Revert "Send input event IPCs directly from the UI thread"

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 147 matching lines @@
 #include "content/public/common/url_constants.h"
 #include "device/battery/battery_monitor_impl.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gpu_switches.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "ipc/attachment_broker.h"
 #include "ipc/attachment_broker_privileged.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_logging.h"
-#include "ipc/ipc_sender.h"
 #include "ipc/ipc_switches.h"
 #include "ipc/mojo/ipc_channel_mojo.h"
 #include "media/base/media_switches.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ppapi/shared_impl/ppapi_switches.h"
 #include "services/shell/runner/common/switches.h"
 #include "storage/browser/fileapi/sandbox_file_system_backend.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/ui_base_switches.h"
@@ skipping 263 matching lines @@
   for (auto it : vector) {
     if (!str.empty())
       str += ",";
     str += base::UintToString(it);
   }
   return str;
 }
 
 }  // namespace
 
-class RenderProcessHostImpl::SafeSenderProxy : public IPC::Sender {
- public:
-  // |process| must outlive this object.
-  explicit SafeSenderProxy(RenderProcessHostImpl* process, bool send_now)
-      : process_(process), send_now_(send_now) {}
-  ~SafeSenderProxy() override {}
-
-  // IPC::Sender:
-  bool Send(IPC::Message* message) override {
-    return process_->SendImpl(base::WrapUnique(message), send_now_);
-  }
-
- private:
-  RenderProcessHostImpl* const process_;
-  const bool send_now_;
-
-  DISALLOW_COPY_AND_ASSIGN(SafeSenderProxy);
-};
-
 RendererMainThreadFactoryFunction g_renderer_main_thread_factory = NULL;
 
 base::MessageLoop* g_in_process_thread;
 
 base::MessageLoop*
 RenderProcessHostImpl::GetInProcessRendererThreadForTesting() {
   return g_in_process_thread;
 }
 
 // Stores the maximum number of renderer processes the content module can
@@ skipping 69 matching lines @@
 RenderProcessHostImpl::RenderProcessHostImpl(
     BrowserContext* browser_context,
     StoragePartitionImpl* storage_partition_impl,
     bool is_for_guests_only)
     : fast_shutdown_started_(false),
       deleting_soon_(false),
 #ifndef NDEBUG
       is_self_deleted_(false),
 #endif
       pending_views_(0),
-      immediate_sender_(new SafeSenderProxy(this, true)),
-      io_thread_sender_(new SafeSenderProxy(this, false)),
       child_token_(mojo::edk::GenerateRandomToken()),
       mojo_application_host_(new MojoApplicationHost(child_token_)),
       visible_widgets_(0),
       is_process_backgrounded_(false),
       is_initialized_(false),
       id_(ChildProcessHostImpl::GenerateChildProcessUniqueId()),
       browser_context_(browser_context),
       storage_partition_impl_(storage_partition_impl),
       sudden_termination_allowed_(true),
       ignore_input_events_(false),
@@ skipping 94 matching lines @@
     ui::GpuSwitchingManager::GetInstance()->RemoveObserver(this);
     gpu_observer_registered_ = false;
   }
 
 #if USE_ATTACHMENT_BROKER
   IPC::AttachmentBroker::GetGlobal()->DeregisterCommunicationChannel(
       channel_.get());
 #endif
   // We may have some unsent messages at this point, but that's OK.
   channel_.reset();
-  while (!queued_messages_.empty())
+  while (!queued_messages_.empty()) {
+    delete queued_messages_.front();
     queued_messages_.pop();
+  }
 
   UnregisterHost(GetID());
 
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableGpuShaderDiskCache)) {
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                             base::Bind(&RemoveShaderInfo, GetID()));
   }
 }
 
@@ skipping 335 matching lines @@
   AddFilter(new ProfilerMessageFilter(PROCESS_TYPE_RENDERER));
   AddFilter(new HistogramMessageFilter());
   AddFilter(new MemoryMessageFilter(this));
   AddFilter(new PushMessagingMessageFilter(
       GetID(), storage_partition_impl_->GetServiceWorkerContext()));
 #if defined(OS_ANDROID)
   AddFilter(new ScreenOrientationMessageFilterAndroid());
 #endif
 }
 
