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

content/common/gpu/media/gpu_video_decode_accelerator.h

 // 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.
 
 #ifndef CONTENT_COMMON_GPU_MEDIA_GPU_VIDEO_DECODE_ACCELERATOR_H_
 #define CONTENT_COMMON_GPU_MEDIA_GPU_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/shared_memory.h"
 #include "content/common/gpu/gpu_command_buffer_stub.h"
+#include "content/common/gpu/media/video_decode_accelerator_impl.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_sender.h"
 #include "media/video/video_decode_accelerator.h"
 
+namespace base {

[Pawel Osciak, 2013/08/28 08:36:49]

Nit: although the style guide doesn't explicitly say this, it seems like the
convention is to have one empty line after namespace's opening and before
closing braces.
Others might correct me though.

[wuchengli, 2013/08/28 13:18:21]

I did a search. It looks like that forward declaration doesn't need the blank
lines.

https://code.google.com/p/chromium/codesearch#search/&q=class%5C%20MessageLoo...

+class MessageLoopProxy;
+}
+
 namespace content {
 
 class GpuVideoDecodeAccelerator
     : public IPC::Listener,
       public IPC::Sender,
       public media::VideoDecodeAccelerator::Client,
       public GpuCommandBufferStub::DestructionObserver {
  public:
   // Each of the arguments to the constructor must outlive this object.
   // |stub->decoder()| will be made current around any operation that touches
@@ skipping 20 matching lines @@
   virtual void OnWillDestroyStub() OVERRIDE;
 
   // Function to delegate sending to actual sender.
   virtual bool Send(IPC::Message* message) OVERRIDE;
 
   // Initialize the accelerator with the given profile and send the
   // |init_done_msg| when done.
   // The renderer process handle is valid as long as we have a channel between
   // GPU process and the renderer.
   void Initialize(const media::VideoCodecProfile profile,
-                  IPC::Message* init_done_msg);
+                  IPC::Message* init_done_msg,
+                  const scoped_refptr<base::MessageLoopProxy>& io_message_loop);
 
  private:
+  class MessageFilter;
+
   // Handlers for IPC messages.
   void OnDecode(base::SharedMemoryHandle handle, int32 id, uint32 size);
   void OnAssignPictureBuffers(
       const std::vector<int32>& buffer_ids,
       const std::vector<uint32>& texture_ids,
       const std::vector<gfx::Size>& sizes);
   void OnReusePictureBuffer(
       int32 picture_buffer_id);
   void OnFlush();
   void OnReset();
   void OnDestroy();
 
+  // Called on IO thread when |filter_| has been removed.
+  void OnFilterRemoved();
+
   // Message to Send() when initialization is done.  Is only non-NULL during
   // initialization and is owned by the IPC channel underlying the
   // GpuCommandBufferStub.
   IPC::Message* init_done_msg_;
 
   // Route ID to communicate with the host.
   int32 host_route_id_;
 
   // Unowned pointer to the underlying GpuCommandBufferStub.
   GpuCommandBufferStub* stub_;
 
   // The underlying VideoDecodeAccelerator.
-  scoped_ptr<media::VideoDecodeAccelerator> video_decode_accelerator_;
+  scoped_ptr<VideoDecodeAcceleratorImpl> video_decode_accelerator_;
 
   // Callback for making the relevant context current for GL calls.
   // Returns false if failed.
   base::Callback<bool(void)> make_context_current_;
 
   // The texture target as requested by ProvidePictureBuffers().
   uint32 texture_target_;
 
+  // The message filter to run VDA::Decode on IO thread if VDA supports it.
+  scoped_refptr<MessageFilter> filter_;
+
+  // GPU child message loop.
+  scoped_refptr<base::MessageLoopProxy> child_message_loop_;
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(GpuVideoDecodeAccelerator);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_GPU_VIDEO_DECODE_ACCELERATOR_H_