Implement GpuArcVideoService for arc video accelerator

content/common/gpu/gpu_channel_manager.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/common/gpu/gpu_channel_manager.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 12 matching lines @@
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_program_cache.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "ipc/message_filter.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_share_group.h"
 
+#if defined(OS_CHROMEOS)
+#include "content/common/gpu/media/gpu_arc_video_service.h"
+#endif
+
 namespace content {
 
 namespace {
 #if defined(OS_ANDROID)
 // Amount of time we expect the GPU to stay powered up without being used.
 const int kMaxGpuIdleTimeMs = 40;
 // Maximum amount of time we keep pinging the GPU waiting for the client to
 // draw.
 const int kMaxKeepAliveTimeMs = 200;
 #endif
@@ skipping 87 matching lines @@
 }
 
 bool GpuChannelManager::OnControlMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuChannelManager, msg)
     IPC_MESSAGE_HANDLER(GpuMsg_EstablishChannel, OnEstablishChannel)
     IPC_MESSAGE_HANDLER(GpuMsg_CloseChannel, OnCloseChannel)
     IPC_MESSAGE_HANDLER(GpuMsg_CreateViewCommandBuffer,
                         OnCreateViewCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuMsg_DestroyGpuMemoryBuffer, OnDestroyGpuMemoryBuffer)
+#if defined(OS_CHROMEOS)
+    IPC_MESSAGE_HANDLER(GpuMsg_CreateArcVideoAcceleratorChannel,
+                        OnCreateArcVideoAcceleratorChannel)
+#endif
     IPC_MESSAGE_HANDLER(GpuMsg_LoadedShader, OnLoadedShader)
     IPC_MESSAGE_HANDLER(GpuMsg_UpdateValueState, OnUpdateValueState)
 #if defined(OS_ANDROID)
     IPC_MESSAGE_HANDLER(GpuMsg_WakeUpGpu, OnWakeUpGpu);
 #endif
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
@@ skipping 89 matching lines @@
           base::Bind(&GpuChannelManager::DestroyGpuMemoryBuffer,
                      base::Unretained(this), id, client_id));
       return;
     }
   }
 
   // No sync token or invalid sync token, destroy immediately.
   DestroyGpuMemoryBuffer(id, client_id);
 }
 
+#if defined(OS_CHROMEOS)
+void GpuChannelManager::OnCreateArcVideoAcceleratorChannel() {
+  if (!gpu_arc_video_service_) {
+    gpu_arc_video_service_.reset(
+        new GpuArcVideoService(shutdown_event_, io_task_runner_));
+  }
+
+  gpu_arc_video_service_->CreateChannel(
+      base::Bind(&GpuChannelManager::ArcVideoAcceleratorChannelCreated,
+                 weak_factory_.GetWeakPtr()));
+}
+
+void GpuChannelManager::ArcVideoAcceleratorChannelCreated(
+    const IPC::ChannelHandle& handle) {
+  Send(new GpuHostMsg_ArcVideoAcceleratorChannelCreated(handle));
+}
+
+void GpuChannelManager::OnShutdownArcVideoService() {
+  gpu_arc_video_service_.reset();
+}
+#endif
+
 void GpuChannelManager::OnUpdateValueState(
     int client_id, unsigned int target, const gpu::ValueState& state) {
   // Only pass updated state to the channel corresponding to the
   // render_widget_host where the event originated.
   auto it = gpu_channels_.find(client_id);
   if (it != gpu_channels_.end())
     it->second->HandleUpdateValueState(target, state);
 }
 
 void GpuChannelManager::OnLoadedShader(const std::string& program_proto) {
@@ skipping 81 matching lines @@
     }
   }
   if (!stub || !stub->decoder()->MakeCurrent())
     return;
   glFinish();
   DidAccessGpu();
 }
 #endif
 
 }  // namespace content