-bool RenderProcessHostImpl::SendImpl(std::unique_ptr<IPC::Message> msg,
-                                     bool send_now) {
-  TRACE_EVENT0("renderer_host", "RenderProcessHostImpl::SendImpl");
-#if !defined(OS_ANDROID)
-  DCHECK(!msg->is_sync());
-#endif
-
-  if (!channel_) {
-#if defined(OS_ANDROID)
-    if (msg->is_sync())
-      return false;
-#endif
-    if (!is_initialized_) {
-      queued_messages_.emplace(std::move(msg));
-      return true;
-    } else {
-      return false;
-    }
-  }
-
-  if (child_process_launcher_.get() && child_process_launcher_->IsStarting()) {
-#if defined(OS_ANDROID)
-    if (msg->is_sync())
-      return false;
-#endif
-    queued_messages_.emplace(std::move(msg));
-    return true;
-  }
-
-  if (send_now)
-    return channel_->SendNow(std::move(msg));
-
-  return channel_->SendOnIPCThread(std::move(msg));
-}
-
 void RenderProcessHostImpl::RegisterMojoServices() {
 #if !defined(OS_ANDROID)
   mojo_application_host_->service_registry()->AddService(
       base::Bind(&device::BatteryMonitorImpl::Create));
 #endif
 
   mojo_application_host_->service_registry()->AddService(
       base::Bind(&PermissionServiceContext::CreateService,
                  base::Unretained(permission_service_context_.get())));
 
@@ skipping 620 matching lines @@
 
   // Set this before ProcessDied() so observers can tell if the render process
   // died due to fast shutdown versus another cause.
   fast_shutdown_started_ = true;
 
   ProcessDied(false /* already_dead */, nullptr);
   return true;
 }
 
 bool RenderProcessHostImpl::Send(IPC::Message* msg) {
-  return SendImpl(base::WrapUnique(msg), false /* send_now */);
+  TRACE_EVENT0("renderer_host", "RenderProcessHostImpl::Send");
+#if !defined(OS_ANDROID)
+  DCHECK(!msg->is_sync());
+#endif
+
+  if (!channel_) {
+#if defined(OS_ANDROID)
+    if (msg->is_sync()) {
+      delete msg;
+      return false;
+    }
+#endif
+    if (!is_initialized_) {
+      queued_messages_.push(msg);
+      return true;
+    } else {
+      delete msg;
+      return false;
+    }
+  }
+
+  if (child_process_launcher_.get() && child_process_launcher_->IsStarting()) {
+#if defined(OS_ANDROID)
+    if (msg->is_sync()) {
+      delete msg;
+      return false;
+    }
+#endif
+    queued_messages_.push(msg);
+    return true;
+  }
+
+  return channel_->Send(msg);
 }
 
 bool RenderProcessHostImpl::OnMessageReceived(const IPC::Message& msg) {
   // If we're about to be deleted, or have initiated the fast shutdown sequence,
   // we ignore incoming messages.
 
   if (deleting_soon_ || fast_shutdown_started_)
     return false;
 
   mark_child_process_activity_time();
@@ skipping 339 matching lines @@
                    p2p_socket_dispatcher_host_);
   }
   return stop_rtp_dump_callback_;
 }
 #endif
 
 IPC::ChannelProxy* RenderProcessHostImpl::GetChannel() {
   return channel_.get();
 }
 
-IPC::Sender* RenderProcessHostImpl::GetImmediateSender() {
-  return immediate_sender_.get();
-}
-
-IPC::Sender* RenderProcessHostImpl::GetIOThreadSender() {
-  return io_thread_sender_.get();
-}
-
 void RenderProcessHostImpl::AddFilter(BrowserMessageFilter* filter) {
   channel_->AddFilter(filter->GetFilter());
 }
 
 bool RenderProcessHostImpl::FastShutdownForPageCount(size_t count) {
   if (GetActiveViewCount() == count)
     return FastShutdownIfPossible();
   return false;
 }
 
@@ skipping 325 matching lines @@
   }
 
   RendererClosedDetails details(status, exit_code);
 
   child_process_launcher_.reset();
 #if USE_ATTACHMENT_BROKER
   IPC::AttachmentBroker::GetGlobal()->DeregisterCommunicationChannel(
       channel_.get());
 #endif
   channel_.reset();
-  while (!queued_messages_.empty())
+  while (!queued_messages_.empty()) {
+    delete queued_messages_.front();
     queued_messages_.pop();
+  }
   UpdateProcessPriority();
   DCHECK(!is_process_backgrounded_);
 
   // RenderProcessExited observers and RenderProcessGone handlers might
   // navigate or perform other actions that require a connection. Ensure that
   // there is one before calling them.
   child_token_ = mojo::edk::GenerateRandomToken();
   mojo_application_host_.reset(new MojoApplicationHost(child_token_));
 
   within_process_died_observer_ = true;
@@ skipping 157 matching lines @@
   // with state that must be there before any JavaScript executes.
   //
   // The queued messages contain such things as "navigate". If this notification
   // was after, we can end up executing JavaScript before the initialization
   // happens.
   NotificationService::current()->Notify(NOTIFICATION_RENDERER_PROCESS_CREATED,
                                          Source<RenderProcessHost>(this),
                                          NotificationService::NoDetails());
 
   while (!queued_messages_.empty()) {
-    Send(queued_messages_.front().release());
+    Send(queued_messages_.front());
     queued_messages_.pop();
   }
 
   if (IsReady()) {
     DCHECK(!sent_render_process_ready_);
     sent_render_process_ready_ = true;
     // Send RenderProcessReady only if the channel is already connected.
     FOR_EACH_OBSERVER(RenderProcessHostObserver,
                       observers_,
                       RenderProcessReady(this));
@@ skipping 213 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