Adds routed interface support between RenderFrameHost and RenderFrame

content/browser/renderer_host/render_process_host_impl.h

 // 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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_RENDER_PROCESS_HOST_IMPL_H_
 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_PROCESS_HOST_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <queue>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/observer_list.h"
 #include "base/process/process.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "build/build_config.h"
 #include "content/browser/child_process_launcher.h"
 #include "content/browser/dom_storage/session_storage_namespace_impl.h"
 #include "content/browser/power_monitor_message_broadcaster.h"
 #include "content/browser/webrtc/webrtc_eventlog_host.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/render_process_host.h"
+#include "content/public/common/associated_interfaces.mojom.h"
 #include "content/public/common/mojo_shell_connection.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_platform_file.h"
+#include "mojo/public/cpp/bindings/associated_binding.h"
+#include "mojo/public/cpp/bindings/associated_binding_set.h"
 #include "mojo/public/cpp/bindings/interface_ptr.h"
 #include "services/shell/public/cpp/interface_registry.h"
 #include "services/shell/public/interfaces/service.mojom.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gl/gpu_switching_observer.h"
 
 #if defined(OS_ANDROID)
 #include "content/public/browser/android/interface_registry_android.h"
 #endif
 
@@ skipping 57 matching lines @@
 // are correlated with IDs. This way, the Views and the corresponding ViewHosts
 // communicate through the two process objects.
 //
 // A RenderProcessHost is also associated with one and only one
 // StoragePartition.  This allows us to implement strong storage isolation
 // because all the IPCs from the RenderViews (renderer) will only ever be able
 // to access the partition they are assigned to.
 class CONTENT_EXPORT RenderProcessHostImpl
     : public RenderProcessHost,
       public ChildProcessLauncher::Client,
