media: gpu process ipc video decoder implementation

chrome/gpu/gpu_channel.cc

 // Copyright (c) 2010 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 "chrome/gpu/gpu_channel.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "base/command_line.h"
 #include "base/lock.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "chrome/common/child_process.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/gpu_messages.h"
 #include "chrome/gpu/gpu_thread.h"
+#include "chrome/gpu/gpu_video_service.h"
 
 #if defined(OS_POSIX)
 #include "ipc/ipc_channel_posix.h"
 #endif
 
 GpuChannel::GpuChannel(int renderer_id)
     : renderer_id_(renderer_id)
 #if defined(OS_POSIX)
     , renderer_fd_(-1)
 #endif
@@ skipping 51 matching lines @@
 }
 
 void GpuChannel::OnControlMessageReceived(const IPC::Message& msg) {
   IPC_BEGIN_MESSAGE_MAP(GpuChannel, msg)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_CreateViewCommandBuffer,
         OnCreateViewCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_CreateOffscreenCommandBuffer,
         OnCreateOffscreenCommandBuffer)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_DestroyCommandBuffer,
         OnDestroyCommandBuffer)
+    IPC_MESSAGE_HANDLER(GpuChannelMsg_GetVideoService,
+        OnGetVideoService)
+    IPC_MESSAGE_HANDLER(GpuChannelMsg_CreateVideoDecoder,
+        OnCreateVideoDecoder)
+    IPC_MESSAGE_HANDLER(GpuChannelMsg_DestroyVideoDecoder,
+        OnDestroyVideoDecoder)
     IPC_MESSAGE_UNHANDLED_ERROR()
   IPC_END_MESSAGE_MAP()
 }
 
 int GpuChannel::GenerateRouteID() {
   static int last_id = 0;
   return ++last_id;
 }
 
 void GpuChannel::OnCreateViewCommandBuffer(gfx::NativeViewId view_id,
@@ skipping 70 matching lines @@
 #endif
 }
 
 void GpuChannel::OnDestroyCommandBuffer(int32 route_id) {
 #if defined(ENABLE_GPU)
   router_.RemoveRoute(route_id);
   stubs_.Remove(route_id);
 #endif
 }
 
+void GpuChannel::OnGetVideoService(GpuVideoServiceInfoParam* info) {
+  info->service_available_ = 0;
+#if defined(ENABLE_GPU)
+#if defined(OS_WIN)
+  // TODO(jiesun): Not every windows platforms will support our media
+  // foundation implementation. Add more check here.
+  LOG(INFO) << "GpuChannel::OnGetVideoService";
+  GpuVideoService* service = GpuVideoService::get();
+  if (service == NULL)
+    return;
+
+  info->video_service_host_route_id_ = GenerateRouteID();
+  info->video_service_route_id_ = GenerateRouteID();
+  // TODO(jiesun): we could had multiple entries in this routing table.
+  router_.AddRoute(info->video_service_route_id_, service);
+  info->service_available_ = 1;
+#endif
+#endif
+}
+
+void GpuChannel::OnCreateVideoDecoder(GpuVideoDecoderInfoParam* info) {
+#if defined(ENABLE_GPU)
+  LOG(INFO) << "GpuChannel::OnCreateVideoDecoder";
+  info->decoder_id_ = -1;
+  GpuVideoService* service = GpuVideoService::get();
+  if (service == NULL)
+    return;
+
+  info->decoder_host_route_id_ = GenerateRouteID();
+  info->decoder_route_id_ = GenerateRouteID();
+  service->CreateVideoDecoder(this, &router_, info);
+#endif
+}
+
+void GpuChannel::OnDestroyVideoDecoder(int32 decoder_id) {
+#if defined(ENABLE_GPU)
+  LOG(ERROR) << "GpuChannel::OnDestroyVideoDecoder";
+  GpuVideoService* service = GpuVideoService::get();
+  if (service == NULL)
+    return;
+  service->DestroyVideoDecoder(&router_, decoder_id);
+#endif
+}
+
 bool GpuChannel::Init() {
   // Check whether we're already initialized.
   if (channel_.get())
     return true;
 
   // Map renderer ID to a (single) channel to that process.
   std::string channel_name = GetChannelName();
 #if defined(OS_POSIX)
   // This gets called when the GpuChannel is initially created. At this
   // point, create the socketpair and assign the GPU side FD to the channel
   // name. Keep the renderer side FD as a member variable in the PluginChannel
   // to be able to transmit it through IPC.
   int gpu_fd;
   IPC::SocketPair(&gpu_fd, &renderer_fd_);
   IPC::AddChannelSocket(channel_name, gpu_fd);
 #endif
   channel_.reset(new IPC::SyncChannel(
       channel_name, IPC::Channel::MODE_SERVER, this, NULL,
       ChildProcess::current()->io_message_loop(), false,
       ChildProcess::current()->GetShutDownEvent()));
+
   return true;
 }
 
 std::string GpuChannel::GetChannelName() {
   return StringPrintf("%d.r%d", base::GetCurrentProcId(), renderer_id_);
 }