Implement GpuArcVideoService for arc video accelerator

content/browser/gpu/gpu_process_host.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.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 586 matching lines @@
 bool GpuProcessHost::OnMessageReceived(const IPC::Message& message) {
   DCHECK(CalledOnValidThread());
   IPC_BEGIN_MESSAGE_MAP(GpuProcessHost, message)
     IPC_MESSAGE_HANDLER(GpuHostMsg_Initialized, OnInitialized)
     IPC_MESSAGE_HANDLER(GpuHostMsg_ChannelEstablished, OnChannelEstablished)
     IPC_MESSAGE_HANDLER(GpuHostMsg_CommandBufferCreated, OnCommandBufferCreated)
     IPC_MESSAGE_HANDLER(GpuHostMsg_GpuMemoryBufferCreated,
                         OnGpuMemoryBufferCreated)
     IPC_MESSAGE_HANDLER(GpuHostMsg_DidCreateOffscreenContext,
                         OnDidCreateOffscreenContext)
+#if defined(OS_CHROMEOS)
+    IPC_MESSAGE_HANDLER(GpuHostMsg_ArcVideoAcceleratorChannelCreated,
+                        OnArcVideoAcceleratorChannelCreated)
+#endif
     IPC_MESSAGE_HANDLER(GpuHostMsg_DidLoseContext, OnDidLoseContext)
     IPC_MESSAGE_HANDLER(GpuHostMsg_DidDestroyOffscreenContext,
                         OnDidDestroyOffscreenContext)
     IPC_MESSAGE_HANDLER(GpuHostMsg_GpuMemoryUmaStats,
                         OnGpuMemoryUmaStatsReceived)
 #if defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER_GENERIC(GpuHostMsg_AcceleratedSurfaceBuffersSwapped,
                                 OnAcceleratedSurfaceBuffersSwapped(message))
 #endif
     IPC_MESSAGE_HANDLER(GpuHostMsg_DestroyChannel,
@@ skipping 129 matching lines @@
 void GpuProcessHost::DestroyGpuMemoryBuffer(gfx::GpuMemoryBufferId id,
                                             int client_id,
                                             const gpu::SyncToken& sync_token) {
   TRACE_EVENT0("gpu", "GpuProcessHost::DestroyGpuMemoryBuffer");
 
   DCHECK(CalledOnValidThread());
 
   Send(new GpuMsg_DestroyGpuMemoryBuffer(id, client_id, sync_token));
 }
 
+#if defined(OS_CHROMEOS)
+void GpuProcessHost::CreateArcVideoAcceleratorChannel(
+    const CreateArcVideoAcceleratorChannelCallback& callback) {
+  DCHECK(CalledOnValidThread());
+
+  if (Send(new GpuMsg_CreateArcVideoAcceleratorChannel())) {
+    create_arc_video_accelerator_channel_requests_.push(callback);
+  } else {
+    callback.Run(IPC::ChannelHandle());
+  }
+}
+#endif
+
 void GpuProcessHost::OnInitialized(bool result, const gpu::GPUInfo& gpu_info) {
   UMA_HISTOGRAM_BOOLEAN("GPU.GPUProcessInitialized", result);
   initialized_ = result;
 
   if (!initialized_)
     GpuDataManagerImpl::GetInstance()->OnGpuProcessInitFailure();
   else if (!in_process_)
     GpuDataManagerImpl::GetInstance()->UpdateGpuInfo(gpu_info);
 }
 
@@ skipping 47 matching lines @@
 
   if (create_gpu_memory_buffer_requests_.empty())
     return;
 
   CreateGpuMemoryBufferCallback callback =
       create_gpu_memory_buffer_requests_.front();
   create_gpu_memory_buffer_requests_.pop();
   callback.Run(handle);
 }
 
+#if defined(OS_CHROMEOS)
+void GpuProcessHost::OnArcVideoAcceleratorChannelCreated(
+    const IPC::ChannelHandle& handle) {
+  if (create_arc_video_accelerator_channel_requests_.empty()) {
+    RouteOnUIThread(
+        GpuHostMsg_OnLogMessage(logging::LOG_WARNING, "WARNING",
+                                "Received a ArcVideoAcceleratorChannelCreated "
+                                "message but no requests in queue."));
+    return;
+  }
+
+  CreateArcVideoAcceleratorChannelCallback callback =
+      create_arc_video_accelerator_channel_requests_.front();
+  create_arc_video_accelerator_channel_requests_.pop();
+  callback.Run(handle);
+}
+#endif
+
 void GpuProcessHost::OnDidCreateOffscreenContext(const GURL& url) {
   urls_with_live_offscreen_contexts_.insert(url);
 }
 
 void GpuProcessHost::OnDidLoseContext(bool offscreen,
                                       gpu::error::ContextLostReason reason,
                                       const GURL& url) {
   // TODO(kbr): would be nice to see the "offscreen" flag too.
   TRACE_EVENT2("gpu", "GpuProcessHost::OnDidLoseContext",
                "reason", reason,
@@ skipping 185 matching lines @@
     create_command_buffer_requests_.pop();
     callback.Run(CREATE_COMMAND_BUFFER_FAILED_AND_CHANNEL_LOST);
   }
 
   while (!create_gpu_memory_buffer_requests_.empty()) {
     CreateGpuMemoryBufferCallback callback =
         create_gpu_memory_buffer_requests_.front();
     create_gpu_memory_buffer_requests_.pop();
     callback.Run(gfx::GpuMemoryBufferHandle());
   }
+
+#if defined(OS_CHROMEOS)
+  while (!create_arc_video_accelerator_channel_requests_.empty()) {
+    CreateArcVideoAcceleratorChannelCallback callback =
+        create_arc_video_accelerator_channel_requests_.front();
+    create_arc_video_accelerator_channel_requests_.pop();
+    callback.Run(IPC::ChannelHandle());
+  }
+#endif
 }
 
 void GpuProcessHost::BlockLiveOffscreenContexts() {
   for (std::multiset<GURL>::iterator iter =
            urls_with_live_offscreen_contexts_.begin();
        iter != urls_with_live_offscreen_contexts_.end(); ++iter) {
     GpuDataManagerImpl::GetInstance()->BlockDomainFrom3DAPIs(
         *iter, GpuDataManagerImpl::DOMAIN_GUILT_UNKNOWN);
   }
 }
@@ skipping 107 matching lines @@
   TRACE_EVENT0("gpu", "GpuProcessHost::OnCacheShader");
   ClientIdToShaderCacheMap::iterator iter =
       client_id_to_shader_cache_.find(client_id);
   // If the cache doesn't exist then this is an off the record profile.
   if (iter == client_id_to_shader_cache_.end())
     return;
   iter->second->Cache(GetShaderPrefixKey() + ":" + key, shader);
 }
 
 }  // namespace content