-      public ui::GpuSwitchingObserver {
+      public ui::GpuSwitchingObserver,
+      public NON_EXPORTED_BASE(mojom::RouteProvider),
+      public NON_EXPORTED_BASE(mojom::AssociatedInterfaceProvider) {
  public:
   RenderProcessHostImpl(BrowserContext* browser_context,
                         StoragePartitionImpl* storage_partition_impl,
                         bool is_for_guests_only);
   ~RenderProcessHostImpl() override;
 
   // RenderProcessHost implementation (public portion).
   void EnableSendQueue() override;
   bool Init() override;
   int GetNextRoutingID() override;
@@ skipping 52 matching lines @@
   scoped_refptr<media::MediaKeys> GetCdm(int render_frame_id,
                                          int cdm_id) const override;
 #endif
   bool IsProcessBackgrounded() const override;
   void IncrementServiceWorkerRefCount() override;
   void DecrementServiceWorkerRefCount() override;
   void IncrementSharedWorkerRefCount() override;
   void DecrementSharedWorkerRefCount() override;
   void PurgeAndSuspend() override;
 
+  mojom::RouteProvider* GetRemoteRouteProvider();
+
   // IPC::Sender via RenderProcessHost.
   bool Send(IPC::Message* msg) override;
 
   // IPC::Listener via RenderProcessHost.
   bool OnMessageReceived(const IPC::Message& msg) override;
   void OnChannelConnected(int32_t peer_pid) override;
   void OnChannelError() override;
   void OnBadMessageReceived(const IPC::Message& message) override;
 
   // ChildProcessLauncher::Client implementation.
@@ skipping 128 matching lines @@
 
   std::unique_ptr<IPC::ChannelProxy> CreateChannelProxy(
       const std::string& channel_id);
 
   // Creates and adds the IO thread message filters.
   void CreateMessageFilters();
 
   // Registers Mojo interfaces to be exposed to the renderer.
   void RegisterMojoInterfaces();
 
+  // mojom::RouteProvider:
+  void GetRoute(
+      int32_t routing_id,
+      mojom::AssociatedInterfaceProviderAssociatedRequest request) override;
+
+  // mojom::AssociatedInterfaceProvider:
+  void GetAssociatedInterface(
+      const std::string& name,
+      mojom::AssociatedInterfaceAssociatedRequest request) override;
+
   void CreateStoragePartitionService(
       mojo::InterfaceRequest<mojom::StoragePartitionService> request);
 
   // Control message handlers.
   void OnShutdownRequest();
   void SuddenTerminationChanged(bool enabled);
   void OnUserMetricsRecordAction(const std::string& action);
   void OnCloseACK(int old_route_id);
 
   // Generates a command line to be used to spawn a renderer and appends the
@@ skipping 14 matching lines @@
 
   // Creates a PersistentMemoryAllocator and shares it with the renderer
   // process for it to store histograms from that process. The allocator is
   // available for extraction by a SubprocesMetricsProvider in order to
   // report those histograms to UMA.
   void CreateSharedRendererHistogramAllocator();
 
   // Handle termination of our process.
   void ProcessDied(bool already_dead, RendererClosedDetails* known_details);
 
+  void OnRouteProviderRequest(mojom::RouteProviderAssociatedRequest request);
+
   // GpuSwitchingObserver implementation.
   void OnGpuSwitched() override;
 
 #if defined(ENABLE_WEBRTC)
   void OnRegisterAecDumpConsumer(int id);
   void OnUnregisterAecDumpConsumer(int id);
   void RegisterAecDumpConsumerOnUIThread(int id);
   void UnregisterAecDumpConsumerOnUIThread(int id);
   void EnableAecDumpForId(const base::FilePath& file, int id);
   // Sends |file_for_transit| to the render process.
@@ skipping 49 matching lines @@
   std::unique_ptr<InterfaceRegistryAndroid> interface_registry_android_;
 #endif
 
   size_t service_worker_ref_count_;
   size_t shared_worker_ref_count_;
 
   // The registered IPC listener objects. When this list is empty, we should
   // delete ourselves.
   IDMap<IPC::Listener> listeners_;
 
+  mojo::AssociatedBinding<mojom::RouteProvider> route_provider_binding_;
+  mojo::AssociatedBindingSet<mojom::AssociatedInterfaceProvider>
+      associated_interface_provider_bindings_;
+
   // The count of currently visible widgets.  Since the host can be a container
   // for multiple widgets, it uses this count to determine when it should be
   // backgrounded.
   int32_t visible_widgets_;
 
   // Whether this process currently has backgrounded priority. Tracked so that
   // UpdateProcessPriority() can avoid redundantly setting the priority.
   bool is_process_backgrounded_;
 
   // Used to allow a RenderWidgetHost to intercept various messages on the
@@ skipping 16 matching lines @@
   // also reset that in the case of process termination.
   bool is_initialized_;
 
   // PlzNavigate
   // Stores the time at which the first call to Init happened.
   base::TimeTicks init_time_;
 
   // Used to launch and terminate the process without blocking the UI thread.
   std::unique_ptr<ChildProcessLauncher> child_process_launcher_;
 
-  // Messages we queue while waiting for the process handle.  We queue them here
-  // instead of in the channel so that we ensure they're sent after init related
-  // messages that are sent once the process handle is available.  This is
-  // because the queued messages may have dependencies on the init messages.
-  std::queue<IPC::Message*> queued_messages_;
+  // Messages we queue before the ChannelProxy is created.
+  using MessageQueue = std::queue<std::unique_ptr<IPC::Message>>;
+  MessageQueue queued_messages_;
 
   // The globally-unique identifier for this RPH.
   const int id_;
 
   // A secondary ID used by the Mojo shell to distinguish different incarnations
   // of the same RPH from each other. Unlike |id_| this is not globally unique,
   // but it is guaranteed to change every time Init() is called.
   int instance_id_ = 1;
 
   BrowserContext* browser_context_;
@@ skipping 84 matching lines @@
   // UI thread is the source of sync IPCs and all shutdown signals.
   // Therefore a proper shutdown event to unblock the UI thread is not
   // possible without massive refactoring shutdown code.
   // Luckily Android never performs a clean shutdown. So explicitly
   // ignore this problem.
   base::WaitableEvent never_signaled_;
 #endif
 
   scoped_refptr<ResourceMessageFilter> resource_message_filter_;
 
+  mojom::RouteProviderAssociatedPtr remote_route_provider_;
+
   // A WeakPtrFactory which is reset every time Cleanup() runs. Used to vend
   // WeakPtrs which are invalidated any time the RPHI is recycled.
   std::unique_ptr<base::WeakPtrFactory<RenderProcessHostImpl>>
       instance_weak_factory_;
 
   base::WeakPtrFactory<RenderProcessHostImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderProcessHostImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_PROCESS_HOST_IMPL_H_