Decouple browser-specific GPU IPC messages from GPU service IPCs

content/gpu/gpu_child_thread.cc

 // 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.
 
 #include "content/gpu/gpu_child_thread.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/threading/worker_pool.h"
 #include "build/build_config.h"
 #include "content/child/child_process.h"
 #include "content/child/thread_safe_sender.h"
+#include "content/common/gpu/establish_channel_params.h"
+#include "content/common/gpu/gpu_browser_messages.h"
 #include "content/common/gpu/gpu_memory_buffer_factory.h"
-#include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/media/gpu_video_decode_accelerator.h"
 #include "content/gpu/gpu_process_control_impl.h"
 #include "content/gpu/gpu_watchdog_thread.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/config/gpu_info_collector.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gpu_switching_manager.h"
 
 #if defined(USE_OZONE)
 #include "ui/ozone/public/gpu_platform_support.h"
 #include "ui/ozone/public/ozone_platform.h"
 #endif
 
 namespace content {
 namespace {
 
 static base::LazyInstance<scoped_refptr<ThreadSafeSender> >
     g_thread_safe_sender = LAZY_INSTANCE_INITIALIZER;
 
 bool GpuProcessLogMessageHandler(int severity,
                                  const char* file, int line,
                                  size_t message_start,
                                  const std::string& str) {
   std::string header = str.substr(0, message_start);
   std::string message = str.substr(message_start);
 
-  g_thread_safe_sender.Get()->Send(new GpuHostMsg_OnLogMessage(
-      severity, header, message));
+  g_thread_safe_sender.Get()->Send(
+      new GpuBrowserHostMsg_OnLogMessage(severity, header, message));
 
   return false;
 }
 
-// Message filter used to to handle GpuMsg_CreateGpuMemoryBuffer messages on
+// Message filter used to to handle GpuBrowserMsg_CreateGpuMemoryBuffer messages
+// on
 // the IO thread. This allows the UI thread in the browser process to remain
 // fast at all times.
 class GpuMemoryBufferMessageFilter : public IPC::MessageFilter {
  public:
   explicit GpuMemoryBufferMessageFilter(
       GpuMemoryBufferFactory* gpu_memory_buffer_factory)
       : gpu_memory_buffer_factory_(gpu_memory_buffer_factory),
         sender_(nullptr) {}
 
   // Overridden from IPC::MessageFilter:
   void OnFilterAdded(IPC::Sender* sender) override {
     DCHECK(!sender_);
     sender_ = sender;
   }
   void OnFilterRemoved() override {
     DCHECK(sender_);
     sender_ = nullptr;
   }
   bool OnMessageReceived(const IPC::Message& message) override {
     DCHECK(sender_);
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(GpuMemoryBufferMessageFilter, message)
-    IPC_MESSAGE_HANDLER(GpuMsg_CreateGpuMemoryBuffer, OnCreateGpuMemoryBuffer)
-    IPC_MESSAGE_HANDLER(GpuMsg_CreateGpuMemoryBufferFromHandle,
-                        OnCreateGpuMemoryBufferFromHandle)
-    IPC_MESSAGE_UNHANDLED(handled = false)
+      IPC_MESSAGE_HANDLER(GpuBrowserMsg_CreateGpuMemoryBuffer,
+                          OnCreateGpuMemoryBuffer)
+      IPC_MESSAGE_HANDLER(GpuBrowserMsg_CreateGpuMemoryBufferFromHandle,
+                          OnCreateGpuMemoryBufferFromHandle)
+      IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     return handled;
   }
 
  protected:
   ~GpuMemoryBufferMessageFilter() override {}
 
   void OnCreateGpuMemoryBuffer(
-      const GpuMsg_CreateGpuMemoryBuffer_Params& params) {
+      const GpuBrowserMsg_CreateGpuMemoryBuffer_Params& params) {
     TRACE_EVENT2("gpu", "GpuMemoryBufferMessageFilter::OnCreateGpuMemoryBuffer",
                  "id", params.id.id, "client_id", params.client_id);
 
     DCHECK(gpu_memory_buffer_factory_);
-    sender_->Send(new GpuHostMsg_GpuMemoryBufferCreated(
+    sender_->Send(new GpuBrowserHostMsg_GpuMemoryBufferCreated(
         gpu_memory_buffer_factory_->CreateGpuMemoryBuffer(
             params.id, params.size, params.format, params.usage,
             params.client_id, params.surface_handle)));
   }
 
   void OnCreateGpuMemoryBufferFromHandle(
-      const GpuMsg_CreateGpuMemoryBufferFromHandle_Params& params) {
+      const GpuBrowserMsg_CreateGpuMemoryBufferFromHandle_Params& params) {
     TRACE_EVENT2(
         "gpu",
         "GpuMemoryBufferMessageFilter::OnCreateGpuMemoryBufferFromHandle", "id",
         params.id.id, "client_id", params.client_id);
-    sender_->Send(new GpuHostMsg_GpuMemoryBufferCreated(
+    sender_->Send(new GpuBrowserHostMsg_GpuMemoryBufferCreated(
         gpu_memory_buffer_factory_->CreateGpuMemoryBufferFromHandle(
             params.handle, params.id, params.size, params.format,
             params.client_id)));
   }
 
   GpuMemoryBufferFactory* const gpu_memory_buffer_factory_;
   IPC::Sender* sender_;
 };
 
 ChildThreadImpl::Options GetOptions(
@@ skipping 95 matching lines @@
   // The GPU process must never send a synchronous IPC message to the browser
   // process. This could result in deadlock.
   DCHECK(!msg->is_sync());
 
   return ChildThreadImpl::Send(msg);
 }
 
 bool GpuChildThread::OnControlMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuChildThread, msg)
-    IPC_MESSAGE_HANDLER(GpuMsg_Initialize, OnInitialize)
-    IPC_MESSAGE_HANDLER(GpuMsg_Finalize, OnFinalize)
-    IPC_MESSAGE_HANDLER(GpuMsg_CollectGraphicsInfo, OnCollectGraphicsInfo)
-    IPC_MESSAGE_HANDLER(GpuMsg_GetVideoMemoryUsageStats,
+    IPC_MESSAGE_HANDLER(GpuBrowserMsg_Initialize, OnInitialize)
+    IPC_MESSAGE_HANDLER(GpuBrowserMsg_Finalize, OnFinalize)
+    IPC_MESSAGE_HANDLER(GpuBrowserMsg_CollectGraphicsInfo,
+                        OnCollectGraphicsInfo)
+    IPC_MESSAGE_HANDLER(GpuBrowserMsg_GetVideoMemoryUsageStats,
                         OnGetVideoMemoryUsageStats)
-    IPC_MESSAGE_HANDLER(GpuMsg_Clean, OnClean)
-    IPC_MESSAGE_HANDLER(GpuMsg_Crash, OnCrash)
-    IPC_MESSAGE_HANDLER(GpuMsg_Hang, OnHang)
-    IPC_MESSAGE_HANDLER(GpuMsg_DisableWatchdog, OnDisableWatchdog)
-    IPC_MESSAGE_HANDLER(GpuMsg_GpuSwitched, OnGpuSwitched)
+    IPC_MESSAGE_HANDLER(GpuBrowserMsg_Clean, OnClean)
+    IPC_MESSAGE_HANDLER(GpuBrowserMsg_Crash, OnCrash)
+    IPC_MESSAGE_HANDLER(GpuBrowserMsg_Hang, OnHang)
+    IPC_MESSAGE_HANDLER(GpuBrowserMsg_DisableWatchdog, OnDisableWatchdog)
+    IPC_MESSAGE_HANDLER(GpuBrowserMsg_GpuSwitched, OnGpuSwitched)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   if (handled)
     return true;
 
 #if defined(USE_OZONE)
   if (ui::OzonePlatform::GetInstance()
           ->GetGpuPlatformSupport()
           ->OnMessageReceived(msg))
     return true;
 #endif
 
   return false;
 }
 
 bool GpuChildThread::OnMessageReceived(const IPC::Message& msg) {
   if (ChildThreadImpl::OnMessageReceived(msg))
     return true;
 
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(GpuChildThread, msg)
+    IPC_MESSAGE_HANDLER(GpuBrowserMsg_EstablishChannel, OnEstablishChannel)
+    IPC_MESSAGE_HANDLER(GpuBrowserMsg_CloseChannel, OnCloseChannel)
+    IPC_MESSAGE_HANDLER(GpuBrowserMsg_DestroyGpuMemoryBuffer,
+                        OnDestroyGpuMemoryBuffer)
+    IPC_MESSAGE_HANDLER(GpuBrowserMsg_LoadedShader, OnLoadedShader)
+    IPC_MESSAGE_HANDLER(GpuBrowserMsg_UpdateValueState, OnUpdateValueState)
+#if defined(OS_ANDROID)
+    IPC_MESSAGE_HANDLER(GpuBrowserMsg_WakeUpGpu, OnWakeUpGpu);
+#endif
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  if (handled)
+    return true;
+
   return gpu_channel_manager_.get() &&
          gpu_channel_manager_->OnMessageReceived(msg);
 }
 
+void GpuChildThread::AddSubscription(int32_t client_id, unsigned int target) {
+  Send(new GpuBrowserHostMsg_AddSubscription(client_id, target));
+}
+
+void GpuChildThread::CacheShader(int32_t client_id,
+                                 const std::string& key,
+                                 const std::string& shader) {
+  Send(new GpuBrowserHostMsg_CacheShader(client_id, key, shader));
+}
+
+void GpuChildThread::ChannelEstablished(
+    const IPC::ChannelHandle& channel_handle) {
+  Send(new GpuBrowserHostMsg_ChannelEstablished(channel_handle));
+}
+
+void GpuChildThread::DestroyChannel(int client_id) {
+  Send(new GpuBrowserHostMsg_DestroyChannel(client_id));
+}
+
+void GpuChildThread::DidCreateOffscreenContext(const GURL& active_url) {
+  Send(new GpuBrowserHostMsg_DidCreateOffscreenContext(active_url));
+}
+
+void GpuChildThread::DidDestroyOffscreenContext(const GURL& active_url) {
+  Send(new GpuBrowserHostMsg_DidDestroyOffscreenContext(active_url));
+}
+
+void GpuChildThread::DidLoseContext(bool offscreen,
+                                    gpu::error::ContextLostReason reason,
+                                    const GURL& active_url) {
+  Send(new GpuBrowserHostMsg_DidLoseContext(offscreen, reason, active_url));
+}
+
+void GpuChildThread::GpuMemoryUmaStats(const GPUMemoryUmaStats& params) {
+  Send(new GpuBrowserHostMsg_GpuMemoryUmaStats(params));
+}
+
+void GpuChildThread::RemoveSubscription(int32_t client_id,
+                                        unsigned int target) {
+  Send(new GpuBrowserHostMsg_RemoveSubscription(client_id, target));
+}
+
 void GpuChildThread::OnInitialize() {
   // Record initialization only after collecting the GPU info because that can
   // take a significant amount of time.
   gpu_info_.initialization_time = base::Time::Now() - process_start_time_;
-  Send(new GpuHostMsg_Initialized(!dead_on_arrival_, gpu_info_));
+  Send(new GpuBrowserHostMsg_Initialized(!dead_on_arrival_, gpu_info_));
   while (!deferred_messages_.empty()) {
     Send(deferred_messages_.front());
     deferred_messages_.pop();
   }
 
   if (dead_on_arrival_) {
     LOG(ERROR) << "Exiting GPU process due to errors during initialization";
     base::MessageLoop::current()->QuitWhenIdle();
     return;
   }
 
   // We don't need to pipe log messages if we are running the GPU thread in
   // the browser process.
   if (!in_browser_process_)
     logging::SetLogMessageHandler(GpuProcessLogMessageHandler);
 
   // Defer creation of the render thread. This is to prevent it from handling
   // IPC messages before the sandbox has been enabled and all other necessary
   // initialization has succeeded.
   gpu_channel_manager_.reset(
-      new GpuChannelManager(channel(), watchdog_thread_.get(),
+      new GpuChannelManager(this, channel(), watchdog_thread_.get(),
                             base::ThreadTaskRunnerHandle::Get().get(),
                             ChildProcess::current()->io_task_runner(),
                             ChildProcess::current()->GetShutDownEvent(),
                             sync_point_manager_, gpu_memory_buffer_factory_));
 
 #if defined(USE_OZONE)
   ui::OzonePlatform::GetInstance()
       ->GetGpuPlatformSupport()
       ->OnChannelEstablished(this);
 #endif
@@ skipping 38 matching lines @@
   GetContentClient()->SetGpuInfo(gpu_info_);
 
 #if defined(OS_WIN)
   // This is slow, but it's the only thing the unsandboxed GPU process does,
   // and GpuDataManager prevents us from sending multiple collecting requests,
   // so it's OK to be blocking.
   gpu::GetDxDiagnostics(&gpu_info_.dx_diagnostics);
   gpu_info_.dx_diagnostics_info_state = gpu::kCollectInfoSuccess;
 #endif  // OS_WIN
 
-  Send(new GpuHostMsg_GraphicsInfoCollected(gpu_info_));
+  Send(new GpuBrowserHostMsg_GraphicsInfoCollected(gpu_info_));
 
 #if defined(OS_WIN)
   if (!in_browser_process_) {
     // The unsandboxed GPU process fulfilled its duty.  Rest in peace.
     base::MessageLoop::current()->QuitWhenIdle();
   }
 #endif  // OS_WIN
 }
 
 void GpuChildThread::OnGetVideoMemoryUsageStats() {
   GPUVideoMemoryUsageStats video_memory_usage_stats;
   if (gpu_channel_manager_)
     gpu_channel_manager_->gpu_memory_manager()->GetVideoMemoryUsageStats(
         &video_memory_usage_stats);
-  Send(new GpuHostMsg_VideoMemoryUsageStats(video_memory_usage_stats));
+  Send(new GpuBrowserHostMsg_VideoMemoryUsageStats(video_memory_usage_stats));
 }
 
 void GpuChildThread::OnClean() {
   DVLOG(1) << "GPU: Removing all contexts";
   if (gpu_channel_manager_)
-    gpu_channel_manager_->LoseAllContexts();
+    gpu_channel_manager_->ClearAllChannels();
 }
 
 void GpuChildThread::OnCrash() {
   DVLOG(1) << "GPU: Simulating GPU crash";
   // Good bye, cruel world.
   volatile int* it_s_the_end_of_the_world_as_we_know_it = NULL;
   *it_s_the_end_of_the_world_as_we_know_it = 0xdead;
 }
 
 void GpuChildThread::OnHang() {
@@ skipping 15 matching lines @@
     watchdog_thread_->Stop();
   }
 }
 
 void GpuChildThread::OnGpuSwitched() {
   DVLOG(1) << "GPU: GPU has switched";
   // Notify observers in the GPU process.
   ui::GpuSwitchingManager::GetInstance()->NotifyGpuSwitched();
 }
 
+void GpuChildThread::OnEstablishChannel(const EstablishChannelParams& params) {
+  if (gpu_channel_manager_)
+    gpu_channel_manager_->EstablishChannel(params);
+}
+
+void GpuChildThread::OnCloseChannel(const IPC::ChannelHandle& channel_handle) {
+  if (gpu_channel_manager_)
+    gpu_channel_manager_->CloseChannel(channel_handle);
+}
+
+void GpuChildThread::OnLoadedShader(const std::string& shader) {
+  if (gpu_channel_manager_)
+    gpu_channel_manager_->LoadedShader(shader);
+}
+
+void GpuChildThread::OnDestroyGpuMemoryBuffer(
+    gfx::GpuMemoryBufferId id,
+    int client_id,
+    const gpu::SyncToken& sync_token) {
+  if (gpu_channel_manager_)
+    gpu_channel_manager_->DestroyGpuMemoryBuffer(id, client_id, sync_token);
+}
+
+void GpuChildThread::OnUpdateValueState(int client_id,
+                                        unsigned int target,
+                                        const gpu::ValueState& state) {
+  if (gpu_channel_manager_)
+    gpu_channel_manager_->UpdateValueState(client_id, target, state);
+}
+
+#if defined(OS_ANDROID)
+void GpuChildThread::OnWakeUpGpu() {
+  if (gpu_channel_manager_)
+    gpu_channel_manager_->WakeUpGpu();
+}
+#endif
+
+void GpuChildThread::OnLoseAllContexts() {
+  if (gpu_channel_manager_)
+    gpu_channel_manager_->ClearAllChannels();
+}
+
 void GpuChildThread::BindProcessControlRequest(
     mojo::InterfaceRequest<ProcessControl> request) {
   DVLOG(1) << "GPU: Binding ProcessControl request";
   DCHECK(process_control_);
   process_control_bindings_.AddBinding(process_control_.get(),
                                        std::move(request));
 }
 
 }  // namespace content