Change signature of OnConnect

content/browser/renderer_host/render_process_host_impl.cc

 // Copyright 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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "content/browser/renderer_host/render_process_host_impl.h"
 
 #include <algorithm>
@@ skipping 461 matching lines @@
       : child_identity_(child_identity),
         registry_(std::move(registry)) {}
   ~ConnectionFilterImpl() override {
     scoped_refptr<base::SequencedTaskRunner> io_task_runner =
         BrowserThread::GetTaskRunnerForThread(BrowserThread::IO);
     io_task_runner->DeleteSoon(FROM_HERE, weak_factory_.release());
   }
 
  private:
   // ConnectionFilter:
-  bool OnConnect(shell::Connection* connection,
+  bool OnConnect(const shell::Identity& remote_identity,
+                 shell::InterfaceRegistry* registry,
                  shell::Connector* connector) override {
     if (!weak_factory_)
       weak_factory_.reset(new base::WeakPtrFactory<ConnectionFilterImpl>(this));
 
     // We only fulfill connections from the renderer we host.
-    const shell::Identity& remote_identity = connection->GetRemoteIdentity();
     if (child_identity_.name() != remote_identity.name() ||
         child_identity_.instance() != remote_identity.instance()) {
       return false;
     }
 
     std::set<std::string> interface_names;
     registry_->GetInterfaceNames(&interface_names);
     for (auto& interface_name : interface_names) {
       // Note that the added callbacks may outlive this object, which is
       // destroyed in RPH::Cleanup().
-      connection->GetInterfaceRegistry()->AddInterface(
-          interface_name,
-          base::Bind(&ConnectionFilterImpl::GetInterface,
-                     weak_factory_->GetWeakPtr(),
-                     interface_name));
+      registry->AddInterface(interface_name,
+                             base::Bind(&ConnectionFilterImpl::GetInterface,
+                                        weak_factory_->GetWeakPtr(),
+                                        interface_name));
     }
     return true;
   }
 
   void GetInterface(const std::string& interface_name,
                     mojo::ScopedMessagePipeHandle handle) {
     shell::mojom::InterfaceProvider* provider = registry_.get();
     provider->GetInterface(interface_name, std::move(handle));
   }
 
@@ skipping 577 matching lines @@
   AddFilter(new MemoryMessageFilter(this));
   AddFilter(new PushMessagingMessageFilter(
       GetID(), storage_partition_impl_->GetServiceWorkerContext()));
 #if defined(OS_ANDROID)
   AddFilter(new ScreenOrientationMessageFilterAndroid());
 #endif
 }
 
 void RenderProcessHostImpl::RegisterMojoInterfaces() {
   std::unique_ptr<shell::InterfaceRegistry> registry(
-      new shell::InterfaceRegistry(nullptr));
+      new shell::InterfaceRegistry);
 #if defined(OS_ANDROID)
   interface_registry_android_ =
       InterfaceRegistryAndroid::Create(registry.get());
   InterfaceRegistrarAndroid::ExposeInterfacesToRenderer(
       interface_registry_android_.get());
 #endif
 
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner =
       BrowserThread::GetTaskRunnerForThread(BrowserThread::UI);
 #if !defined(OS_ANDROID)
@@ skipping 1716 matching lines @@
   LOG(ERROR) << "Terminating render process for bad Mojo message: " << error;
 
   // The ReceivedBadMessage call below will trigger a DumpWithoutCrashing. Alias
   // enough information here so that we can determine what the bad message was.
   base::debug::Alias(&error);
   bad_message::ReceivedBadMessage(process.get(),
                                   bad_message::RPH_MOJO_PROCESS_ERROR);
 }
 
 }  // namespace content