Clone service_manager::Connector for IO thread

URLLoaderThrottleProviderImpl and WebSocketHandshakeThrottleProviderImpl
used content::RenderThread::Get()->GetConnector() to connect mojo
interfaces. This prevented us from creating these throttle providers
on the IO thread. To allow these throttle providers can be constructed
without going to the main thread, create a clone of the main thread's
connector in ChromeContentRendererClient::RenderThreadStarted().
The cloned connector is bound to the IO thread and will be used
to create throttle providers for off-the-main-thread service worker
startup.

Bug: 989781
Change-Id: Ic4d20813e18c6238700545946cbcfd6f4534d974
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1724754Reviewed-by: Scott Violet <sky@chromium.org>
Reviewed-by: Ken Rockot <rockot@google.com>
Commit-Queue: Kenichi Ishibashi <bashi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#684169}

chrome/renderer/chrome_content_renderer_client.cc

@@ -328,7 +328,10 @@ ChromeContentRendererClient::ChromeContentRendererClient()
 #endif
 }
 
-ChromeContentRendererClient::~ChromeContentRendererClient() = default;
+ChromeContentRendererClient::~ChromeContentRendererClient() {
+  DCHECK(!render_thread_connector_for_io_thread_ ||
+         !render_thread_connector_for_io_thread_->IsBound());
+}
 
 void ChromeContentRendererClient::RenderThreadStarted() {
   RenderThread* thread = RenderThread::Get();
@@ -353,6 +356,9 @@ void ChromeContentRendererClient::RenderThreadStarted() {
       thread->GetIOTaskRunner(), thread->GetConnector());
 #endif
 
+  io_thread_task_runner_ = thread->GetIOTaskRunner();
+  render_thread_connector_for_io_thread_ = thread->GetConnector()->Clone();
+
   chrome_observer_.reset(new ChromeRenderThreadObserver());
   web_cache_impl_.reset(new web_cache::WebCacheImpl());
 
@@ -1361,7 +1367,16 @@ ChromeRenderThreadObserver* ChromeContentRendererClient::GetChromeObserver()
 
 std::unique_ptr<content::WebSocketHandshakeThrottleProvider>
 ChromeContentRendererClient::CreateWebSocketHandshakeThrottleProvider() {
-  return std::make_unique<WebSocketHandshakeThrottleProviderImpl>();
+  if (content::RenderThread::Get()) {
+    return std::make_unique<WebSocketHandshakeThrottleProviderImpl>(
+        content::RenderThread::Get()->GetConnector());
+  }
+  if (io_thread_task_runner_->BelongsToCurrentThread()) {
+    return std::make_unique<WebSocketHandshakeThrottleProviderImpl>(
+        render_thread_connector_for_io_thread_.get());
+  }
+  NOTREACHED();
+  return nullptr;
 }
 
 std::unique_ptr<blink::WebSpeechSynthesizer>
@@ -1570,7 +1585,16 @@ GURL ChromeContentRendererClient::OverrideFlashEmbedWithHTML(const GURL& url) {
 std::unique_ptr<content::URLLoaderThrottleProvider>
 ChromeContentRendererClient::CreateURLLoaderThrottleProvider(
     content::URLLoaderThrottleProviderType provider_type) {
-  return std::make_unique<URLLoaderThrottleProviderImpl>(provider_type, this);
+  if (content::RenderThread::Get()) {
+    return std::make_unique<URLLoaderThrottleProviderImpl>(
+        content::RenderThread::Get()->GetConnector(), provider_type, this);
+  }
+  if (io_thread_task_runner_->BelongsToCurrentThread()) {
+    return std::make_unique<URLLoaderThrottleProviderImpl>(
+        render_thread_connector_for_io_thread_.get(), provider_type, this);
+  }
+  NOTREACHED();
+  return nullptr;
 }
 
 blink::WebFrame* ChromeContentRendererClient::FindFrame(

chrome/renderer/chrome_content_renderer_client.h

@@ -295,6 +295,12 @@ class ChromeContentRendererClient
 
   service_manager::BinderRegistry registry_;
 
+  // These are initialized in RenderThreadStarted() and used to create throttle
+  // providers on the IO thread.
+  scoped_refptr<base::SingleThreadTaskRunner> io_thread_task_runner_;
+  std::unique_ptr<service_manager::Connector>
+      render_thread_connector_for_io_thread_;
+
   DISALLOW_COPY_AND_ASSIGN(ChromeContentRendererClient);
 };
 

chrome/renderer/url_loader_throttle_provider_impl.cc

@@ -112,20 +112,18 @@ void SetExtensionThrottleManagerTestPolicy(
 }  // namespace
 
 URLLoaderThrottleProviderImpl::URLLoaderThrottleProviderImpl(
+    service_manager::Connector* connector,
     content::URLLoaderThrottleProviderType type,
     ChromeContentRendererClient* chrome_content_renderer_client)
     : type_(type),
       chrome_content_renderer_client_(chrome_content_renderer_client) {
   DETACH_FROM_THREAD(thread_checker_);
-
-  content::RenderThread::Get()->GetConnector()->BindInterface(
-      content::mojom::kBrowserServiceName,
-      mojo::MakeRequest(&safe_browsing_info_));
+  connector->BindInterface(content::mojom::kBrowserServiceName,
+                           mojo::MakeRequest(&safe_browsing_info_));
 
   if (data_reduction_proxy::params::IsEnabledWithNetworkService()) {
-    content::RenderThread::Get()->GetConnector()->BindInterface(
-        content::mojom::kBrowserServiceName,
-        mojo::MakeRequest(&data_reduction_proxy_info_));
+    connector->BindInterface(content::mojom::kBrowserServiceName,
+                             mojo::MakeRequest(&data_reduction_proxy_info_));
   }
 }
 

chrome/renderer/url_loader_throttle_provider_impl.h

@@ -22,6 +22,10 @@ namespace data_reduction_proxy {
 class DataReductionProxyThrottleManager;
 }
 
+namespace service_manager {
+class Connector;
+}
+
 class ChromeContentRendererClient;
 
 // Instances must be constructed on the render thread, and then used and
@@ -30,6 +34,7 @@ class URLLoaderThrottleProviderImpl
     : public content::URLLoaderThrottleProvider {
  public:
   URLLoaderThrottleProviderImpl(
+      service_manager::Connector* connector,
       content::URLLoaderThrottleProviderType type,
       ChromeContentRendererClient* chrome_content_renderer_client);
 

chrome/renderer/websocket_handshake_throttle_provider_impl.cc

@@ -12,12 +12,11 @@
 #include "services/service_manager/public/cpp/connector.h"
 #include "third_party/blink/public/platform/websocket_handshake_throttle.h"
 
-WebSocketHandshakeThrottleProviderImpl::
-    WebSocketHandshakeThrottleProviderImpl() {
+WebSocketHandshakeThrottleProviderImpl::WebSocketHandshakeThrottleProviderImpl(
+    service_manager::Connector* connector) {
   DETACH_FROM_THREAD(thread_checker_);
-  content::RenderThread::Get()->GetConnector()->BindInterface(
-      content::mojom::kBrowserServiceName,
-      mojo::MakeRequest(&safe_browsing_info_));
+  connector->BindInterface(content::mojom::kBrowserServiceName,
+                           mojo::MakeRequest(&safe_browsing_info_));
 }
 
 WebSocketHandshakeThrottleProviderImpl::

chrome/renderer/websocket_handshake_throttle_provider_impl.h

@@ -12,12 +12,17 @@
 #include "components/safe_browsing/common/safe_browsing.mojom.h"
 #include "content/public/renderer/websocket_handshake_throttle_provider.h"
 
+namespace service_manager {
+class Connector;
+}
+
 // This must be constructed on the render thread, and then used and destructed
 // on a single thread, which can be different from the render thread.
 class WebSocketHandshakeThrottleProviderImpl final
     : public content::WebSocketHandshakeThrottleProvider {
  public:
-  WebSocketHandshakeThrottleProviderImpl();
+  explicit WebSocketHandshakeThrottleProviderImpl(
+      service_manager::Connector* connector);
   ~WebSocketHandshakeThrottleProviderImpl() override;
 
   // Implements content::WebSocketHandshakeThrottleProvider.