Pass Client pointer in Initialize() for VDA/VEA

content/common/gpu/media/android_video_encode_accelerator.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_COMMON_GPU_MEDIA_ANDROID_VIDEO_ENCODE_ACCELERATOR_H_
 #define CONTENT_COMMON_GPU_MEDIA_ANDROID_VIDEO_ENCODE_ACCELERATOR_H_
 
 #include <list>
 #include <queue>
 #include <vector>
@@ skipping 13 matching lines @@
 namespace content {
 
 // Android-specific implementation of media::VideoEncodeAccelerator, enabling
 // hardware-acceleration of video encoding, based on Android's MediaCodec class
 // (http://developer.android.com/reference/android/media/MediaCodec.html).  This
 // class expects to live and be called on a single thread (the GPU process'
 // ChildThread).
 class CONTENT_EXPORT AndroidVideoEncodeAccelerator
     : public media::VideoEncodeAccelerator {
  public:
-  explicit AndroidVideoEncodeAccelerator(
-      media::VideoEncodeAccelerator::Client* client);
+  AndroidVideoEncodeAccelerator();
   virtual ~AndroidVideoEncodeAccelerator();
 
   static std::vector<media::VideoEncodeAccelerator::SupportedProfile>
       GetSupportedProfiles();
 
   // media::VideoEncodeAccelerator implementation.
   virtual void Initialize(media::VideoFrame::Format format,
                           const gfx::Size& input_visible_size,
                           media::VideoCodecProfile output_profile,
-                          uint32 initial_bitrate) OVERRIDE;
+                          uint32 initial_bitrate,
+                          Client* client) OVERRIDE;
   virtual void Encode(const scoped_refptr<media::VideoFrame>& frame,
                       bool force_keyframe) OVERRIDE;
   virtual void UseOutputBitstreamBuffer(const media::BitstreamBuffer& buffer)
       OVERRIDE;
   virtual void RequestEncodingParametersChange(uint32 bitrate,
                                                uint32 framerate) OVERRIDE;
   virtual void Destroy() OVERRIDE;
 
  private:
   enum {
@@ skipping 14 matching lines @@
 
   // Start & stop |io_timer_| if the time seems right.
   void MaybeStartIOTimer();
   void MaybeStopIOTimer();
 
   // Used to DCHECK that we are called on the correct thread.
   base::ThreadChecker thread_checker_;
 
   // VideoDecodeAccelerator::Client callbacks go here.  Invalidated once any
   // error triggers.
-  base::WeakPtrFactory<Client> client_ptr_factory_;
+  scoped_ptr<base::WeakPtrFactory<Client> > client_ptr_factory_;
 
   scoped_ptr<media::VideoCodecBridge> media_codec_;
 
   // Bitstream buffers waiting to be populated & returned to the client.
   std::vector<media::BitstreamBuffer> available_bitstream_buffers_;
 
   // Frames waiting to be passed to the codec, queued until an input buffer is
   // available.  Each element is a tuple of <Frame, key_frame, enqueue_time>.
   typedef std::queue<
       Tuple3<scoped_refptr<media::VideoFrame>, bool, base::Time> >
@@ skipping 15 matching lines @@
   size_t output_buffers_capacity_;  // 0 until RequireBitstreamBuffers.
 
   uint32 last_set_bitrate_;  // In bps.
 
   DISALLOW_COPY_AND_ASSIGN(AndroidVideoEncodeAccelerator);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_ANDROID_VIDEO_ENCODE_ACCELERATOR_H_