Run VDA::Decode on GPU IO thread if VDA supports it.

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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/common/gpu/gpu_channel.h"
 
@@ skipping 86 matching lines @@
   virtual void OnFilterAdded(IPC::Channel* channel) OVERRIDE {
     DCHECK(!channel_);
     channel_ = channel;
   }
 
   virtual void OnFilterRemoved() OVERRIDE {
     DCHECK(channel_);
     channel_ = NULL;
   }
 
+  void AddRoute(int32 route_id, IPC::Listener* listener) {
+    router_.AddRoute(route_id, listener);
+  }
+
+  void RemoveRoute(int32 route_id) {
+    router_.RemoveRoute(route_id);
+  }
+
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
     DCHECK(channel_);
 
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(GpuChannelMessageFilter, message)
       IPC_MESSAGE_HANDLER(GpuChannelMsg_GenerateMailboxNames,
                           OnGenerateMailboxNames)
       IPC_MESSAGE_HANDLER(GpuChannelMsg_GenerateMailboxNamesAsync,
                           OnGenerateMailboxNamesAsync)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
 
     if (message.type() == GpuCommandBufferMsg_RetireSyncPoint::ID) {
       // This message should not be sent explicitly by the renderer.
       NOTREACHED();
       handled = true;
     }
 
+    if (message.type() == AcceleratedVideoDecoderMsg_Decode::ID) {
+      handled = router_.RouteMessage(message);
+    }
+
     // All other messages get processed by the GpuChannel.
     if (!handled) {
       messages_forwarded_to_channel_++;
       if (preempting_flag_.get())
         pending_messages_.push(PendingMessage(messages_forwarded_to_channel_));
       UpdatePreemptionState();
     }
 
     if (message.type() == GpuCommandBufferMsg_InsertSyncPoint::ID) {
       uint32 sync_point = sync_point_manager_->GenerateSyncPoint();
@@ skipping 286 matching lines @@
   std::queue<PendingMessage> pending_messages_;
 
   // Count of the number of IPCs forwarded to the GpuChannel.
   uint64 messages_forwarded_to_channel_;
 
   base::OneShotTimer<GpuChannelMessageFilter> timer_;
 
   bool a_stub_is_descheduled_;
 
   crypto::HMAC hmac_;
+
+  // Used to implement message routing functionality running on IO thread.
+  MessageRouter router_;
 };
 
 GpuChannel::GpuChannel(GpuChannelManager* gpu_channel_manager,
                        GpuWatchdog* watchdog,
                        gfx::GLShareGroup* share_group,
                        gpu::gles2::MailboxManager* mailbox,
                        int client_id,
                        bool software)
     : gpu_channel_manager_(gpu_channel_manager),
       messages_processed_(0),
@@ skipping 272 matching lines @@
 }
 
 void GpuChannel::AddRoute(int32 route_id, IPC::Listener* listener) {
   router_.AddRoute(route_id, listener);
 }
 
 void GpuChannel::RemoveRoute(int32 route_id) {
   router_.RemoveRoute(route_id);
 }
 
+void GpuChannel::AddMessageFilterRoute(int32 route_id,
+                                       IPC::Listener* listener) {
+  filter_->AddRoute(route_id, listener);
+}
+
+void GpuChannel::RemoveMessageFilterRoute(int32 route_id) {
+  filter_->RemoveRoute(route_id);
+}
+
 gpu::PreemptionFlag* GpuChannel::GetPreemptionFlag() {
   if (!preempting_flag_.get()) {
     preempting_flag_ = new gpu::PreemptionFlag;
     io_message_loop_->PostTask(
         FROM_HERE, base::Bind(
             &GpuChannelMessageFilter::SetPreemptingFlagAndSchedulingState,
             filter_, preempting_flag_, num_stubs_descheduled_ > 0));
   }
   return preempting_flag_.get();
 }
@@ skipping 246 matching lines @@
   }
 }
 
 void GpuChannel::CacheShader(const std::string& key,
                              const std::string& shader) {
   gpu_channel_manager_->Send(
       new GpuHostMsg_CacheShader(client_id_, key, shader));
 }
 
 }  // namespace content