Make VEA client of command buffer; move sync. IPC to VDA/VEA::Initialize()

content/common/gpu/media/vaapi_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 "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
@@ skipping 226 matching lines @@
 
 VaapiVideoDecodeAccelerator::VaapiVideoDecodeAccelerator(
     Display* x_display,
     const base::Callback<bool(void)>& make_context_current)
     : x_display_(x_display),
       make_context_current_(make_context_current),
       state_(kUninitialized),
       input_ready_(&lock_),
       surfaces_available_(&lock_),
       message_loop_(base::MessageLoop::current()),
-      weak_this_(base::AsWeakPtr(this)),
-      va_surface_release_cb_(media::BindToCurrentLoop(base::Bind(
-          &VaapiVideoDecodeAccelerator::RecycleVASurfaceID, weak_this_))),
       decoder_thread_("VaapiDecoderThread"),
       num_frames_at_client_(0),
       num_stream_bufs_at_decoder_(0),
       finish_flush_pending_(false),
       awaiting_va_surfaces_recycle_(false),
-      requested_num_pics_(0) {
+      requested_num_pics_(0),
+      weak_this_factory_(this) {
+  weak_this_ = weak_this_factory_.GetWeakPtr();
+  va_surface_release_cb_ = media::BindToCurrentLoop(
+      base::Bind(&VaapiVideoDecodeAccelerator::RecycleVASurfaceID, weak_this_));
 }
 
 VaapiVideoDecodeAccelerator::~VaapiVideoDecodeAccelerator() {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 }
 
 class XFreeDeleter {
  public:
   void operator()(void* x) const {
     ::XFree(x);
@@ skipping 54 matching lines @@
       new VaapiH264Decoder(
           vaapi_wrapper_.get(),
           media::BindToCurrentLoop(base::Bind(
               &VaapiVideoDecodeAccelerator::SurfaceReady, weak_this_)),
           base::Bind(&ReportToUMA)));
 
   CHECK(decoder_thread_.Start());
   decoder_thread_proxy_ = decoder_thread_.message_loop_proxy();
 
   state_ = kIdle;
-
-  message_loop_->PostTask(FROM_HERE, base::Bind(
-      &Client::NotifyInitializeDone, client_));
   return true;
 }
 
 void VaapiVideoDecodeAccelerator::SurfaceReady(
     int32 input_id,
     const scoped_refptr<VASurface>& va_surface) {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
   DCHECK(!awaiting_va_surfaces_recycle_);
 
   // Drop any requests to output if we are resetting or being destroyed.
@@ skipping 554 matching lines @@
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 
   if (state_ == kUninitialized || state_ == kDestroying)
     return;
 
   DVLOG(1) << "Destroying VAVDA";
   base::AutoLock auto_lock(lock_);
   state_ = kDestroying;
 
   client_ptr_factory_.reset();
+  weak_this_factory_.InvalidateWeakPtrs();
 
   {
     base::AutoUnlock auto_unlock(lock_);
     // Post a dummy task to the decoder_thread_ to ensure it is drained.
     base::WaitableEvent waiter(false, false);
     decoder_thread_proxy_->PostTask(FROM_HERE, base::Bind(
         &base::WaitableEvent::Signal, base::Unretained(&waiter)));
     input_ready_.Signal();
     surfaces_available_.Signal();
     waiter.Wait();
     decoder_thread_.Stop();
   }
 
   state_ = kUninitialized;
 }
 
 void VaapiVideoDecodeAccelerator::Destroy() {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
   Cleanup();
   delete this;
 }
 
 }  // namespace content