VideoDecodeAccelerator now SupportsWeakPtr instead of being RefCountedThreadSafe.

content/common/gpu/media/vaapi_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.
 //
 // This file contains an implementation of VideoDecoderAccelerator
 // that utilizes hardware video decoder present on Intel CPUs.
 
 #ifndef CONTENT_COMMON_GPU_MEDIA_VAAPI_VIDEO_DECODE_ACCELERATOR_H_
 #define CONTENT_COMMON_GPU_MEDIA_VAAPI_VIDEO_DECODE_ACCELERATOR_H_
 
@@ skipping 14 matching lines @@
 #include "base/threading/thread.h"
 #include "content/common/content_export.h"
 #include "content/common/gpu/media/vaapi_h264_decoder.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/video/picture.h"
 #include "media/video/video_decode_accelerator.h"
 
 // Class to provide video decode acceleration for Intel systems with hardware
 // support for it, and on which libva is available.
 // Decoding tasks are performed in a separate decoding thread.
+//
+// Threading/life-cycle: this object is created & destroyed on the GPU
+// ChildThread.  A few methods on it are called on the decoder thread which is
+// stopped during |this->Destroy()|, so any tasks posted to the decoder thread
+// can assume |*this| is still alive.  See |weak_this_| below for more details.
 class CONTENT_EXPORT VaapiVideoDecodeAccelerator :
     public media::VideoDecodeAccelerator {
  public:
   VaapiVideoDecodeAccelerator(
       Client* client,
       const base::Callback<bool(void)>& make_context_current);
+  virtual ~VaapiVideoDecodeAccelerator();
 
   // media::VideoDecodeAccelerator implementation.
   virtual bool Initialize(media::VideoCodecProfile profile) OVERRIDE;
   virtual void Decode(const media::BitstreamBuffer& bitstream_buffer) OVERRIDE;
   virtual void AssignPictureBuffers(
       const std::vector<media::PictureBuffer>& buffers) OVERRIDE;
   virtual void ReusePictureBuffer(int32 picture_buffer_id) OVERRIDE;
   virtual void Flush() OVERRIDE;
   virtual void Reset() OVERRIDE;
   virtual void Destroy() OVERRIDE;
 
   // Used by user of this class to pass X/GLX state.
   void SetGlxState(Display* x_display, GLXContext glx_context);
 
  private:
-  virtual ~VaapiVideoDecodeAccelerator();
-
   // Ensure data has been synced with the output texture and notify
   // the client it is ready for displaying.
   void SyncAndNotifyPictureReady(int32 input_id, int32 output_id);
 
   // Notify the client that an error has occurred and decoding cannot continue.
   void NotifyError(Error error);
 
   // Map the received input buffer into this process' address space and
   // queue it for decode.
   void MapAndQueueNewInputBuffer(
@@ skipping 41 matching lines @@
   // an idle state, ready to resume if needed, discarding decoded but not yet
   // outputted pictures (decoder keeps ownership of their associated picture
   // buffers). Schedules a FinishReset afterwards.
   void ResetTask();
 
   // Scheduled by ResetTask after it's done putting VAVDA into an idle state.
   // Drops remaining input buffers and notifies the client that reset has been
   // finished.
   void FinishReset();
 
+  // Helper for Destroy(), doing all the actual work except for deleting self.
+  void Cleanup();
+
   // Client-provided X/GLX state.
   Display* x_display_;
   GLXContext glx_context_;
   base::Callback<bool(void)> make_context_current_;
 
   // VAVDA state.
   enum State {
     // Initialize() not called yet or failed.
     kUninitialized,
     // Initialize() succeeded, no initial decode and no pictures requested.
@@ skipping 38 matching lines @@
 
   // Queue for incoming input buffers.
   typedef std::queue<int32> OutputBuffers;
   OutputBuffers output_buffers_;
   // Signalled when output buffers are queued onto the output_buffers_ queue.
   base::ConditionVariable output_ready_;
 
   // ChildThread's message loop
   MessageLoop* message_loop_;
 
+  // WeakPtr<> pointing to |this| for use in posting tasks from the decoder
+  // thread back to the ChildThread.  Because the decoder thread is a member of
+  // this class, any task running on the decoder thread is guaranteed that this
+  // object is still alive.  As a result, tasks posted from ChildThread to
+  // decoder thread should use base::Unretained(this), and tasks posted from the
+  // decoder thread to the ChildThread should use |weak_this_|.
+  base::WeakPtr<VaapiVideoDecodeAccelerator> weak_this_;
+
   // To expose client callbacks from VideoDecodeAccelerator.
   // NOTE: all calls to these objects *MUST* be executed on message_loop_.
   base::WeakPtrFactory<Client> client_ptr_factory_;
   base::WeakPtr<Client> client_;
 
   base::Thread decoder_thread_;
   content::VaapiH264Decoder decoder_;
 
   // Callback passed to the decoder, which it will use to signal readiness
   // of an output picture to be displayed.
   void OutputPicCallback(int32 input_id, int32 output_id);
 
   DISALLOW_COPY_AND_ASSIGN(VaapiVideoDecodeAccelerator);
 };
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_VAAPI_VIDEO_DECODE_ACCELERATOR_H_