content::ResourceDispatcherHostImpl changes for stale-while-revalidate

content/browser/loader/null_resource_handler.cc

Index: content/browser/loader/null_resource_handler.cc
diff --git a/content/browser/loader/null_resource_handler.cc b/content/browser/loader/null_resource_handler.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ed81ab381b64fbcdc9ec64fb8391e7118cad46f3
--- /dev/null
+++ b/content/browser/loader/null_resource_handler.cc
@@ -0,0 +1,119 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/browser/loader/null_resource_handler.h"
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "content/browser/loader/resource_message_filter.h"
+#include "content/browser/loader/resource_request_info_impl.h"
+#include "content/public/browser/resource_controller.h"
+#include "content/public/browser/resource_dispatcher_host_delegate.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "net/url_request/redirect_info.h"
+
+namespace {
+// This matches the maximum allocation size of AsyncResourceHandler.
+const int kReadBufSize = 32 * 1024;
+}
+
+namespace content {
+
+const int kNullResourceHandlerDefaultReadTimeoutSecs = 5 * 60;
+
+// The use of base::Unretained in the initialisation of read_timer_ is safe
+// because base::Timer guarantees it will never call the callback after being
+// destroyed.
+NullResourceHandler::NullResourceHandler(net::URLRequest* request,
+                                         ResourceDispatcherHostImpl* rdh,
+                                         base::TimeDelta read_timeout)
+    : ResourceHandler(request),
+      rdh_(rdh),
+      read_timer_(FROM_HERE,
+                  read_timeout,
+                  base::Bind(&NullResourceHandler::OnReadTimeout,
+                             base::Unretained(this)),
+                  false) {
+}
+
+NullResourceHandler::~NullResourceHandler() {
+}
+
+void NullResourceHandler::SetController(ResourceController* controller) {
+  ResourceHandler::SetController(controller);
+}
+
+bool NullResourceHandler::OnUploadProgress(uint64 position, uint64 size) {
+  return true;
+}
+
+bool NullResourceHandler::OnRequestRedirected(
+    const net::RedirectInfo& redirect_info,
+    ResourceResponse* response,
+    bool* defer) {
+  const ResourceRequestInfoImpl* info = GetRequestInfo();
+  if (info->filter() && rdh_->delegate()) {
+    rdh_->delegate()->OnRequestRedirected(redirect_info.new_url, request(),
+                                          info->GetContext(), response);
+  }
+  // We only need to update the redirect in the cache, not its destination.
+  return false;
+}
+
+bool NullResourceHandler::OnResponseStarted(ResourceResponse* response,
+                                            bool* defer) {
+  const ResourceRequestInfoImpl* info = GetRequestInfo();
+  if (!info->filter())
+    return false;
+  if (rdh_->delegate()) {
+    rdh_->delegate()->OnResponseStarted(request(), info->GetContext(), response,
+                                        info->filter());
+  }
+  return true;
+}
+
+bool NullResourceHandler::OnWillStart(const GURL& url, bool* defer) {
+  return true;
+}
+
+bool NullResourceHandler::OnBeforeNetworkStart(const GURL& url, bool* defer) {
+  DCHECK(!read_timer_.IsRunning());
+  read_timer_.Reset();
+  DCHECK(read_timer_.IsRunning());
+  return true;
+}
+
+bool NullResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
+                                     int* buf_size,
+                                     int min_size) {
+  DCHECK_LE(min_size, kReadBufSize);
+  if (!read_buffer_.get())
+    read_buffer_ = new net::IOBuffer(kReadBufSize);
+  *buf = read_buffer_;
+  *buf_size = kReadBufSize;
+  read_timer_.Reset();
+  return true;
+}
+
+bool NullResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
+  return true;
+}
+
+void NullResourceHandler::OnResponseCompleted(
+    const net::URLRequestStatus& status,
+    const std::string& security_info,
+    bool* defer) {
+  return;
+}
+
+void NullResourceHandler::OnDataDownloaded(int bytes_downloaded) {
+  return;
+}
+
+void NullResourceHandler::OnReadTimeout() {
+  controller()->Cancel();
+}
+
+}  // namespace content