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 {
+
+DetachedResourceHandler::DetachedResourceHandler(
+    net::URLRequest* request, ResourceDispatcherHostImpl* rdh)
+    : request_(request),
+      rdh_(rdh),
+      read_buffer_(new net::IOBuffer(kReadBufSize)) {}

[mmenke, 2013/10/11 16:39:07]

Reading may be delayed by the ResourceThrottle.  Think we should only allocate
the read buffer when we first need it, so we don't have a bunch of these hanging
around in memory.

[jkarlin2, 2013/10/11 18:37:04]

Done.

+
+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 false;

[mmenke, 2013/10/11 16:39:07]

Put return false on next line.

[mmenke, 2013/10/11 16:39:07]

Should we be returning true?  Looks like that's what we need to do to be
destroyed, looking at ResourceLoader.

[jkarlin2, 2013/10/11 18:37:04]

My auto-google-formatter did that.  Done.

[jkarlin2, 2013/10/11 18:37:04]

You're right.  Done.

+
+  // If we crash here, figure out what URL the renderer was requesting.
+  // http://crbug.com/107692
+  char url_buf[128];
+  base::strlcpy(url_buf, request_->url().spec().c_str(), arraysize(url_buf));
+  base::debug::Alias(url_buf);

[mmenke, 2013/10/11 16:39:07]

The referenced bug was long since fixed.  Do we need this here?

[jkarlin2, 2013/10/11 18:37:04]

Done.

+
+  TimeTicks completion_time = TimeTicks::Now();
+
+  int error_code = status.error();
+
+  bool was_ignored_by_handler = info->WasIgnoredByHandler();
+
+  DCHECK(status.status() != net::URLRequestStatus::IO_PENDING);
+  // 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;

[mmenke, 2013/10/11 16:39:07]

nit:  Move return onto another line.

[jkarlin2, 2013/10/11 18:37:04]

Auto formatter again.  Done.

+  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;

[mmenke, 2013/10/11 16:39:07]

nit:  Move return onto another line.

[jkarlin2, 2013/10/11 18:37:04]

Done.

+
+  if (rdh_->delegate()) {
+    rdh_->delegate()->OnResponseStarted(request_, info->GetContext(), response,
+                                        info->filter());

[mmenke, 2013/10/11 16:39:07]

Hmm...Wonder about some of the stuff this does, like
AutoLoginPrompter::ShowInfoBarIfPossible, and
OneClickSigninHelper::ShowInfoBarIfPossible.

[jkarlin2, 2013/10/11 18:37:04]

This seems to be an existing issue with prefetch and unrelated to this CL.  But
perhaps a new bug is in order?

+  }
+
+  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 its data to, but we'll never read it.

[mmenke, 2013/10/11 16:39:07]

nit:  Don't use "we" in comments, since it's ambiguous.  One option is to use
passive voice.

[jkarlin2, 2013/10/11 18:37:04]

Done.

+  *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;
+}
+
+}  // namespace content