Allows prefetch requests to live beyond the renderer by delaying

content/browser/loader/detached_resource_handler.cc

+// Copyright (c) 2013 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/detached_resource_handler.h"
+
+#include <algorithm>
+#include <vector>
+
+#include "base/debug/alias.h"
+#include "base/strings/string_util.h"
+#include "content/browser/devtools/devtools_netlog_observer.h"
+#include "content/browser/loader/resource_dispatcher_host_impl.h"
+#include "content/browser/loader/resource_message_filter.h"
+#include "content/browser/loader/resource_request_info_impl.h"
+#include "content/common/resource_messages.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/url_request.h"
+
+using base::TimeTicks;
+
+namespace content {
+
+namespace {
+
+static const int kReadBufSize = 1024 * 32;
+
+}  // namespace
+
+
+DetachedResourceHandler::DetachedResourceHandler(
+    net::URLRequest* request, ResourceDispatcherHostImpl* rdh)
+    : request_(request), rdh_(rdh) {}
+
+DetachedResourceHandler::~DetachedResourceHandler() {}
+
+bool DetachedResourceHandler::OnResponseCompleted(
+    int request_id, const net::URLRequestStatus& status,
+    const std::string& security_info) {
+  const ResourceRequestInfoImpl* info =
+      ResourceRequestInfoImpl::ForRequest(request_);
+
+  if (!info->filter())
+    return true;
+
+  TimeTicks completion_time = TimeTicks::Now();
+
+  int error_code = status.error();
+
+  bool was_ignored_by_handler = info->WasIgnoredByHandler();
+
+  // If this check fails, then we're in an inconsistent state because all
+  // requests ignored by the handler should be canceled (which should result in
+  // the ERR_ABORTED error code).
+  DCHECK(!was_ignored_by_handler || error_code == net::ERR_ABORTED);
+
+  // TODO(mkosiba): Fix up cases where we create a URLRequestStatus
+  // with a status() != SUCCESS and an error_code() == net::OK.
+  if (status.status() == net::URLRequestStatus::CANCELED &&
+      error_code == net::OK) {
+    error_code = net::ERR_ABORTED;
+  } else if (status.status() == net::URLRequestStatus::FAILED &&
+             error_code == net::OK) {
+    error_code = net::ERR_FAILED;
+  }
+
+  info->filter()->Send(new ResourceMsg_RequestComplete(
+      request_id, error_code, was_ignored_by_handler, security_info,
+      completion_time));
+  return true;
+}
+
+bool DetachedResourceHandler::OnUploadProgress(int request_id, uint64 position,
+                                               uint64 size) {
+  const ResourceRequestInfoImpl* info =
+      ResourceRequestInfoImpl::ForRequest(request_);
+  if (!info->filter())
+    return true;
+  info->filter()->Send(
+      new ResourceMsg_UploadProgress(request_id, position, size));
+  return true;
+}
+
+bool DetachedResourceHandler::OnResponseStarted(int request_id,
+                                                ResourceResponse* response,
+                                                bool* defer) {
+  const ResourceRequestInfoImpl* info =
+      ResourceRequestInfoImpl::ForRequest(request_);
+
+  if (!info->filter())
+    return true;
+
+  if (rdh_->delegate()) {
+    rdh_->delegate()->OnResponseStarted(request_, info->GetContext(), response,
+                                        info->filter());
+  }
+
+  DevToolsNetLogObserver::PopulateResponseInfo(request_, response);
+
+  response->head.request_start = request_->creation_time();
+  response->head.response_start = TimeTicks::Now();
+  info->filter()->Send(
+      new ResourceMsg_ReceivedResponse(request_id, response->head));
+
+  if (request_->response_info().metadata.get()) {
+    std::vector<char> copy(request_->response_info().metadata->data(),
+                           request_->response_info().metadata->data() +
+                               request_->response_info().metadata->size());
+    info->filter()->Send(
+        new ResourceMsg_ReceivedCachedMetadata(request_id, copy));
+  }
+
+  return true;
+}
+
+bool DetachedResourceHandler::OnWillStart(int request_id, const GURL& url,
+                                          bool* defer) {
+  return true;
+}
+
+bool DetachedResourceHandler::OnWillRead(int request_id, net::IOBuffer** buf,
+                                         int* buf_size, int min_size) {
+  // Give the loader something to write to, though it's not going to be read.
+  if (!read_buffer_)
+    read_buffer_ = new net::IOBuffer(kReadBufSize);
+
+  *buf = read_buffer_.get();
+  *buf_size = kReadBufSize;
+  return true;
+}
+
+bool DetachedResourceHandler::OnReadCompleted(int request_id, int bytes_read,
+                                              bool* defer) {
+  return true;
+}
+
+bool DetachedResourceHandler::OnRequestRedirected(int request_id,
+                                                  const GURL& new_url,
+                                                  ResourceResponse* response,
+                                                  bool* defer) {
+  return true;
+}
+
+void DetachedResourceHandler::OnDataDownloaded(int request_id,
+                                               int bytes_downloaded) {}
+
+}  // namespace content