Convert content ConnectionFilter to OnBindInterface

content/child/child_thread_impl.cc

 // Copyright (c) 2012 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/child/child_thread_impl.h"
 
 #include <signal.h>
 #include <string>
 #include <utility>
 
@@ skipping 243 matching lines @@
   // Mojo isn't supported on all child process types.
   // TODO(crbug.com/604282): Support Mojo in the remaining processes.
   if (!platform_channel.is_valid())
     return;
   mojo::edk::SetParentPipeHandle(std::move(platform_channel));
 }
 
 class ChannelBootstrapFilter : public ConnectionFilter {
  public:
   explicit ChannelBootstrapFilter(IPC::mojom::ChannelBootstrapPtrInfo bootstrap)
-      : bootstrap_(std::move(bootstrap)), weak_factory_(this) {}
+      : bootstrap_(std::move(bootstrap)) {}
 
  private:
   // ConnectionFilter:
-  bool OnConnect(const service_manager::Identity& remote_identity,
-                 service_manager::InterfaceRegistry* registry,
-                 service_manager::Connector* connector) override {
-    if (remote_identity.name() != mojom::kBrowserServiceName)
-      return false;
+  void OnBindInterface(const service_manager::ServiceInfo& source_info,
+                       const std::string& interface_name,
+                       mojo::ScopedMessagePipeHandle* interface_pipe,
+                       service_manager::Connector* connector) override {
+    if (source_info.identity.name() != mojom::kBrowserServiceName)
+      return;
 
-    registry->AddInterface(base::Bind(&ChannelBootstrapFilter::CreateBootstrap,
-                                      weak_factory_.GetWeakPtr()));
-    return true;
-  }
-
-  void CreateBootstrap(IPC::mojom::ChannelBootstrapRequest request) {
-    DCHECK(bootstrap_.is_valid());
-    mojo::FuseInterface(std::move(request), std::move(bootstrap_));
+    if (interface_name == IPC::mojom::ChannelBootstrap::Name_) {
+      DCHECK(bootstrap_.is_valid());
+      mojo::FuseInterface(mojo::MakeRequest<IPC::mojom::ChannelBootstrap>(
+                              std::move(*interface_pipe)),
+                          std::move(bootstrap_));
+    }
   }
 
   IPC::mojom::ChannelBootstrapPtrInfo bootstrap_;
-  base::WeakPtrFactory<ChannelBootstrapFilter> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ChannelBootstrapFilter);
 };
 
 }  // namespace
 
 ChildThread* ChildThread::Get() {
   return ChildThreadImpl::current();
 }
 
@@ skipping 148 matching lines @@
     service_request_token = options.in_process_service_request_token;
   }
   if (!service_request_token.empty()) {
     mojo::ScopedMessagePipeHandle handle =
         mojo::edk::CreateChildMessagePipe(service_request_token);
     DCHECK(handle.is_valid());
     service_manager_connection_ = ServiceManagerConnection::Create(
         mojo::MakeRequest<service_manager::mojom::Service>(std::move(handle)),
         GetIOTaskRunner());
 
-    // When connect_to_browser is true, we obtain interfaces from the browser
-    // process by connecting to it, rather than from the incoming interface
-    // provider. Exposed interfaces are subject to manifest capability spec.
-    if (options.connect_to_browser) {
-      browser_connection_ =
-          service_manager_connection_->GetConnector()->Connect(
-              mojom::kBrowserServiceName);
-    }
-
     // TODO(rockot): Remove this once all child-to-browser interface connections
     // are made via a Connector rather than directly through an
     // InterfaceProvider, and all exposed interfaces are exposed via a
     // ConnectionFilter.
     service_manager_connection_->SetupInterfaceRequestProxies(
         GetInterfaceRegistry(), nullptr);
   }
 
   sync_message_filter_ = channel_->CreateSyncMessageFilter();
   thread_safe_sender_ = new ThreadSafeSender(
@@ skipping 402 matching lines @@
   connected_to_browser_ = true;
   child_info_ = local_info;
   browser_info_ = remote_info;
 }
 
 bool ChildThreadImpl::IsInBrowserProcess() const {
   return static_cast<bool>(browser_process_io_runner_);
 }
 
 }  // namespace content