Refactor GpuVideoDecoder::Factories out of GpuVideoDecoder.

content/renderer/media/rtc_video_decoder.h

 // Copyright 2013 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_RENDERER_MEDIA_RTC_VIDEO_DECODER_H_
 #define CONTENT_RENDERER_MEDIA_RTC_VIDEO_DECODER_H_
 
 #include <deque>
+#include <map>
 #include <set>
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "content/common/content_export.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/video_decoder.h"
-#include "media/filters/gpu_video_decoder.h"
 #include "media/video/picture.h"
 #include "media/video/video_decode_accelerator.h"
 #include "third_party/webrtc/modules/video_coding/codecs/interface/video_codec_interface.h"
 
 namespace base {
 class MessageLoopProxy;
 };
 
 namespace media {
 class DecoderBuffer;
+class GpuVideoDecoderFactories;
 }
 
 namespace content {
 
 // This class uses hardware accelerated video decoder to decode video for
 // WebRTC. The message loop of RendererGpuVideoDecoderFactories is stored as
 // |vda_message_loop_|. It is the compositor thread, or the renderer thread if
 // threaded compositing is disabled. VDA::Client methods run on
 // |vda_message_loop_|. webrtc::VideoDecoder methods run on WebRTC
 // DecodingThread or Chrome_libJingle_WorkerThread, which are trampolined to
 // |vda_message_loop_|. Decode() is non-blocking and queues the buffers. Decoded
 // frames are delivered on |vda_message_loop_|.
 class CONTENT_EXPORT RTCVideoDecoder
     : NON_EXPORTED_BASE(public webrtc::VideoDecoder),
       public media::VideoDecodeAccelerator::Client,
       public base::MessageLoop::DestructionObserver {
  public:
   virtual ~RTCVideoDecoder();
 
   // Creates a RTCVideoDecoder. Returns NULL if failed.
   static scoped_ptr<RTCVideoDecoder> Create(
-      const scoped_refptr<media::GpuVideoDecoder::Factories>& factories);
+      const scoped_refptr<media::GpuVideoDecoderFactories>& factories);
 
   // webrtc::VideoDecoder implementation.
   // Called on WebRTC DecodingThread.
   virtual int32_t InitDecode(const webrtc::VideoCodec* codecSettings,
                              int32_t numberOfCores) OVERRIDE;
   // Called on WebRTC DecodingThread.
   virtual int32_t Decode(
       const webrtc::EncodedImage& inputImage,
       bool missingFrames,
       const webrtc::RTPFragmentationHeader* fragmentation,
@@ skipping 39 matching lines @@
     int32 bitstream_buffer_id;
     uint32_t timestamp;  // in 90KHz
     uint32_t width;
     uint32_t height;
     size_t size;  // buffer size
   };
 
   FRIEND_TEST_ALL_PREFIXES(RTCVideoDecoderTest, IsBufferAfterReset);
 
   RTCVideoDecoder(
-      const scoped_refptr<media::GpuVideoDecoder::Factories>& factories);
+      const scoped_refptr<media::GpuVideoDecoderFactories>& factories);
 
   void Initialize(base::WaitableEvent* waiter);
 
   // Requests a buffer to be decoded by VDA.
   void RequestBufferDecode();
 
   bool CanMoreDecodeWorkBeDone();
 
   // Returns true if bitstream buffer id |id_buffer| comes after |id_reset|.
   // This handles the wraparound.
@@ skipping 63 matching lines @@
   // The hardware video decoder.
   scoped_ptr<media::VideoDecodeAccelerator> vda_;
 
   // The size of the incoming video frames.
   gfx::Size frame_size_;
 
   // The weak pointer should live and die on the |vda_loop_proxy_|;
   base::WeakPtrFactory<RTCVideoDecoder> weak_factory_;
   base::WeakPtr<RTCVideoDecoder> weak_this_;
 
-  scoped_refptr<media::GpuVideoDecoder::Factories> factories_;
+  scoped_refptr<media::GpuVideoDecoderFactories> factories_;
 
   // The message loop to run callbacks on. This is should be the same as the one
   // of |factories_|.
   scoped_refptr<base::MessageLoopProxy> vda_loop_proxy_;
 
-  // The thread to create shared memory. Factories::CreateSharedMemory is
-  // trampolined to the child thread. When |vda_loop_proxy_| is the compositor
-  // thread, blocking on the child thread will deadlock. During WebRTC hang up,
-  // the child thread waits for Chrome_libJingle_WorkerThread. libJingle thread
-  // cannot finish when DecodingThread holds a WebRTC lock and blocks on the
-  // child thread. So we need to call CreateSharedMemory asynchronously from a
-  // different thread.
+  // The thread to create shared memory. CreateSharedMemory is trampolined to
+  // the child thread. When |vda_loop_proxy_| is the compositor thread, blocking
+  // on the child thread will deadlock. During WebRTC hang up, the child thread
+  // waits for Chrome_libJingle_WorkerThread. libJingle thread cannot finish
+  // when DecodingThread holds a WebRTC lock and blocks on the child thread. So
+  // we need to call CreateSharedMemory asynchronously from a different thread.
   base::Thread create_shm_thread_;
 
   // The texture target used for decoded pictures.
   uint32 decoder_texture_target_;
 
   // Metadata of the buffers that have been sent for decode.
   std::list<BufferData> input_buffer_data_;
 
   // A map from bitstream buffer IDs to bitstream buffers that are being
   // processed by VDA. The map owns SHM buffers.
@@ skipping 47 matching lines @@
   // A buffer that has an id less than this should be dropped because Reset or
   // Release has been called. Guarded by |lock_|.
   int32 reset_bitstream_buffer_id_;
 
   DISALLOW_COPY_AND_ASSIGN(RTCVideoDecoder);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_RTC_VIDEO_DECODER_H_