PlzNavigate: Add first version of NavigationURLLoader.

content/browser/loader/navigation_url_loader_core.h

+// 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.
+
+#ifndef CONTENT_BROWSER_LOADER_NAVIGATION_URL_LOADER_CORE_H_
+#define CONTENT_BROWSER_LOADER_NAVIGATION_URL_LOADER_CORE_H_
+
+#include "base/basictypes.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "content/browser/loader/navigation_url_loader.h"
+
+namespace net {
+class URLRequest;
+struct RedirectInfo;
+}
+
+namespace content {
+
+class BrowserContext;
+class FrameTreeNode;
+class NavigationResourceHandler;
+class ResourceContext;
+class ResourceHandler;
+class ResourceRequestBody;
+class StreamHandle;
+struct ResourceResponse;
+
+// Part of the implementation of NavigationURLLoaderImpl. It is jointly owned by
+// NavigationURLLoaderImpl on the UI thread and NavigationResourceHandler and IO
+// thread. It passes signals across threads between the two objects.

[mmenke, 2014/10/20 18:52:13]

This currently doesn't pass messages to the NavigationURLLoaderImpl - it only
passes them to the NavigationURLLoader::Delegate.  I think this is a mistake -
it should only talk to the NavigationURLLoader on the UI thread, and that should
talk to the delegate.

[davidben, 2014/10/22 01:32:37]

Done.

+class NavigationURLLoaderCore
+    : public base::RefCountedThreadSafe<NavigationURLLoaderCore> {

[mmenke, 2014/10/20 18:52:13]

Do we really need a refcounted class for this?  Seems like we could just make
this an IO thread class, and have this and the NavigationURLLoader post messages
to each other via weak pointers.

[mmenke, 2014/10/20 18:55:18]

Actually, I need to figure out ownership semantics, but do we really not know
which will outlive the other, the *Loader or the *Handler?

[davidben, 2014/10/22 01:32:37]

Reworked so that Core is owned by Impl, but cross-thread. Handler/Core is still
screwy because the ResourceLoader isn't owned by the Core (yet...).

+ public:
+  NavigationURLLoaderCore();
+
+  // Called on the UI thread to start the request.
+  void StartRequest(BrowserContext* browser_context,
+                    int64 frame_tree_node_id,
+                    const CommonNavigationParams& common_params,
+                    scoped_ptr<NavigationRequestInfo> request_info,
+                    ResourceRequestBody* request_body);
+
+  // Called on the UI thread to set the delegate.
+  void set_delegate(NavigationURLLoader::Delegate* delegate) {
+    delegate_ = delegate;
+  }
+
+  // Called on the UI thread to resume a deferred redirect.
+  void FollowRedirect();
+
+  // Called on the UI thread to cancel a request, if it has not completed.
+  //
+  // Note: once the response headers are received, the request is considered

[nasko, 2014/10/20 13:52:18]

nit: No need for an empty line above.

[davidben, 2014/10/22 01:32:37]

This class got reworked.

+  // completed from the perspective of NavigationURLLoader and ownership is
+  // transferred to the StreamHandle containing the body.
+  void Cancel();
+
+  // Called on the IO thread to set the resource handler.
+  void set_resource_handler(NavigationResourceHandler* resource_handler) {
+    resource_handler_ = resource_handler;
+  }
+
+  // Called on the IO thread when the request is redirected. The request will
+  // resume processing on the next call to FollowRedirect on the UI thread.
+  void RequestRedirectedOnIOThread(const net::RedirectInfo& redirect_info,
+                                   ResourceResponse* response);
+
+  // Called on the IO thread when the response started.
+  void ResponseStartedOnIOThread(ResourceResponse* response,
+                                 scoped_ptr<StreamHandle> body);
+
+  // Called on the IO thread if the request failed before giving a response.
+  void RequestFailedOnIOThread(int net_error);
+
+ private:
+  friend class base::RefCountedThreadSafe<NavigationURLLoaderCore>;
+
+  ~NavigationURLLoaderCore();
+
+  void StartRequestOnIOThread(ResourceContext* resource_context,
+                              int64 frame_tree_node_id,
+                              const CommonNavigationParams& common_params,
+                              scoped_ptr<NavigationRequestInfo> request_info,
+                              ResourceRequestBody* request_body);
+  void FollowRedirectOnIOThread();
+  void CancelOnIOThread();
+
+  void CallOnRequestRedirected(const net::RedirectInfo& redirect_info,
+                               ResourceResponse* response);
+  void CallOnResponseStarted(ResourceResponse* response,
+                             scoped_ptr<StreamHandle> body);
+  void CallOnRequestFailed(int net_error);
+
+  NavigationURLLoader::Delegate* delegate_;
+  NavigationResourceHandler* resource_handler_;
+
+  DISALLOW_COPY_AND_ASSIGN(NavigationURLLoaderCore);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_LOADER_NAVIGATION_URL_LOADER_H_