ozone: gpu: Add plumbing for platform-specific gpu messaging

content/browser/gpu/gpu_process_host_ui_shim.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/browser/gpu/gpu_process_host_ui_shim.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/id_map.h"
 #include "base/lazy_instance.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "ui/gl/gl_switches.h"
 
+#if defined(USE_OZONE)
+#include "ui/ozone/gpu/gpu_platform_support_host.h"
+#endif
+
 namespace content {
 
 namespace {
 
 // One of the linux specific headers defines this as a macro.
 #ifdef DestroyAll
 #undef DestroyAll
 #endif
 
 base::LazyInstance<IDMap<GpuProcessHostUIShim> > g_hosts_by_id =
@@ skipping 66 matching lines @@
 }
 
 // static
 void GpuProcessHostUIShim::Destroy(int host_id, const std::string& message) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GpuDataManagerImpl::GetInstance()->AddLogMessage(
       logging::LOG_ERROR, "GpuProcessHostUIShim",
       message);
 
+#if defined(USE_OZONE)
+  ui::GpuPlatformSupportHost::GetInstance()->OnHostDestroyed(host_id);
+#endif
+
   delete FromID(host_id);
 }
 
 // static
 void GpuProcessHostUIShim::DestroyAll() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   while (!g_hosts_by_id.Pointer()->IsEmpty()) {
     IDMap<GpuProcessHostUIShim>::iterator it(g_hosts_by_id.Pointer());
     delete it.GetCurrentValue();
   }
@@ skipping 19 matching lines @@
   return BrowserThread::PostTask(BrowserThread::IO,
                                  FROM_HERE,
                                  base::Bind(&SendOnIOThreadTask,
                                             host_id_,
                                             msg));
 }
 
 bool GpuProcessHostUIShim::OnMessageReceived(const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
 
-  if (message.routing_id() != MSG_ROUTING_CONTROL)
+  if (message.routing_id() == MSG_ROUTING_CONTROL)
+    return OnControlMessageReceived(message);
+
+  IPC::Listener* listener = routes_.Lookup(message.routing_id());
+  if (!listener)
     return false;
 
-  return OnControlMessageReceived(message);
+  listener->OnMessageReceived(message);
+  return true;
 }
 
 void GpuProcessHostUIShim::SimulateRemoveAllContext() {
   Send(new GpuMsg_Clean());
 }
 
 void GpuProcessHostUIShim::SimulateCrash() {
   Send(new GpuMsg_Crash());
 }
 
 void GpuProcessHostUIShim::SimulateHang() {
   Send(new GpuMsg_Hang());
 }
 
+void GpuProcessHostUIShim::AddRoute(int32 routing_id, IPC::Listener* listener) {
+  routes_.AddWithID(listener, routing_id);
+}
+
 GpuProcessHostUIShim::~GpuProcessHostUIShim() {
   DCHECK(CalledOnValidThread());
   g_hosts_by_id.Pointer()->Remove(host_id_);
 }
 
 bool GpuProcessHostUIShim::OnControlMessageReceived(
     const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
 
   IPC_BEGIN_MESSAGE_MAP(GpuProcessHostUIShim, message)
@@ skipping 10 matching lines @@
                         OnAcceleratedSurfaceSuspend)
     IPC_MESSAGE_HANDLER(GpuHostMsg_GraphicsInfoCollected,
                         OnGraphicsInfoCollected)
     IPC_MESSAGE_HANDLER(GpuHostMsg_AcceleratedSurfaceRelease,
                         OnAcceleratedSurfaceRelease)
     IPC_MESSAGE_HANDLER(GpuHostMsg_VideoMemoryUsageStats,
                         OnVideoMemoryUsageStatsReceived);
     IPC_MESSAGE_HANDLER(GpuHostMsg_UpdateVSyncParameters,
                         OnUpdateVSyncParameters)
     IPC_MESSAGE_HANDLER(GpuHostMsg_FrameDrawn, OnFrameDrawn)
+    IPC_MESSAGE_HANDLER(GpuHostMsg_PlatformSupportInitialized,
+                        OnPlatformSupportInitialized);
 
     IPC_MESSAGE_UNHANDLED_ERROR()
   IPC_END_MESSAGE_MAP()
 
   return true;
 }
 
 void GpuProcessHostUIShim::OnUpdateVSyncParameters(int surface_id,
                                                    base::TimeTicks timebase,
                                                    base::TimeDelta interval) {
@@ skipping 72 matching lines @@
 }
 
 void GpuProcessHostUIShim::OnFrameDrawn(
     const std::vector<ui::LatencyInfo>& latency_info) {
   if (!ui::LatencyInfo::Verify(latency_info,
                                "GpuProcessHostUIShim::OnFrameDrawn"))
     return;
   RenderWidgetHostImpl::CompositorFrameDrawn(latency_info);
 }
 
+void GpuProcessHostUIShim::OnPlatformSupportInitialized(int32 host_route_id,
+                                                        int32 gpu_route_id) {
+#if defined(USE_OZONE)
+  ui::GpuPlatformSupportHost* platform_support_host =
+      ui::GpuPlatformSupportHost::GetInstance();
+  AddRoute(host_route_id, platform_support_host);
+  platform_support_host->OnChannelEstablished(host_id_, gpu_route_id, this);
+#endif
+}
+
 void GpuProcessHostUIShim::OnAcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params) {
   TRACE_EVENT0("renderer",
       "GpuProcessHostUIShim::OnAcceleratedSurfacePostSubBuffer");
   if (!ui::LatencyInfo::Verify(params.latency_info,
                                "GpuHostMsg_AcceleratedSurfacePostSubBuffer"))
     return;
   AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
   ack_params.mailbox = params.mailbox;
   ack_params.sync_point = 0;
@@ skipping 42 matching lines @@
   view->AcceleratedSurfaceRelease();
 }
 
 void GpuProcessHostUIShim::OnVideoMemoryUsageStatsReceived(
     const GPUVideoMemoryUsageStats& video_memory_usage_stats) {
   GpuDataManagerImpl::GetInstance()->UpdateVideoMemoryUsageStats(
       video_memory_usage_stats);
 }
 
 }  // namespace content