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..772bfe60de26479ee7b810fd5ce1242c00f5fcc4
--- /dev/null
+++ b/content/browser/loader/navigation_url_loader_core.cc
@@ -0,0 +1,157 @@
+// 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()
+    : delegate_(NULL),
+      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,

[mmenke, 2014/09/23 17:22:45]

Should include "base/location.h" for FROM_HERE

[davidben, 2014/10/03 16:27:52]

Done.

+      base::Bind(&NavigationURLLoaderCore::StartRequestOnIOThread, this,
+                 browser_context->GetResourceContext(),
+                 frame_tree_node_id, request_info,
+                 make_scoped_refptr(request_body)));
+}
+
+void NavigationURLLoaderCore::FollowRedirect() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&NavigationURLLoaderCore::FollowRedirectOnIOThread, this));
+}
+
+void NavigationURLLoaderCore::Cancel() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  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));
+
+  // Make a copy of the ResourceResponse before it is passed to another thread.
+  //
+  // TODO(davidben): This copy could be avoided if ResourceResponse weren't
+  // reference counted and the loader stack passed unique ownership of the
+  // response. https://crbug.com/416050
+  scoped_refptr<ResourceResponse> response_copy = new ResourceResponse;
+  response_copy->head = response->head;

[mmenke, 2014/09/23 17:22:45]

Copying ResourceResponse is allowed, right?  So we can just use response_copy =
new ResourceResponse(*response);

[davidben, 2014/10/03 16:27:52]

It doesn't actually have a copy constructor, sadly. I added a DeepCopy method
which a sad TODO about ref-counted modifiable structs.

+
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&NavigationURLLoaderCore::CallOnResponseStarted,
+                 this, response_copy, base::Passed(&body)));
+}
+
+void NavigationURLLoaderCore::RequestFailedOnIOThread(int net_error) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&NavigationURLLoaderCore::CallOnRequestFailed,
+                 this, net_error));
+}
+
+NavigationURLLoaderCore::~NavigationURLLoaderCore() {

[nasko, 2014/09/24 21:15:34]

Which thread should this object be destroyed on? Can we DCHECK it?

[davidben, 2014/10/03 16:27:52]

It actually could be either, which is kinda weird. But this object doesn't
actually have state. I think URLFetcherCore works like this too.

The other option I see would be for the Core to be an IO-thread object, not
ref-counted, and just owned by the NavigationURLLoaderImpl from the UI thread.
(So when the UI thread object decides it's time for the Core to die, it
PostTasks a delete.) The Core needs to call back to the UI thread Impl, so it
gets passed a UI-thread WeakPtr when being constructed.

And then Core and Handler have non-owning pointers to each other and make sure
to disconnect appropriately when either side goes away. That part is kind of
silly and mostly a side effect of RDH owning the ResourceLoader rather than the
Core. Matt and I have been talking about refactoring the RDH, but I didn't want
to block PlzNavigate on that. (Hence hiding all the thread stuff behind this
API.)

Anyway, I can switch it to that version if you prefer. This seemed a slightly
simpler mechanism.

+  // The core may outlive either the delegate or the resource handler, so each

[nasko, 2014/09/24 21:15:34]

"may" or "should"? If it is "may", then there is a case where it doesn't, which
will make the DCHECKs below fire, no?

[davidben, 2014/10/03 16:27:52]

Rephrased to be slightly less confusing hopefully.

+  // should NULL references on detach. At this point, both should be NULL.
+  DCHECK(!delegate_);
+  DCHECK(!resource_handler_);
+}
+
+void NavigationURLLoaderCore::StartRequestOnIOThread(
+    ResourceContext* resource_context,
+    int64 frame_tree_node_id,
+    const NavigationRequestInfo& request_info,
+    ResourceRequestBody* request_body) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  ResourceDispatcherHostImpl::Get()->BeginNavigationRequest(
+      resource_context, frame_tree_node_id, request_info, request_body,
+      this);
+}
+
+void NavigationURLLoaderCore::FollowRedirectOnIOThread() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (resource_handler_)
+    resource_handler_->FollowRedirect();
+}
+
+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