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

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 "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/gpu_messages.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"
 
+#if defined(USE_OZONE)
+#include "ui/ozone/gpu/gpu_platform_support.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) {
@@ skipping 13 matching lines @@
                                const gpu::GPUInfo& gpu_info,
                                const DeferredMessages& deferred_messages)
     : dead_on_arrival_(dead_on_arrival),
       gpu_info_(gpu_info),
       deferred_messages_(deferred_messages),
       in_browser_process_(false) {
   watchdog_thread_ = watchdog_thread;
 #if defined(OS_WIN)
   target_services_ = NULL;
 #endif
+#if defined(USE_OZONE)
+  ui::GpuPlatformSupport::Initialize();
+#endif
   g_thread_safe_sender.Get() = thread_safe_sender();
 }
 
 GpuChildThread::GpuChildThread(const std::string& channel_id)
     : ChildThread(channel_id),
       dead_on_arrival_(false),
       in_browser_process_(true) {
 #if defined(OS_WIN)
   target_services_ = NULL;
 #endif
@@ skipping 41 matching lines @@
     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_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   if (handled)
     return true;
 
+#if defined(USE_OZONE)
+  if (ui::GpuPlatformSupport::GetInstance()->OnMessageReceived(msg))
+    return true;
+#endif
+
   return gpu_channel_manager_.get() &&
       gpu_channel_manager_->OnMessageReceived(msg);
 }
 
 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_));
   while (!deferred_messages_.empty()) {
@@ skipping 19 matching lines @@
     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(GetRouter(),
                             watchdog_thread_.get(),
                             ChildProcess::current()->io_message_loop_proxy(),
                             ChildProcess::current()->GetShutDownEvent()));
+
+#if defined(USE_OZONE)
+  ui::GpuPlatformSupport::GetInstance()->OnChannelEstablished(this);
+#endif
 }
 
 void GpuChildThread::StopWatchdog() {
   if (watchdog_thread_.get()) {
     watchdog_thread_->Stop();
   }
 }
 
 void GpuChildThread::OnCollectGraphicsInfo() {
 #if defined(OS_WIN)
@@ skipping 73 matching lines @@
     // the future posting of tasks to the message loop.
     if (watchdog_thread_->message_loop())
       watchdog_thread_->PostAcknowledge();
     // Prevent rearming.
     watchdog_thread_->Stop();
   }
 }
 
 }  // namespace content