Convert ChromeViewHostMsg_UpdatedCacheStats to use mojo.

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 1358 matching lines @@
 
   AddUIThreadInterface(registry.get(), base::Bind(&FieldTrialRecorder::Create));
 
   AddUIThreadInterface(
       registry.get(),
       base::Bind(
           &memory_instrumentation::CoordinatorImpl::BindCoordinatorRequest,
           base::Unretained(
               memory_instrumentation::CoordinatorImpl::GetInstance())));
 
-  GetContentClient()->browser()->ExposeInterfacesToRenderer(registry.get(),
-                                                            this);
+  associated_interfaces_.reset(new AssociatedInterfaceRegistryImpl());
+  GetContentClient()->browser()->ExposeInterfacesToRenderer(
+      registry.get(), associated_interfaces_.get(), this);
+  static_cast<AssociatedInterfaceRegistry*>(associated_interfaces_.get())
+      ->AddInterface(base::Bind(&RenderProcessHostImpl::BindRouteProvider,
+                                base::Unretained(this)));
 
   ServiceManagerConnection* service_manager_connection =
       BrowserContext::GetServiceManagerConnectionFor(browser_context_);
   std::unique_ptr<ConnectionFilterImpl> connection_filter(
       new ConnectionFilterImpl(child_connection_->child_identity(),
                                std::move(registry)));
   connection_filter_controller_ = connection_filter->controller();
   connection_filter_id_ = service_manager_connection->AddConnectionFilter(
       std::move(connection_filter));
 }
 
+void RenderProcessHostImpl::BindRouteProvider(
+    mojom::RouteProviderAssociatedRequest request) {
+  if (route_provider_binding_.is_bound())
+    return;
+  route_provider_binding_.Bind(std::move(request));
+}
+
 void RenderProcessHostImpl::GetRoute(
     int32_t routing_id,
     mojom::AssociatedInterfaceProviderAssociatedRequest request) {
   DCHECK(request.is_pending());
   associated_interface_provider_bindings_.AddBinding(
       this, std::move(request), routing_id);
 }
 
 void RenderProcessHostImpl::GetAssociatedInterface(
     const std::string& name,
@@ skipping 729 matching lines @@
       Send(reply);
     }
     return true;
   }
   return listener->OnMessageReceived(msg);
 }
 
 void RenderProcessHostImpl::OnAssociatedInterfaceRequest(
     const std::string& interface_name,
     mojo::ScopedInterfaceEndpointHandle handle) {
-  if (interface_name == mojom::RouteProvider::Name_) {
-    if (route_provider_binding_.is_bound())
-      return;
-    mojom::RouteProviderAssociatedRequest request;
-    request.Bind(std::move(handle));
-    route_provider_binding_.Bind(std::move(request));
+  if ((associated_interfaces_) &&

[Ken Rockot(use gerrit already), 2017/04/28 19:20:10]

nit: please remove the redundant parenthesis from both of these expressions.
there is no potential ambiguity to be guarded against and so they add no value

[nigeltao1, 2017/04/29 07:07:57]

Done.

+      (associated_interfaces_->CanBindRequest(interface_name))) {
+    associated_interfaces_->BindRequest(interface_name, std::move(handle));
   } else {
     LOG(ERROR) << "Request for unknown Channel-associated interface: "
                << interface_name;
   }
 }
 
 void RenderProcessHostImpl::OnChannelConnected(int32_t peer_pid) {
   channel_connected_ = true;
   if (IsReady()) {
     DCHECK(!sent_render_process_ready_);
@@ skipping 639 matching lines @@
       status = base::TERMINATION_STATUS_PROCESS_CRASHED;
     }
   }
 
   RendererClosedDetails details(status, exit_code);
 
   child_process_launcher_.reset();
   is_dead_ = true;
   if (route_provider_binding_.is_bound())
     route_provider_binding_.Close();
+  associated_interfaces_.reset(NULL);

[Ken Rockot(use gerrit already), 2017/04/28 19:20:10]

nit: please use nullptr instead of NULL in new code. but here you should in fact
just reset().

It's totally fine if you really want to reset associated_interfaces_ here, but
that has absolutely nothing to do with closing existing bound interfaces. It's
just a map of callbacks that are used to bind incoming requests. If you want to
close bound interfaces too, you have to do that explicitly (e.g. look at how
route_provider_binding_ is closed above).

The use of StrongAssociatedBinding for your interface makes it impossible for
you to force-close the pipe at your own discretion. Because it's a
Channel-associated interface, however, it is impossible for it to outlive the
IPC::Channel anyway, so I don't think there's actually any risk here.

[nigeltao1, 2017/04/29 07:07:57]

Done.

   ResetChannelProxy();
 
   UpdateProcessPriority();
   DCHECK(!is_process_backgrounded_);
 
   within_process_died_observer_ = true;
   NotificationService::current()->Notify(
       NOTIFICATION_RENDERER_PROCESS_CLOSED, Source<RenderProcessHost>(this),
       Details<RendererClosedDetails>(&details));
   for (auto& observer : observers_)
@@ skipping 323 matching lines @@
   LOG(ERROR) << "Terminating render process for bad Mojo message: " << error;
 
   // The ReceivedBadMessage call below will trigger a DumpWithoutCrashing.
   // Capture the error message in a crash key value.
   base::debug::ScopedCrashKey error_key_value("mojo-message-error", error);
   bad_message::ReceivedBadMessage(render_process_id,
                                   bad_message::RPH_MOJO_PROCESS_ERROR);
 }
 
 }  // namespace content