Remove the WorkerThread InterfaceProvider.

Migrate the remaining interfaces accessed via
WorkerThread::GetInterfaceProvider() to use
ExecutionContext::GetInterfaceProvider():
- PaymentManager
- PermissionService
- WebSocket

Bug: 734210
Change-Id: Ib33c8783bbb490bd4bda5dd31da2a72ab218d03b
Reviewed-on: https://chromium-review.googlesource.com/743102
Commit-Queue: Sam McNally <sammc@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Cr-Commit-Position: refs/heads/master@{#513053}

content/browser/renderer_host/render_process_host_impl.cc

@@ -1790,17 +1790,6 @@ void RenderProcessHostImpl::RegisterMojoInterfaces() {
       registry.get(), base::Bind(&ForwardRequest<device::mojom::BatteryMonitor>,
                                  device::mojom::kServiceName));
 
-  AddUIThreadInterface(
-      registry.get(),
-      base::Bind(&PermissionServiceContext::CreateService,
-                 base::Unretained(permission_service_context_.get())));
-
-  AddUIThreadInterface(
-      registry.get(),
-      base::Bind(
-          &PaymentAppContextImpl::CreatePaymentManager,
-          base::Unretained(storage_partition_impl_->GetPaymentAppContext())));
-
   AddUIThreadInterface(
       registry.get(),
       base::Bind(&RenderProcessHostImpl::CreateOffscreenCanvasProvider,
@@ -1912,12 +1901,6 @@ void RenderProcessHostImpl::RegisterMojoInterfaces() {
   registry->AddInterface(
       base::Bind(&CreateReportingServiceProxy, storage_partition_impl_));
 
-  // This is to support usage of WebSockets in cases in which there is no
-  // associated RenderFrame (e.g., Shared Workers).
-  AddUIThreadInterface(registry.get(),
-                       base::Bind(&WebSocketManager::CreateWebSocket, GetID(),
-                                  MSG_ROUTING_NONE));
-
   AddUIThreadInterface(registry.get(), base::Bind(&FieldTrialRecorder::Create));
 
   associated_interfaces_.reset(new AssociatedInterfaceRegistryImpl());

content/browser/renderer_host/render_process_host_impl.h

@@ -388,6 +388,10 @@ class CONTENT_EXPORT RenderProcessHostImpl
   // globally-used spare RenderProcessHost at any time.
   static RenderProcessHost* GetSpareRenderProcessHostForTesting();
 
+  PermissionServiceContext& permission_service_context() {
+    return *permission_service_context_;
+  };
+
  protected:
   // A proxy for our IPC::Channel that lives on the IO thread.
   std::unique_ptr<IPC::ChannelProxy> channel_;

content/browser/worker_interface_binders.cc

@@ -6,6 +6,12 @@
 
 #include <utility>
 
+#include "base/bind.h"
+#include "content/browser/payments/payment_manager.h"
+#include "content/browser/permissions/permission_service_context.h"
+#include "content/browser/renderer_host/render_process_host_impl.h"
+#include "content/browser/storage_partition_impl.h"
+#include "content/browser/websockets/websocket_manager.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
@@ -71,6 +77,26 @@ void WorkerInterfaceBinders::InitializeParameterizedBinderRegistry() {
   parameterized_binder_registry_.AddInterface(
       base::Bind(&ForwardRequest<shape_detection::mojom::TextDetection>,
                  shape_detection::mojom::kServiceName));
+  parameterized_binder_registry_.AddInterface(
+      base::Bind([](blink::mojom::WebSocketRequest request,
+                    RenderProcessHost* host, const url::Origin& origin) {
+        WebSocketManager::CreateWebSocket(host->GetID(), MSG_ROUTING_NONE,
+                                          std::move(request));
+      }));
+  parameterized_binder_registry_.AddInterface(
+      base::Bind([](payments::mojom::PaymentManagerRequest request,
+                    RenderProcessHost* host, const url::Origin& origin) {
+        static_cast<StoragePartitionImpl*>(host->GetStoragePartition())
+            ->GetPaymentAppContext()
+            ->CreatePaymentManager(std::move(request));
+      }));
+  parameterized_binder_registry_.AddInterface(
+      base::Bind([](blink::mojom::PermissionServiceRequest request,
+                    RenderProcessHost* host, const url::Origin& origin) {
+        static_cast<RenderProcessHostImpl*>(host)
+            ->permission_service_context()
+            .CreateService(std::move(request));
+      }));
 }
 
 }  // namespace

content/public/app/mojo/content_browser_manifest.json

@@ -26,10 +26,8 @@
           "blink::mojom::MimeRegistry",
           "blink::mojom::NotificationService",
           "blink::mojom::OffscreenCanvasProvider",
-          "blink::mojom::PermissionService",
           "blink::mojom::ReportingServiceProxy",
           "blink::mojom::WebDatabaseHost",
-          "blink::mojom::WebSocket",
           "content::mojom::FieldTrialRecorder",
           "content::mojom::FileUtilitiesHost",
           "content::mojom::FrameSinkProvider",
@@ -49,11 +47,7 @@
           "media::mojom::VideoDecodePerfHistory",
           "memory_coordinator::mojom::MemoryCoordinatorHandle",
           "metrics::mojom::SingleSampleMetricsProvider",
-          "payments::mojom::PaymentManager",
           "resource_coordinator::mojom::ProcessCoordinationUnit",
-          "shape_detection::mojom::BarcodeDetection",
-          "shape_detection::mojom::FaceDetectionProvider",
-          "shape_detection::mojom::TextDetection",
           "ui::mojom::Gpu",
           "viz::mojom::SharedBitmapAllocationNotifier",
           "viz::mojom::CompositingModeReporter"
@@ -177,6 +171,8 @@
     "navigation:dedicated_worker": {
       "provides": {
         "renderer": [
+          "blink::mojom::PermissionService",
+          "payments::mojom::PaymentManager",
           "shape_detection::mojom::BarcodeDetection",
           "shape_detection::mojom::FaceDetectionProvider",
           "shape_detection::mojom::TextDetection"
@@ -186,6 +182,9 @@
     "navigation:service_worker": {
       "provides": {
         "renderer": [
+          "blink::mojom::PermissionService",
+          "blink::mojom::WebSocket",
+          "payments::mojom::PaymentManager",
           "shape_detection::mojom::BarcodeDetection",
           "shape_detection::mojom::FaceDetectionProvider",
           "shape_detection::mojom::TextDetection"
@@ -195,6 +194,9 @@
     "navigation:shared_worker": {
       "provides": {
         "renderer": [
+          "blink::mojom::PermissionService",
+          "blink::mojom::WebSocket",
+          "payments::mojom::PaymentManager",
           "shape_detection::mojom::BarcodeDetection",
           "shape_detection::mojom::FaceDetectionProvider",
           "shape_detection::mojom::TextDetection"

third_party/WebKit/Source/core/workers/WorkerThread.cpp

@@ -58,7 +58,6 @@
 #include "platform/wtf/PtrUtil.h"
 #include "platform/wtf/Threading.h"
 #include "platform/wtf/text/WTFString.h"
-#include "public/platform/InterfaceProvider.h"
 #include "public/platform/Platform.h"
 
 namespace blink {
@@ -70,12 +69,6 @@ namespace {
 // TODO(nhiroki): Adjust the delay based on UMA.
 constexpr TimeDelta kForcibleTerminationDelay = TimeDelta::FromSeconds(2);
 
-void ForwardInterfaceRequest(const std::string& name,
-                             mojo::ScopedMessagePipeHandle handle) {
-  Platform::Current()->GetInterfaceProvider()->GetInterface(name.c_str(),
-                                                            std::move(handle));
-}
-
 }  // namespace
 
 static Mutex& ThreadSetMutex() {
@@ -307,13 +300,6 @@ ExitCode WorkerThread::GetExitCodeForTesting() {
   return exit_code_;
 }
 
-service_manager::InterfaceProvider& WorkerThread::GetInterfaceProvider() {
-  // TODO(https://crbug.com/734210): Instead of forwarding to the process-wide
-  // interface provider a worker-specific interface provider pipe should be
-  // passed in as part of the WorkerThreadStartupData.
-  return interface_provider_;
-}
-
 WorkerThread::WorkerThread(ThreadableLoadingContext* loading_context,
                            WorkerReportingProxy& worker_reporting_proxy)
     : time_origin_(MonotonicallyIncreasingTime()),
@@ -329,8 +315,6 @@ WorkerThread::WorkerThread(ThreadableLoadingContext* loading_context,
   DCHECK(IsMainThread());
   MutexLocker lock(ThreadSetMutex());
   WorkerThreads().insert(this);
-  interface_provider_.Forward(
-      ConvertToBaseCallback(WTF::Bind(&ForwardInterfaceRequest)));
 }
 
 void WorkerThread::ScheduleToTerminateScriptExecution() {

third_party/WebKit/Source/core/workers/WorkerThread.h

@@ -45,7 +45,6 @@
 #include "platform/wtf/Optional.h"
 #include "platform/wtf/RefPtr.h"
 #include "public/platform/WebThread.h"
-#include "services/service_manager/public/cpp/interface_provider.h"
 #include "v8/include/v8.h"
 
 namespace blink {
@@ -171,8 +170,6 @@ class CORE_EXPORT WorkerThread : public WebThread::TaskObserver {
     return global_scope_scheduler_.get();
   }
 
-  service_manager::InterfaceProvider& GetInterfaceProvider();
-
   // For ServiceWorkerScriptStreaming. Returns nullptr otherwise.
   virtual InstalledScriptsManager* GetInstalledScriptsManager() {
     return nullptr;
@@ -284,10 +281,6 @@ class CORE_EXPORT WorkerThread : public WebThread::TaskObserver {
 
   CrossThreadPersistent<ParentFrameTaskRunners> parent_frame_task_runners_;
 
-  // Mojo interface provider serving interface requests scoped to this worker
-  // context.
-  service_manager::InterfaceProvider interface_provider_;
-
   // Tasks managed by this scheduler are canceled when the global scope is
   // closed.
   std::unique_ptr<scheduler::WorkerGlobalScopeScheduler>

third_party/WebKit/Source/modules/cookie_store/GlobalCookieStore.cpp

@@ -12,8 +12,8 @@
 #include "modules/cookie_store/CookieStore.h"
 #include "platform/Supplementable.h"
 #include "platform/heap/Handle.h"
-#include "public/platform/InterfaceProvider.h"
 #include "services/network/public/interfaces/restricted_cookie_manager.mojom-blink.h"
+#include "services/service_manager/public/cpp/interface_provider.h"
 
 namespace blink {
 

third_party/WebKit/Source/modules/payments/PaymentManager.cpp

@@ -6,15 +6,10 @@
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "core/dom/DOMException.h"
-#include "core/dom/Document.h"
-#include "core/frame/LocalFrame.h"
-#include "core/workers/WorkerGlobalScope.h"
-#include "core/workers/WorkerThread.h"
 #include "modules/payments/PaymentInstruments.h"
 #include "modules/serviceworkers/ServiceWorkerRegistration.h"
 #include "platform/bindings/ScriptState.h"
-#include "platform/mojo/MojoHelper.h"
-#include "public/platform/Platform.h"
+#include "services/service_manager/public/cpp/interface_provider.h"
 
 namespace blink {
 
@@ -49,14 +44,10 @@ PaymentManager::PaymentManager(ServiceWorkerRegistration* registration)
   DCHECK(registration);
 
   auto request = mojo::MakeRequest(&manager_);
-  ExecutionContext* context = registration->GetExecutionContext();
-  if (context && context->IsDocument()) {
-    LocalFrame* frame = ToDocument(context)->GetFrame();
-    if (frame)
-      frame->GetInterfaceProvider().GetInterface(std::move(request));
-  } else if (context && context->IsWorkerGlobalScope()) {
-    WorkerThread* thread = ToWorkerGlobalScope(context)->GetThread();
-    thread->GetInterfaceProvider().GetInterface(std::move(request));
+  if (ExecutionContext* context = registration->GetExecutionContext()) {
+    if (auto* interface_provider = context->GetInterfaceProvider()) {
+      interface_provider->GetInterface(std::move(request));
+    }
   }
 
   manager_.set_connection_error_handler(ConvertToBaseCallback(WTF::Bind(

third_party/WebKit/Source/modules/permissions/PermissionUtils.cpp

@@ -21,21 +21,11 @@ using MojoPermissionDescriptor = mojom::blink::PermissionDescriptor;
 using mojom::blink::PermissionDescriptorPtr;
 using mojom::blink::PermissionName;
 
-bool ConnectToPermissionService(
+void ConnectToPermissionService(
     ExecutionContext* execution_context,
     mojom::blink::PermissionServiceRequest request) {
-  if (execution_context->IsWorkerGlobalScope()) {
-    WorkerThread* thread = ToWorkerGlobalScope(execution_context)->GetThread();
-    thread->GetInterfaceProvider().GetInterface(std::move(request));
-    return true;
-  }
-
-  LocalFrame* frame = ToDocument(execution_context)->GetFrame();
-  if (!frame)
-    return false;
-
-  frame->GetInterfaceProvider().GetInterface(std::move(request));
-  return true;
+  if (auto* interface_provider = execution_context->GetInterfaceProvider())
+    interface_provider->GetInterface(std::move(request));
 }
 
 PermissionDescriptorPtr CreatePermissionDescriptor(PermissionName name) {

third_party/WebKit/Source/modules/permissions/PermissionUtils.h

@@ -11,7 +11,7 @@ namespace blink {
 
 class ExecutionContext;
 
-bool ConnectToPermissionService(ExecutionContext*,
+void ConnectToPermissionService(ExecutionContext*,
                                 mojom::blink::PermissionServiceRequest);
 
 mojom::blink::PermissionDescriptorPtr CreatePermissionDescriptor(

third_party/WebKit/Source/modules/permissions/Permissions.cpp

@@ -157,16 +157,6 @@ ScriptPromise Permissions::query(ScriptState* script_state,
   if (exception_state.HadException())
     return exception_state.Reject(script_state);
 
-  // This must be called after `parsePermission` because the website might
-  // be able to run code.
-  PermissionService* service = GetService(ExecutionContext::From(script_state));
-  if (!service)
-    return ScriptPromise::RejectWithDOMException(
-        script_state,
-        DOMException::Create(
-            kInvalidStateError,
-            "In its current state, the global scope can't query permissions."));
-
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
 
@@ -175,12 +165,13 @@ ScriptPromise Permissions::query(ScriptState* script_state,
   // permission prompt will be shown even if the returned permission will most
   // likely be "prompt".
   PermissionDescriptorPtr descriptor_copy = descriptor->Clone();
-  service->HasPermission(
-      std::move(descriptor),
-      ExecutionContext::From(script_state)->GetSecurityOrigin(),
-      ConvertToBaseCallback(WTF::Bind(
-          &Permissions::TaskComplete, WrapPersistent(this),
-          WrapPersistent(resolver), WTF::Passed(std::move(descriptor_copy)))));
+  GetService(ExecutionContext::From(script_state))
+      .HasPermission(std::move(descriptor),
+                     ExecutionContext::From(script_state)->GetSecurityOrigin(),
+                     ConvertToBaseCallback(WTF::Bind(
+                         &Permissions::TaskComplete, WrapPersistent(this),
+                         WrapPersistent(resolver),
+                         WTF::Passed(std::move(descriptor_copy)))));
   return promise;
 }
 
@@ -196,27 +187,20 @@ ScriptPromise Permissions::request(ScriptState* script_state,
 
   ExecutionContext* context = ExecutionContext::From(script_state);
 
-  // This must be called after `parsePermission` because the website might
-  // be able to run code.
-  PermissionService* service = GetService(context);
-  if (!service)
-    return ScriptPromise::RejectWithDOMException(
-        script_state, DOMException::Create(kInvalidStateError,
-                                           "In its current state, the global "
-                                           "scope can't request permissions."));
-
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
 
   PermissionDescriptorPtr descriptor_copy = descriptor->Clone();
   Document* doc = ToDocumentOrNull(context);
   Frame* frame = doc ? doc->GetFrame() : nullptr;
-  service->RequestPermission(
-      std::move(descriptor), context->GetSecurityOrigin(),
-      Frame::HasTransientUserActivation(frame, true /* checkIfMainThread */),
-      ConvertToBaseCallback(WTF::Bind(
-          &Permissions::TaskComplete, WrapPersistent(this),
-          WrapPersistent(resolver), WTF::Passed(std::move(descriptor_copy)))));
+  GetService(ExecutionContext::From(script_state))
+      .RequestPermission(std::move(descriptor), context->GetSecurityOrigin(),
+                         Frame::HasTransientUserActivation(
+                             frame, true /* checkIfMainThread */),
+                         ConvertToBaseCallback(WTF::Bind(
+                             &Permissions::TaskComplete, WrapPersistent(this),
+                             WrapPersistent(resolver),
+                             WTF::Passed(std::move(descriptor_copy)))));
   return promise;
 }
 
@@ -230,25 +214,18 @@ ScriptPromise Permissions::revoke(ScriptState* script_state,
   if (exception_state.HadException())
     return exception_state.Reject(script_state);
 
-  // This must be called after `parsePermission` because the website might
-  // be able to run code.
-  PermissionService* service = GetService(ExecutionContext::From(script_state));
-  if (!service)
-    return ScriptPromise::RejectWithDOMException(
-        script_state, DOMException::Create(kInvalidStateError,
-                                           "In its current state, the global "
-                                           "scope can't revoke permissions."));
-
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
 
   PermissionDescriptorPtr descriptor_copy = descriptor->Clone();
-  service->RevokePermission(
-      std::move(descriptor),
-      ExecutionContext::From(script_state)->GetSecurityOrigin(),
-      ConvertToBaseCallback(WTF::Bind(
-          &Permissions::TaskComplete, WrapPersistent(this),
-          WrapPersistent(resolver), WTF::Passed(std::move(descriptor_copy)))));
+  GetService(ExecutionContext::From(script_state))
+      .RevokePermission(
+          std::move(descriptor),
+          ExecutionContext::From(script_state)->GetSecurityOrigin(),
+          ConvertToBaseCallback(
+              WTF::Bind(&Permissions::TaskComplete, WrapPersistent(this),
+                        WrapPersistent(resolver),
+                        WTF::Passed(std::move(descriptor_copy)))));
   return promise;
 }
 
@@ -286,15 +263,6 @@ ScriptPromise Permissions::requestAll(
 
   ExecutionContext* context = ExecutionContext::From(script_state);
 
-  // This must be called after `parsePermission` because the website might
-  // be able to run code.
-  PermissionService* service = GetService(context);
-  if (!service)
-    return ScriptPromise::RejectWithDOMException(
-        script_state, DOMException::Create(kInvalidStateError,
-                                           "In its current state, the global "
-                                           "scope can't request permissions."));
-
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
 
@@ -305,24 +273,27 @@ ScriptPromise Permissions::requestAll(
 
   Document* doc = ToDocumentOrNull(context);
   Frame* frame = doc ? doc->GetFrame() : nullptr;
-  service->RequestPermissions(
-      std::move(internal_permissions), context->GetSecurityOrigin(),
-      Frame::HasTransientUserActivation(frame, true /* checkIfMainThread */),
-      ConvertToBaseCallback(
-          WTF::Bind(&Permissions::BatchTaskComplete, WrapPersistent(this),
-                    WrapPersistent(resolver),
-                    WTF::Passed(std::move(internal_permissions_copy)),
-                    WTF::Passed(std::move(caller_index_to_internal_index)))));
+  GetService(ExecutionContext::From(script_state))
+      .RequestPermissions(
+          std::move(internal_permissions), context->GetSecurityOrigin(),
+          Frame::HasTransientUserActivation(frame,
+                                            true /* checkIfMainThread */),
+          ConvertToBaseCallback(WTF::Bind(
+              &Permissions::BatchTaskComplete, WrapPersistent(this),
+              WrapPersistent(resolver),
+              WTF::Passed(std::move(internal_permissions_copy)),
+              WTF::Passed(std::move(caller_index_to_internal_index)))));
   return promise;
 }
 
-PermissionService* Permissions::GetService(
+PermissionService& Permissions::GetService(
     ExecutionContext* execution_context) {
-  if (!service_ && ConnectToPermissionService(execution_context,
-                                              mojo::MakeRequest(&service_)))
+  if (!service_) {
+    ConnectToPermissionService(execution_context, mojo::MakeRequest(&service_));
     service_.set_connection_error_handler(ConvertToBaseCallback(WTF::Bind(
         &Permissions::ServiceConnectionError, WrapWeakPersistent(this))));
-  return service_.get();
+  }
+  return *service_;
 }
 
 void Permissions::ServiceConnectionError() {

third_party/WebKit/Source/modules/permissions/Permissions.h

@@ -27,7 +27,7 @@ class Permissions final : public ScriptWrappable {
   ScriptPromise requestAll(ScriptState*, const Vector<Dictionary>&);
 
  private:
-  mojom::blink::PermissionService* GetService(ExecutionContext*);
+  mojom::blink::PermissionService& GetService(ExecutionContext*);
   void ServiceConnectionError();
   void TaskComplete(ScriptPromiseResolver*,
                     mojom::blink::PermissionDescriptorPtr,

third_party/WebKit/Source/modules/quota/StorageManager.cpp

@@ -77,23 +77,15 @@ ScriptPromise StorageManager::persist(ScriptState* script_state) {
   }
 
   DCHECK(execution_context->IsDocument());
-  PermissionService* permission_service =
-      GetPermissionService(ExecutionContext::From(script_state));
-  if (!permission_service) {
-    resolver->Reject(DOMException::Create(
-        kInvalidStateError,
-        "In its current state, the global scope can't request permissions."));
-    return promise;
-  }
-
   Document* doc = ToDocumentOrNull(execution_context);
-  permission_service->RequestPermission(
-      CreatePermissionDescriptor(PermissionName::DURABLE_STORAGE),
-      ExecutionContext::From(script_state)->GetSecurityOrigin(),
-      Frame::HasTransientUserActivation(doc ? doc->GetFrame() : nullptr),
-      ConvertToBaseCallback(
-          WTF::Bind(&StorageManager::PermissionRequestComplete,
-                    WrapPersistent(this), WrapPersistent(resolver))));
+  GetPermissionService(ExecutionContext::From(script_state))
+      .RequestPermission(
+          CreatePermissionDescriptor(PermissionName::DURABLE_STORAGE),
+          ExecutionContext::From(script_state)->GetSecurityOrigin(),
+          Frame::HasTransientUserActivation(doc ? doc->GetFrame() : nullptr),
+          ConvertToBaseCallback(
+              WTF::Bind(&StorageManager::PermissionRequestComplete,
+                        WrapPersistent(this), WrapPersistent(resolver))));
 
   return promise;
 }
@@ -110,20 +102,13 @@ ScriptPromise StorageManager::persisted(ScriptState* script_state) {
     return promise;
   }
 
-  PermissionService* permission_service =
-      GetPermissionService(ExecutionContext::From(script_state));
-  if (!permission_service) {
-    resolver->Reject(DOMException::Create(
-        kInvalidStateError,
-        "In its current state, the global scope can't query permissions."));
-    return promise;
-  }
-  permission_service->HasPermission(
-      CreatePermissionDescriptor(PermissionName::DURABLE_STORAGE),
-      ExecutionContext::From(script_state)->GetSecurityOrigin(),
-      ConvertToBaseCallback(
-          WTF::Bind(&StorageManager::PermissionRequestComplete,
-                    WrapPersistent(this), WrapPersistent(resolver))));
+  GetPermissionService(ExecutionContext::From(script_state))
+      .HasPermission(
+          CreatePermissionDescriptor(PermissionName::DURABLE_STORAGE),
+          ExecutionContext::From(script_state)->GetSecurityOrigin(),
+          ConvertToBaseCallback(
+              WTF::Bind(&StorageManager::PermissionRequestComplete,
+                        WrapPersistent(this), WrapPersistent(resolver))));
   return promise;
 }
 
@@ -146,15 +131,16 @@ ScriptPromise StorageManager::estimate(ScriptState* script_state) {
   return promise;
 }
 
-PermissionService* StorageManager::GetPermissionService(
+PermissionService& StorageManager::GetPermissionService(
     ExecutionContext* execution_context) {
-  if (!permission_service_ &&
-      ConnectToPermissionService(execution_context,
-                                 mojo::MakeRequest(&permission_service_)))
+  if (!permission_service_) {
+    ConnectToPermissionService(execution_context,
+                               mojo::MakeRequest(&permission_service_));
     permission_service_.set_connection_error_handler(ConvertToBaseCallback(
         WTF::Bind(&StorageManager::PermissionServiceConnectionError,
                   WrapWeakPersistent(this))));
-  return permission_service_.get();
+  }
+  return *permission_service_;
 }
 
 void StorageManager::PermissionServiceConnectionError() {

third_party/WebKit/Source/modules/quota/StorageManager.h

@@ -26,7 +26,7 @@ class StorageManager final : public ScriptWrappable {
   ScriptPromise estimate(ScriptState*);
 
  private:
-  mojom::blink::PermissionService* GetPermissionService(ExecutionContext*);
+  mojom::blink::PermissionService& GetPermissionService(ExecutionContext*);
   void PermissionServiceConnectionError();
   void PermissionRequestComplete(ScriptPromiseResolver*,
                                  mojom::blink::PermissionStatus);

third_party/WebKit/Source/modules/websockets/WorkerWebSocketChannel.cpp

@@ -46,8 +46,8 @@
 #include "platform/wtf/PtrUtil.h"
 #include "platform/wtf/text/CString.h"
 #include "platform/wtf/text/WTFString.h"
-#include "public/platform/InterfaceProvider.h"
 #include "public/platform/TaskType.h"
+#include "services/service_manager/public/cpp/interface_provider.h"
 
 namespace blink {
 
@@ -414,7 +414,7 @@ bool Bridge::Connect(std::unique_ptr<SourceLocation> location,
   // SSL interstitial decision to WebSocket connections from the worker.
   mojom::blink::WebSocketPtrInfo socket_ptr_info;
   if (!worker_global_scope_->IsDedicatedWorkerGlobalScope()) {
-    worker_thread->GetInterfaceProvider().GetInterface(
+    worker_global_scope_->GetInterfaceProvider()->GetInterface(
         mojo::MakeRequest(&socket_ptr_info));
   }