Revert of Decouple Media Service

content/common/gpu/gpu_channel.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.h"
 
 #include <utility>
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 16 matching lines @@
 #include "base/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "content/common/gpu/gpu_channel_manager.h"
 #include "content/common/gpu/gpu_channel_manager_delegate.h"
 #include "content/common/gpu/gpu_memory_buffer_factory.h"
 #include "content/common/gpu/gpu_messages.h"
+#include "content/common/gpu/media/gpu_jpeg_decode_accelerator.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/value_state.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/image_factory.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "gpu/command_buffer/service/valuebuffer_manager.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/message_filter.h"
@@ skipping 18 matching lines @@
 const int64_t kPreemptWaitTimeMs = 2 * kVsyncIntervalMs;
 
 // Once we trigger a preemption, the maximum duration that we will wait
 // before clearing the preemption.
 const int64_t kMaxPreemptTimeMs = kVsyncIntervalMs;
 
 // Stop the preemption once the time for the longest pending IPC drops
 // below this threshold.
 const int64_t kStopPreemptThresholdMs = kVsyncIntervalMs;
 
+void SendCreateJpegDecoderResult(
+    scoped_ptr<IPC::Message> reply_message,
+    scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
+    base::WeakPtr<GpuChannel> channel,
+    scoped_refptr<GpuChannelMessageFilter> filter,
+    bool result) {
+  GpuChannelMsg_CreateJpegDecoder::WriteReplyParams(reply_message.get(),
+                                                    result);
+  if (io_task_runner->BelongsToCurrentThread()) {
+    filter->Send(reply_message.release());
+  } else {
+    channel->Send(reply_message.release());
+  }
+}
+
 }  // anonymous namespace
 
 scoped_refptr<GpuChannelMessageQueue> GpuChannelMessageQueue::Create(
     int32_t stream_id,
     GpuStreamPriority stream_priority,
     GpuChannel* channel,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
     const scoped_refptr<gpu::PreemptionFlag>& preempting_flag,
     const scoped_refptr<gpu::PreemptionFlag>& preempted_flag,
     gpu::SyncPointManager* sync_point_manager) {
@@ skipping 497 matching lines @@
                        gpu::PreemptionFlag* preempting_flag,
                        gpu::PreemptionFlag* preempted_flag,
                        base::SingleThreadTaskRunner* task_runner,
                        base::SingleThreadTaskRunner* io_task_runner,
                        int32_t client_id,
                        uint64_t client_tracing_id,
                        bool allow_view_command_buffers,
                        bool allow_real_time_streams)
     : gpu_channel_manager_(gpu_channel_manager),
       sync_point_manager_(sync_point_manager),
-      unhandled_message_listener_(nullptr),
       channel_id_(IPC::Channel::GenerateVerifiedChannelID("gpu")),
       preempting_flag_(preempting_flag),
       preempted_flag_(preempted_flag),
       client_id_(client_id),
       client_tracing_id_(client_tracing_id),
       task_runner_(task_runner),
       io_task_runner_(io_task_runner),
       share_group_(share_group),
       mailbox_manager_(mailbox),
       subscription_ref_set_(new gpu::gles2::SubscriptionRefSet),
@@ skipping 42 matching lines @@
   base::ScopedFD renderer_fd = channel_->TakeClientFileDescriptor();
   DCHECK(renderer_fd.is_valid());
   channel_handle.socket = base::FileDescriptor(std::move(renderer_fd));
 #endif
 
   channel_->AddFilter(filter_.get());
 
   return channel_handle;
 }
 
-void GpuChannel::SetUnhandledMessageListener(IPC::Listener* listener) {
-  unhandled_message_listener_ = listener;
-}
-
-base::WeakPtr<GpuChannel> GpuChannel::AsWeakPtr() {
-  return weak_factory_.GetWeakPtr();
-}
-
 base::ProcessId GpuChannel::GetClientPID() const {
   return channel_->GetPeerPID();
 }
 
 uint32_t GpuChannel::GetProcessedOrderNum() const {
   uint32_t processed_order_num = 0;
   for (auto& kv : streams_) {
     processed_order_num =
         std::max(processed_order_num, kv.second->GetProcessedOrderNum());
   }
@@ skipping 79 matching lines @@
 
 bool GpuChannel::OnControlMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   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_DELAY_REPLY(GpuChannelMsg_CreateJpegDecoder,
+                                    OnCreateJpegDecoder)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
+  DCHECK(handled) << msg.type();
   return handled;
 }
 
 scoped_refptr<gpu::SyncPointOrderData> GpuChannel::GetSyncPointOrderData(
     int32_t stream_id) {
   auto it = streams_.find(stream_id);
   DCHECK(it != streams_.end());
   DCHECK(it->second);
   return it->second->GetSyncPointOrderData();
 }
@@ skipping 41 matching lines @@
 void GpuChannel::HandleMessageHelper(const IPC::Message& msg) {
   int32_t routing_id = msg.routing_id();
 
   bool handled = false;
   if (routing_id == MSG_ROUTING_CONTROL) {
     handled = OnControlMessageReceived(msg);
   } else {
     handled = router_.RouteMessage(msg);
   }
 
-  if (!handled && unhandled_message_listener_)
-    handled = unhandled_message_listener_->OnMessageReceived(msg);
-
   // Respond to sync messages even if router failed to route.
   if (!handled && msg.is_sync()) {
     IPC::Message* reply = IPC::SyncMessage::GenerateReply(&msg);
     reply->set_reply_error();
     Send(reply);
   }
 }
 
 void GpuChannel::HandleOutOfOrderMessage(const IPC::Message& msg) {
   HandleMessageHelper(msg);
@@ skipping 147 matching lines @@
   // In case the renderer is currently blocked waiting for a sync reply from the
   // stub, we need to make sure to reschedule the correct stream here.
   if (stub && !stub->IsScheduled()) {
     // This stub won't get a chance to reschedule the stream so do that now.
     OnStreamRescheduled(stub->stream_id(), true);
   }
 
   RemoveRoute(route_id);
 }
 
+void GpuChannel::OnCreateJpegDecoder(int32_t route_id,
+                                     IPC::Message* reply_msg) {
+  scoped_ptr<IPC::Message> msg(reply_msg);
+  if (!jpeg_decoder_) {
+    jpeg_decoder_.reset(new GpuJpegDecodeAccelerator(this, io_task_runner_));
+  }
+  jpeg_decoder_->AddClient(
+      route_id,
+      base::Bind(&SendCreateJpegDecoderResult, base::Passed(&msg),
+                 io_task_runner_, weak_factory_.GetWeakPtr(), filter_));
+}
+
 void GpuChannel::CacheShader(const std::string& key,
                              const std::string& shader) {
   gpu_channel_manager_->delegate()->StoreShaderToDisk(client_id_, key, shader);
 }
 
 void GpuChannel::AddFilter(IPC::MessageFilter* filter) {
   io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&GpuChannelMessageFilter::AddChannelFilter,
                             filter_, make_scoped_refptr(filter)));
 }
@@ skipping 53 matching lines @@
     }
   }
 }
 
 void GpuChannel::HandleUpdateValueState(
     unsigned int target, const gpu::ValueState& state) {
   pending_valuebuffer_state_->UpdateState(target, state);
 }
 
 }  // namespace content