Implement Mojo SyncLoad

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 "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/loader/resource_message_filter.h"
 #include "content/common/resource_request.h"
 #include "content/common/url_loader.mojom.h"
 #include "content/public/browser/browser_thread.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 
 namespace content {
 
+namespace {
+
+void DispatchSyncLoadResult(
+    const URLLoaderFactoryImpl::SyncLoadCallback& callback,
+    const SyncLoadResult* result) {
+  if (!result) {

[kinuko, 2016/10/13 05:36:00]

sorry, could you teach me when this could happen?

[tzik, 2016/10/13 06:31:26]

This can be called from the dtor of SyncResourceHandler. It's probably on a
channel error or a network error?
https://chromium.googlesource.com/chromium/src/+/d41ce0ce55bb756c85f63c94ddac...

[kinuko, 2016/10/13 11:39:01]

I see thanks.  Maybe worth commenting that result could be null when
SyncResourceHandler gets destructed?

[tzik, 2016/10/14 08:02:31]

Done.

+    SyncLoadResult failure;
+    failure.error_code = net::ERR_FAILED;
+    callback.Run(failure);
+    return;
+  }
+
+  callback.Run(*result);
+}
+
+} // namespace
+
 URLLoaderFactoryImpl::URLLoaderFactoryImpl(
     scoped_refptr<ResourceMessageFilter> resource_message_filter)
     : resource_message_filter_(std::move(resource_message_filter)) {
   DCHECK(resource_message_filter_);
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
 URLLoaderFactoryImpl::~URLLoaderFactoryImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
 void URLLoaderFactoryImpl::CreateLoaderAndStart(
     mojom::URLLoaderRequest request,
     int32_t routing_id,
     int32_t request_id,
     const ResourceRequest& url_request,
     mojom::URLLoaderClientPtr client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   ResourceDispatcherHostImpl* rdh = ResourceDispatcherHostImpl::Get();
   rdh->OnRequestResourceWithMojo(routing_id, request_id, url_request,
                                  std::move(request), std::move(client),
                                  resource_message_filter_.get());
 }
 
+void URLLoaderFactoryImpl::SyncLoad(int32_t routing_id,
+                                    int32_t request_id,
+                                    const ResourceRequest& url_request,
+                                    const SyncLoadCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  SyncLoadResult result;

[kinuko, 2016/10/13 05:36:00]

Do we need this line?

[tzik, 2016/10/13 06:31:26]

Oops. No, it's needed. Removed.

+  ResourceDispatcherHostImpl* rdh = ResourceDispatcherHostImpl::Get();
+  rdh->OnSyncLoadWithMojo(routing_id, request_id, url_request,
+                          resource_message_filter_.get(),
+                          base::Bind(&DispatchSyncLoadResult, callback));
+}
+
 void URLLoaderFactoryImpl::Create(
     scoped_refptr<ResourceMessageFilter> filter,
     mojo::InterfaceRequest<mojom::URLLoaderFactory> request) {
   mojo::MakeStrongBinding(
       base::WrapUnique(new URLLoaderFactoryImpl(std::move(filter))),
       std::move(request));
 }
 
 }  // namespace content