Use mojo for Chrome Loading, Part 1

content/browser/loader/url_loader_factory_impl.cc

+// Copyright 2016 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/url_loader_factory_impl.h"
+
+#include <memory>
+
+#include "base/memory/ptr_util.h"
+#include "base/memory/weak_ptr.h"
+#include "content/browser/loader/resource_dispatcher_host_impl.h"
+#include "content/browser/loader/resource_message_filter.h"
+#include "content/common/resource_messages.h"
+#include "content/common/resource_request.h"
+#include "content/common/url_loader.mojom.h"
+
+namespace content {
+
+namespace {
+
+// This class is an implementation of mojom::URLLoader which is a resource
+// loader interface with Mojo.
+class URLLoaderImpl final : public mojom::URLLoader {
+ public:
+  // Creates a URLLoader. This function returns nothing and registers the
+  // created instance to the ResourceDispatcherHostImpl instead.
+  static void Create(scoped_refptr<ResourceMessageFilter> filter,
+                     mojom::URLLoaderRequest request) {
+    int child_id = filter->child_id();
+    ResourceDispatcherHostImpl::Get()->AddUninitiatedURLLoader(

[mmenke, 2016/05/25 16:17:20]

"Uninitiated" seems like a more ambiguous term for "NotStarted" / "Unstarted". 
Could we rename this?

[yhirano, 2016/05/26 15:42:44]

Done.

+        child_id,
+        base::WrapUnique(new URLLoaderImpl(filter.get(), std::move(request))));

[mmenke, 2016/05/25 16:17:20]

This ownership model seems really weird and non-obvious.  "Create" creates a
URLLoader, and gives it to the RDH.  And then calling Load on a URLLoader (Not
quite sure how someone finds it to call load on in the first place...) makes the
object take ownership of itself back...Just to pass ownership *back* to the RDH.

Can we do something better here?  I guess the mojo code doesn't expect to own
the mojo communications objects itself?

[yhirano, 2016/05/26 15:42:44]

URLLoaderImpl uses mojo::Binding[1]. mojo::Binding doesn't take target's
ownership, as written in the class comment. mojom::URLLoader functions are
called via mojo::Binding, I think.
I think you are talking about mojo::StrongBinding[2], but I wanted to use
Binding because I wanted to unbind the loader when the associated ResourceLoader
is destructed and I was not sure I could do that with StringBinding.

1:
https://code.google.com/p/chromium/codesearch#chromium/src/mojo/public/cpp/bi...
2:
https://code.google.com/p/chromium/codesearch#chromium/src/mojo/public/cpp/bi...

+  }
+
+  ~URLLoaderImpl() override {}
+
+  void Load(int32_t request_id,
+            const ResourceRequest& request,
+            mojom::URLLoaderClientPtr client) override {
+    DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+    ResourceMessageFilter* filter = resource_message_filter_.get();
+    if (!filter) {
+      // TODO(yhirano): Cancel the request.
+      return;
+    }
+
+    std::unique_ptr<mojom::URLLoader> that =
+        ResourceDispatcherHostImpl::Get()->TakeUninitiatedURLLoader(this);
+    DCHECK(that);
+
+    // TODO(yhirano): Provide the right routing ID.
+    const int routing_id = 0;
+    ResourceDispatcherHostImpl* rdh = ResourceDispatcherHostImpl::Get();
+    rdh->OnRequestResourceWithMojo(routing_id, request_id, request,
+                                   std::move(that), std::move(client), filter);
+  }
+  void FollowRedirect() override {}
+  void Cancel() override {}
+
+ private:
+  URLLoaderImpl(ResourceMessageFilter* filter,
+                mojo::InterfaceRequest<mojom::URLLoader> request)
+      : resource_message_filter_(filter->GetWeakPtr()),
+        binding_(this, std::move(request)) {}
+
+  base::WeakPtr<ResourceMessageFilter> resource_message_filter_;
+  mojo::Binding<mojom::URLLoader> binding_;
+};
+
+}  // namespace
+
+URLLoaderFactoryImpl::URLLoaderFactoryImpl(
+    scoped_refptr<ResourceMessageFilter> resource_message_filter,
+    mojo::InterfaceRequest<mojom::URLLoaderFactory> request)
+    : resource_message_filter_(resource_message_filter),
+      binding_(this, std::move(request)) {}
+
+URLLoaderFactoryImpl::~URLLoaderFactoryImpl() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+}
+
+void URLLoaderFactoryImpl::CreateURLLoader(mojom::URLLoaderRequest request) {
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&URLLoaderImpl::Create, resource_message_filter_,
+                 base::Passed(std::move(request))));
+}
+
+}  // namespace content