Adds routed interface support between RenderFrameHost and RenderFrame

content/renderer/render_frame_impl.cc

 // Copyright 2013 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/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 1078 matching lines @@
   remote_interfaces_.reset(new shell::InterfaceProvider);
   remote_interfaces_->Bind(std::move(remote_interfaces));
   blink_interface_provider_.reset(new BlinkInterfaceProviderImpl(
       remote_interfaces_->GetWeakPtr()));
 
   std::pair<RoutingIDFrameMap::iterator, bool> result =
       g_routing_id_frame_map.Get().insert(std::make_pair(routing_id_, this));
   CHECK(result.second) << "Inserting a duplicate item.";
 
   RenderThread::Get()->AddRoute(routing_id_, this);
+  RenderThread::Get()->AddRoutedInterfaces(routing_id_, this);
 
   render_view_->RegisterRenderFrame(this);
 
   // Everything below subclasses RenderFrameObserver and is automatically
   // deleted when the RenderFrame gets deleted.
 #if defined(OS_ANDROID)
   new GinJavaBridgeDispatcher(this);
 #endif
 
 #if defined(ENABLE_PLUGINS)
@@ skipping 1279 matching lines @@
 }
 
 shell::InterfaceRegistry* RenderFrameImpl::GetInterfaceRegistry() {
   return interface_registry_.get();
 }
 
 shell::InterfaceProvider* RenderFrameImpl::GetRemoteInterfaces() {
   return remote_interfaces_.get();
 }
 
+void RenderFrameImpl::AddRoutedInterface(
+    const base::StringPiece& name,
+    const GenericRoutedInterfaceFactory& factory) {
+  auto result =
+      routed_interfaces_.insert(std::make_pair(name.as_string(), factory));
+  DCHECK(result.second);
+}
+
+void RenderFrameImpl::RemoveRoutedInterface(const base::StringPiece& name) {
+  auto it = routed_interfaces_.find(name.as_string());
+  DCHECK(it != routed_interfaces_.end());
+  routed_interfaces_.erase(it);
+}
+
+void RenderFrameImpl::GetRemoteRoutedInterface(
+    const base::StringPiece& name,
+    mojo::ScopedInterfaceEndpointHandle handle) {
+  mojom::RoutedInterfaceAssociatedRequest request;
+  request.Bind(std::move(handle));
+  GetRemoteRoutedInterfaces()->GetRoutedInterface(name.as_string(),
+                                                  std::move(request));
+}
+
 #if defined(ENABLE_PLUGINS)
 void RenderFrameImpl::RegisterPeripheralPlugin(
     const url::Origin& content_origin,
     const base::Closure& unthrottle_callback) {
   return plugin_power_saver_helper_->RegisterPeripheralPlugin(
       content_origin, unthrottle_callback);
 }
 
 RenderFrame::PeripheralContentStatus
 RenderFrameImpl::GetPeripheralContentStatus(
@@ skipping 3759 matching lines @@
 }
 
 void RenderFrameImpl::RegisterMojoInterfaces() {
   // Only main frame have ImageDownloader service.
   if (!frame_->parent()) {
     GetInterfaceRegistry()->AddInterface(base::Bind(
         &ImageDownloaderImpl::CreateMojoService, base::Unretained(this)));
   }
 }
 
+mojom::RoutedInterfaceProvider* RenderFrameImpl::GetRemoteRoutedInterfaces() {
+  if (!remote_routed_interfaces_) {
+    RenderThread* render_thread = RenderThread::Get();
+    render_thread->GetRemoteRouteProvider()->GetRoutedInterfaces(
+        GetRoutingID(),
+        mojo::GetProxy(&remote_routed_interfaces_,
+                       render_thread->GetChannel()->GetAssociatedGroup()));
+  }
+
+  return remote_routed_interfaces_.get();
+}
+
 template <typename Interface>
 void RenderFrameImpl::GetInterface(mojo::InterfaceRequest<Interface> request) {
   GetRemoteInterfaces()->GetInterface(std::move(request));
 }
 
 media::RendererWebMediaPlayerDelegate*
 RenderFrameImpl::GetWebMediaPlayerDelegate() {
   if (!media_player_delegate_)
     media_player_delegate_ = new media::RendererWebMediaPlayerDelegate(this);
   return media_player_delegate_;
@@ skipping 144 matching lines @@
   // And then the mouse event is forwarded to blink, which dispatches it to the
   // event target. Potentially a Pepper plugin will receive the event.
   // In order to tell whether a plugin gets the last mouse event and which it
   // is, we set |pepper_last_mouse_event_target_| to null here. If a plugin gets
   // the event, it will notify us via DidReceiveMouseEvent() and set itself as
   // |pepper_last_mouse_event_target_|.
   pepper_last_mouse_event_target_ = nullptr;
 #endif
 }
 
+void RenderFrameImpl::GetRoutedInterface(
+    const std::string& name,
+    mojom::RoutedInterfaceAssociatedRequest request) {
+  auto it = routed_interfaces_.find(name);
+  if (it != routed_interfaces_.end())
+    it->second.Run(request.PassHandle());
+}
+
 }  // namespace content