Initial PlzNavigate RDH-side logic.

content/browser/loader/navigation_url_loader_core.cc

Index: content/browser/loader/navigation_url_loader_core.cc
diff --git a/content/browser/loader/navigation_url_loader_core.cc b/content/browser/loader/navigation_url_loader_core.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4077f680f2de78befa4e966f1fa8fd5dc7f343ca
--- /dev/null
+++ b/content/browser/loader/navigation_url_loader_core.cc
@@ -0,0 +1,156 @@
+// Copyright 2014 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/navigation_url_loader_core.h"
+
+#include "base/bind.h"
+#include "content/browser/frame_host/frame_tree_node.h"
+#include "content/browser/frame_host/navigation_request_info.h"
+#include "content/browser/loader/navigation_resource_handler.h"
+#include "content/browser/loader/resource_dispatcher_host_impl.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/stream_handle.h"
+#include "content/public/common/resource_response.h"
+#include "net/base/net_errors.h"
+#include "net/url_request/redirect_info.h"
+
+namespace content {
+
+NavigationURLLoaderCore::NavigationURLLoaderCore(
+    NavigationURLLoader::Delegate* delegate)
+    : delegate_(delegate),
+      resource_handler_(NULL) {
+}
+
+void NavigationURLLoaderCore::StartRequest(
+    BrowserContext* browser_context,
+    int64 frame_tree_node_id,
+    const NavigationRequestInfo& request_info,
+    ResourceRequestBody* request_body) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&NavigationURLLoaderCore::StartRequestOnIOThread, this,
+                 browser_context->GetResourceContext(),
+                 frame_tree_node_id, request_info,
+                 make_scoped_refptr(request_body)));
+}
+
+void NavigationURLLoaderCore::Resume() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&NavigationURLLoaderCore::ResumeOnIOThread, this));
+}
+
+void NavigationURLLoaderCore::Cancel() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  delegate_ = NULL;
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&NavigationURLLoaderCore::CancelOnIOThread, this));
+}
+
+void NavigationURLLoaderCore::RequestRedirectedOnIOThread(
+    const net::RedirectInfo& redirect_info,
+    ResourceResponse* response) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&NavigationURLLoaderCore::CallOnRequestRedirected,
+                 this, redirect_info, make_scoped_refptr(response)));
+}
+
+void NavigationURLLoaderCore::ResponseStartedOnIOThread(
+    ResourceResponse* response,
+    scoped_ptr<StreamHandle> body) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  resource_handler_ = NULL;
+  BrowserThread::PostTask(

[clamy, 2014/09/12 20:51:25]

Are we sure that after this point ResourceResponse will not be accessed on the
IO thread anymore?

[davidben, 2014/09/19 18:30:50]

I believe it is safe. I tried to ensure this by making ResourceResponse always
passed as a scoped_ptr, but the problem is that BufferedResourceHandler's
dispatch logic is incompatible with this.

I'd like to move the dispatch part of BRH up to NavigationRequest, which would
allow us to scoped_ptr it. But that's further off, so I've made a copy and left
a TODO that we can optimize out the copy once we un-refcount it.

+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&NavigationURLLoaderCore::CallOnResponseStarted,
+                 this, make_scoped_refptr(response), base::Passed(&body)));
+}
+
+void NavigationURLLoaderCore::RequestFailedOnIOThread(int net_error) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  resource_handler_ = NULL;
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&NavigationURLLoaderCore::CallOnRequestFailed,
+                 this, net_error));
+}
+
+NavigationURLLoaderCore::~NavigationURLLoaderCore() {
+  DCHECK(!delegate_);
+  DCHECK(!resource_handler_);

[clamy, 2014/09/12 20:51:25]

When is resource_handler_ set to null? In fact, I think a comment should clarify
a bit the lifetime, destruction order and where the pointer to the various
components are set to null in the main cases (request proceeds normally, request
cancelled on the UI thread, request cancelled on the IO thread), as it is not
immediately explicit.

[davidben, 2014/09/19 18:30:49]

I've switched all the NULL setting to explicit calls which should hopefully be
clearer. Also moved the BeginNavigationRequest return code out. Core no longer
has any interesting logic outside of thread shuffling which hopefully is
clearer. Also added a comment on why these should be NULL at this point.

+}
+
+void NavigationURLLoaderCore::StartRequestOnIOThread(
+    ResourceContext* resource_context,
+    int64 frame_tree_node_id,
+    const NavigationRequestInfo& request_info,
+    ResourceRequestBody* request_body) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (!ResourceDispatcherHostImpl::Get()->BeginNavigationRequest(
+          resource_context, frame_tree_node_id, request_info, request_body,
+          this)) {
+    DCHECK(!resource_handler_);
+    RequestFailedOnIOThread(net::ERR_ABORTED);

[clamy, 2014/09/12 20:51:25]

Shouldn't we return here?

[davidben, 2014/09/19 18:30:50]

Oof. Done. Also added a test that exercises this path.

+  }
+
+  DCHECK(resource_handler_);
+}
+
+void NavigationURLLoaderCore::ResumeOnIOThread() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (resource_handler_)
+    resource_handler_->Resume();
+}
+
+void NavigationURLLoaderCore::CancelOnIOThread() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (resource_handler_)
+    resource_handler_->Cancel();
+}
+
+void NavigationURLLoaderCore::CallOnRequestRedirected(
+    const net::RedirectInfo& redirect_info,
+    ResourceResponse* response) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (delegate_)
+    delegate_->OnRequestRedirected(redirect_info, response);
+}
+
+void NavigationURLLoaderCore::CallOnResponseStarted(
+    ResourceResponse* response,
+    scoped_ptr<StreamHandle> body) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // If |delegate_| is NULL, OnResponseStarted on the IO thread raced with
+  // Cancel on the UI thread. |body| will be destructed and the request released
+  // at that point.
+  if (delegate_)
+    delegate_->OnResponseStarted(response, body.Pass());
+}
+
+void NavigationURLLoaderCore::CallOnRequestFailed(int net_error) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (delegate_)
+    delegate_->OnRequestFailed(net_error);
+}
+
+}  // namespace content