VideoDecodeAccelerator now SupportsWeakPtr instead of being RefCountedThreadSafe.

content/common/gpu/media/video_decode_accelerator_unittest.cc

 // 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.
 //
 // The bulk of this file is support code; sorry about that.  Here's an overview
 // to hopefully help readers of this code:
 // - RenderingHelper is charged with interacting with X11/{EGL/GLES2,GLX/GL} or
 //   Win/EGL.
 // - ClientState is an enum for the state of the decode client used by the test.
 // - ClientStateNotification is a barrier abstraction that allows the test code
@@ skipping 206 matching lines @@
   virtual void NotifyEndOfBitstreamBuffer(int32 bitstream_buffer_id);
   virtual void NotifyFlushDone();
   virtual void NotifyResetDone();
   virtual void NotifyError(VideoDecodeAccelerator::Error error);
 
   // Simple getters for inspecting the state of the Client.
   ClientState state() { return state_; }
   int num_done_bitstream_buffers() { return num_done_bitstream_buffers_; }
   int num_decoded_frames() { return num_decoded_frames_; }
   double frames_per_second();
-  bool decoder_deleted() { return !decoder_; }
+  bool decoder_deleted() { return !decoder_.get(); }
 
  private:
   typedef std::map<int, media::PictureBuffer*> PictureBufferById;
 
   void SetState(ClientState new_state);
 
   // Delete the associated OMX decoder helper.
   void DeleteDecoder();
 
   // Compute & return in |*end_pos| the end position for the next batch of NALUs
   // to ship to the decoder (based on |start_pos| & |num_NALUs_per_decode_|).
   void GetRangeForNextNALUs(size_t start_pos, size_t* end_pos);
 
   // Request decode of the next batch of NALUs in the encoded data.
   void DecodeNextNALUs();
 
   RenderingHelper* rendering_helper_;
   int rendering_window_id_;
   std::string encoded_data_;
   const int num_NALUs_per_decode_;
   const int num_in_flight_decodes_;
   int outstanding_decodes_;
   size_t encoded_data_next_pos_to_decode_;
   int next_bitstream_buffer_id_;
   ClientStateNotification* note_;
-  scoped_refptr<VideoDecodeAccelerator> decoder_;
+  scoped_ptr<VideoDecodeAccelerator> decoder_;
   std::set<int> outstanding_texture_ids_;
   int remaining_play_throughs_;
   int reset_after_frame_num_;
   int delete_decoder_state_;
   ClientState state_;
   int num_decoded_frames_;
   int num_done_bitstream_buffers_;
   PictureBufferById picture_buffers_by_id_;
   base::TimeTicks initialize_done_ticks_;
   base::TimeTicks last_frame_delivered_ticks_;
@@ skipping 37 matching lines @@
   SetState(CS_DESTROYED);
 }
 
 #if !defined(OS_WIN) && !defined(OS_MACOSX) && defined(ARCH_CPU_X86_FAMILY)
 static bool DoNothingReturnTrue() { return true; }
 #endif
 
 void GLRenderingVDAClient::CreateDecoder() {
   CHECK(decoder_deleted());
 #if defined(OS_WIN)
-  scoped_refptr<DXVAVideoDecodeAccelerator> decoder =
-      new DXVAVideoDecodeAccelerator(this);
+  scoped_ptr<DXVAVideoDecodeAccelerator> decoder(
+      new DXVAVideoDecodeAccelerator(this));
 #elif defined(OS_MACOSX)
-  scoped_refptr<MacVideoDecodeAccelerator> decoder =
-      new MacVideoDecodeAccelerator(this);
+  scoped_ptr<MacVideoDecodeAccelerator> decoder(
+      new MacVideoDecodeAccelerator(this));
   decoder->SetCGLContext(
       static_cast<CGLContextObj>(rendering_helper_->GetGLContext()));
 #elif defined(ARCH_CPU_ARMEL)
-  scoped_refptr<OmxVideoDecodeAccelerator> decoder =
-      new OmxVideoDecodeAccelerator(this);
+  scoped_ptr<OmxVideoDecodeAccelerator> decoder(
+      new OmxVideoDecodeAccelerator(this));
   decoder->SetEglState(
       static_cast<EGLDisplay>(rendering_helper_->GetGLDisplay()),
       static_cast<EGLContext>(rendering_helper_->GetGLContext()));
 #elif defined(ARCH_CPU_X86_FAMILY)
-  scoped_refptr<VaapiVideoDecodeAccelerator> decoder =
-      new VaapiVideoDecodeAccelerator(this, base::Bind(&DoNothingReturnTrue));
+  scoped_ptr<VaapiVideoDecodeAccelerator> decoder(
+      new VaapiVideoDecodeAccelerator(this, base::Bind(&DoNothingReturnTrue)));
   decoder->SetGlxState(
       static_cast<Display*>(rendering_helper_->GetGLDisplay()),
       static_cast<GLXContext>(rendering_helper_->GetGLContext()));
 #endif  // OS_WIN
-  decoder_ = decoder.release();
+  decoder_ = decoder.Pass();
   SetState(CS_DECODER_SET);
   if (decoder_deleted())
     return;
 
   // Configure the decoder.
   media::VideoCodecProfile profile = media::H264PROFILE_BASELINE;
   if (profile_ != -1)
     profile = static_cast<media::VideoCodecProfile>(profile_);
   CHECK(decoder_->Initialize(profile));
 }
@@ skipping 134 matching lines @@
   state_ = new_state;
   if (!remaining_play_throughs_ && new_state == delete_decoder_state_) {
     CHECK(!decoder_deleted());
     DeleteDecoder();
   }
 }
 
 void GLRenderingVDAClient::DeleteDecoder() {
   if (decoder_deleted())
     return;
-  decoder_->Destroy();
-  decoder_ = NULL;
+  decoder_->Destroy(decoder_.Pass());
   STLClearObject(&encoded_data_);
   for (std::set<int>::iterator it = outstanding_texture_ids_.begin();
        it != outstanding_texture_ids_.end(); ++it) {
     rendering_helper_->DeleteTexture(*it);
   }
   outstanding_texture_ids_.clear();
   // Cascade through the rest of the states to simplify test code below.
   for (int i = state_ + 1; i < CS_MAX; ++i)
     SetState(static_cast<ClientState>(i));
 }
@@ skipping 358 matching lines @@
 
   base::ShadowingAtExitManager at_exit_manager;
   RenderingHelper::InitializePlatform();
 
 #if defined(OS_WIN)
   DXVAVideoDecodeAccelerator::PreSandboxInitialization();
 #endif
 
   return RUN_ALL_TESTS();
 }