Revert of Revert of Revert of Remove threading from RendererGpuVideoAcceleratorFactories

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 <list>
 #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/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 WaitableEvent;
 class MessageLoopProxy;
 };
 
 namespace media {
 class DecoderBuffer;
 class GpuVideoAcceleratorFactories;
 }
 
 namespace content {
 
 // This class uses hardware accelerated video decoder to decode video for
 // WebRTC. |vda_message_loop_| is the message loop proxy of the media thread,
 // which VDA::Client methods run on. 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 to WebRTC on |vda_message_loop_|.
 class CONTENT_EXPORT RTCVideoDecoder
     : NON_EXPORTED_BASE(public webrtc::VideoDecoder),
-      public media::VideoDecodeAccelerator::Client {
+      public media::VideoDecodeAccelerator::Client,
+      public base::MessageLoop::DestructionObserver {
  public:
   virtual ~RTCVideoDecoder();
 
   // Creates a RTCVideoDecoder. Returns NULL if failed. The video decoder will
   // run on the message loop of |factories|.
   static scoped_ptr<RTCVideoDecoder> Create(
       webrtc::VideoCodecType type,
       const scoped_refptr<media::GpuVideoAcceleratorFactories>& factories);
 
   // webrtc::VideoDecoder implementation.
@@ skipping 22 matching lines @@
   virtual void ProvidePictureBuffers(uint32 count,
                                      const gfx::Size& size,
                                      uint32 texture_target) OVERRIDE;
   virtual void DismissPictureBuffer(int32 id) OVERRIDE;
   virtual void PictureReady(const media::Picture& picture) OVERRIDE;
   virtual void NotifyEndOfBitstreamBuffer(int32 id) OVERRIDE;
   virtual void NotifyFlushDone() OVERRIDE;
   virtual void NotifyResetDone() OVERRIDE;
   virtual void NotifyError(media::VideoDecodeAccelerator::Error error) OVERRIDE;
 
+  // base::DestructionObserver implementation. Called when |vda_message_loop_|
+  // is stopped.
+  virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
+
  private:
   class SHMBuffer;
   // Metadata of a bitstream buffer.
   struct BufferData {
     BufferData(int32 bitstream_buffer_id,
                uint32_t timestamp,
                int width,
                int height,
                size_t size);
     BufferData();
     ~BufferData();
     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);
   FRIEND_TEST_ALL_PREFIXES(RTCVideoDecoderTest, IsFirstBufferAfterReset);
 
   // The meessage loop of |factories| will be saved to |vda_task_runner_|.
   RTCVideoDecoder(
       const scoped_refptr<media::GpuVideoAcceleratorFactories>& 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.
   bool IsBufferAfterReset(int32 id_buffer, int32 id_reset);
 
   // Returns true if bitstream buffer |id_buffer| is the first buffer after
@@ skipping 20 matching lines @@
       uint32_t width,
       uint32_t height,
       size_t size);
 
   // Resets VDA.
   void ResetInternal();
 
   // Tells VDA that a picture buffer can be recycled.
   void ReusePictureBuffer(int64 picture_buffer_id, uint32 sync_point);
 
-  // Create |vda_| on |vda_loop_proxy_|.
-  void CreateVDA(media::VideoCodecProfile profile, base::WaitableEvent* waiter);
-
   void DestroyTextures();
   void DestroyVDA();
 
   // Gets a shared-memory segment of at least |min_size| bytes from
   // |available_shm_segments_|. Returns NULL if there is no buffer or the
   // buffer is not big enough.
   scoped_ptr<SHMBuffer> GetSHM_Locked(size_t min_size);
 
   // Returns a shared-memory segment to the available pool.
   void PutSHM_Locked(scoped_ptr<SHMBuffer> shm_buffer);
@@ skipping 100 matching lines @@
   // Factory used to populate |weak_this_|. Must be destroyed, or invalidated,
   // on |vda_loop_proxy_|.
   base::WeakPtrFactory<RTCVideoDecoder> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RTCVideoDecoder);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_RTC_VIDEO_DECODER_H_