Send input event IPCs directly from the UI thread

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>
 
@@ skipping 117 matching lines @@
   int GetID() const override;
   bool HasConnection() const override;
   void SetIgnoreInputEvents(bool ignore_input_events) override;
   bool IgnoreInputEvents() const override;
   void Cleanup() override;
   void AddPendingView() override;
   void RemovePendingView() override;
   void SetSuddenTerminationAllowed(bool enabled) override;
   bool SuddenTerminationAllowed() const override;
   IPC::ChannelProxy* GetChannel() override;
+  IPC::Sender* GetImmediateSender() override;
+  IPC::Sender* GetIOThreadSender() override;
   void AddFilter(BrowserMessageFilter* filter) override;
   bool FastShutdownForPageCount(size_t count) override;
   bool FastShutdownStarted() const override;
   base::TimeDelta GetChildProcessIdleTime() const override;
   void FilterURL(bool empty_allowed, GURL* url) override;
 #if defined(ENABLE_WEBRTC)
   void EnableAudioDebugRecordings(const base::FilePath& file) override;
   void DisableAudioDebugRecordings() override;
   void EnableEventLogRecordings(const base::FilePath& file) override;
   void DisableEventLogRecordings() override;
@@ skipping 136 matching lines @@
   // True if this object has deleted itself.
   bool is_self_deleted_;
 #endif
 
   // The count of currently swapped out but pending RenderViews.  We have
   // started to swap these in, so the renderer process should not exit if
   // this count is non-zero.
   int32_t pending_views_;
 
  private:
+  class SafeSenderProxy;
+
+  friend class ChildProcessLauncherBrowserTest_ChildSpawnFail_Test;
+  friend class SafeSenderProxy;
   friend class VisitRelayingRenderProcessHost;
-  friend class ChildProcessLauncherBrowserTest_ChildSpawnFail_Test;
 
   std::unique_ptr<IPC::ChannelProxy> CreateChannelProxy(
       const std::string& channel_id);
 
   // Creates and adds the IO thread message filters.
   void CreateMessageFilters();
 
+  // Shared implementation for IPC::Senders exposed by this RPH.
+  bool SendImpl(std::unique_ptr<IPC::Message> message, bool send_now);
+
   // Registers Mojo services to be exposed to the renderer.
   void RegisterMojoServices();
 
   void CreateStoragePartitionService(
       mojo::InterfaceRequest<mojom::StoragePartitionService> request);
 
   // Control message handlers.
   void OnShutdownRequest();
   void SuddenTerminationChanged(bool enabled);
   void OnUserMetricsRecordAction(const std::string& action);
@@ skipping 42 matching lines @@
   void SendAecDumpFileToRenderer(int id,
                                  IPC::PlatformFileForTransit file_for_transit);
   void SendEventLogFileToRenderer(int id,
                                   IPC::PlatformFileForTransit file_for_transit);
   void SendDisableAecDumpToRenderer();
   void SendDisableEventLogToRenderer();
   base::FilePath GetAecDumpFilePathWithExtensions(const base::FilePath& file);
   base::FilePath GetEventLogFilePathWithExtensions(const base::FilePath& file);
 #endif
 
+  // An IPC::Sender which lives as long as this RPH and provides safe, opaque
+  // access to ChannelProxy SendNow() and SendOnIOThread().
+  const std::unique_ptr<SafeSenderProxy> safe_sender_;
+
   std::unique_ptr<MojoChildConnection> mojo_child_connection_;
   std::unique_ptr<MojoApplicationHost> mojo_application_host_;
 
   // The registered IPC listener objects. When this list is empty, we should
   // delete ourselves.
   IDMap<IPC::Listener> listeners_;
 
   // 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.
@@ skipping 25 matching lines @@
   // 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_;
+  std::queue<std::unique_ptr<IPC::Message>> 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 93 matching lines @@
   mojo::ScopedMessagePipeHandle in_process_renderer_handle_;
 
   base::WeakPtrFactory<RenderProcessHostImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderProcessHostImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_RENDER_PROCESS_HOST_IMPL_H_