VideoDecodeAccelerator now SupportsWeakPtr instead of being RefCountedThreadSafe.

content/common/gpu/media/gpu_video_decode_accelerator.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.
 
 #include "content/common/gpu/media/gpu_video_decode_accelerator.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 52 matching lines @@
   if (!stub_)
     return;
   stub_->AddDestructionObserver(this);
   make_context_current_ =
       base::Bind(&MakeDecoderContextCurrent, stub_->AsWeakPtr());
 }
 
 GpuVideoDecodeAccelerator::~GpuVideoDecodeAccelerator() {
   if (stub_)
     stub_->RemoveDestructionObserver(this);
-  if (video_decode_accelerator_)
-    video_decode_accelerator_->Destroy();
+  if (video_decode_accelerator_.get())
+    video_decode_accelerator_.release()->Destroy(true);
 }
 
 bool GpuVideoDecodeAccelerator::OnMessageReceived(const IPC::Message& msg) {
-  if (!stub_ || !video_decode_accelerator_)
+  if (!stub_ || !video_decode_accelerator_.get())
     return false;
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuVideoDecodeAccelerator, msg)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_Decode, OnDecode)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_AssignPictureBuffers,
                         OnAssignPictureBuffers)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_ReusePictureBuffer,
                         OnReusePictureBuffer)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_Flush, OnFlush)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_Reset, OnReset)
@@ skipping 73 matching lines @@
   }
 #endif
 
 #if defined(OS_WIN)
   if (base::win::GetVersion() < base::win::VERSION_WIN7) {
     NOTIMPLEMENTED() << "HW video decode acceleration not available.";
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
   DLOG(INFO) << "Initializing DXVA HW decoder for windows.";
-  scoped_refptr<DXVAVideoDecodeAccelerator> video_decoder(
+  scoped_ptr<DXVAVideoDecodeAccelerator> video_decoder(
       new DXVAVideoDecodeAccelerator(this));
-  video_decode_accelerator_ = video_decoder;
+  video_decode_accelerator_ = video_decoder.Pass();
 #elif defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL)
-  scoped_refptr<OmxVideoDecodeAccelerator> video_decoder(
+  scoped_ptr<OmxVideoDecodeAccelerator> video_decoder(
       new OmxVideoDecodeAccelerator(this));
   video_decoder->SetEglState(
       gfx::GLSurfaceEGL::GetHardwareDisplay(),
       stub_->decoder()->GetGLContext()->GetHandle());
-  video_decode_accelerator_ = video_decoder;
+  video_decode_accelerator_ = video_decoder.Pass();
 #elif defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
-  scoped_refptr<VaapiVideoDecodeAccelerator> video_decoder(
+  scoped_ptr<VaapiVideoDecodeAccelerator> video_decoder(
       new VaapiVideoDecodeAccelerator(this, make_context_current_));
   gfx::GLContextGLX* glx_context =
       static_cast<gfx::GLContextGLX*>(stub_->decoder()->GetGLContext());
   GLXContext glx_context_handle =
       static_cast<GLXContext>(glx_context->GetHandle());
   video_decoder->SetGlxState(glx_context->display(), glx_context_handle);
-  video_decode_accelerator_ = video_decoder;
+  video_decode_accelerator_ = video_decoder.Pass();
 #elif defined(OS_MACOSX)
-  scoped_refptr<MacVideoDecodeAccelerator> video_decoder(
+  scoped_ptr<MacVideoDecodeAccelerator> video_decoder(
       new MacVideoDecodeAccelerator(this));
   video_decoder->SetCGLContext(static_cast<CGLContextObj>(
       stub_->decoder()->GetGLContext()->GetHandle()));
-  video_decode_accelerator_ = video_decoder;
+  video_decode_accelerator_ = video_decoder.Pass();
 #else
   NOTIMPLEMENTED() << "HW video decode acceleration not available.";
   NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
   return;
 #endif
 
   if (!video_decode_accelerator_->Initialize(profile))
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
 }
 
@@ skipping 49 matching lines @@
   video_decode_accelerator_->Flush();
 }
 
 void GpuVideoDecodeAccelerator::OnReset() {
   DCHECK(video_decode_accelerator_.get());
   video_decode_accelerator_->Reset();
 }
 
 void GpuVideoDecodeAccelerator::OnDestroy() {
   DCHECK(video_decode_accelerator_.get());
-  video_decode_accelerator_->Destroy();
+  video_decode_accelerator_.release()->Destroy(true);
 }
 
 void GpuVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer(
     int32 bitstream_buffer_id) {
   if (!Send(new AcceleratedVideoDecoderHostMsg_BitstreamBufferProcessed(
           host_route_id_, bitstream_buffer_id))) {
     DLOG(ERROR)
         << "Send(AcceleratedVideoDecoderHostMsg_BitstreamBufferProcessed) "
         << "failed";
   }
@@ skipping 12 matching lines @@
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_FlushDone) failed";
 }
 
 void GpuVideoDecodeAccelerator::NotifyResetDone() {
   if (!Send(new AcceleratedVideoDecoderHostMsg_ResetDone(host_route_id_)))
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_ResetDone) failed";
 }
 
 void GpuVideoDecodeAccelerator::OnWillDestroyStub(GpuCommandBufferStub* stub) {
   DCHECK_EQ(stub, stub_.get());
-  if (video_decode_accelerator_) {
-    video_decode_accelerator_->Destroy();
-    video_decode_accelerator_ = NULL;
-  }
+  if (video_decode_accelerator_.get())
+    video_decode_accelerator_.release()->Destroy(true);
   if (stub_) {
     stub_->RemoveDestructionObserver(this);
     stub_.reset();
   }
 }
 
 bool GpuVideoDecodeAccelerator::Send(IPC::Message* message) {
   DCHECK(sender_);
   return sender_->Send(message);
 }