Pass Client pointer in Initialize() for VDA/VEA

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 39 matching lines @@
     return;
   }
 
   // Post Cleanup() as a task so we don't recursively acquire lock_.
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &VaapiVideoDecodeAccelerator::Cleanup, weak_this_));
 
   DVLOG(1) << "Notifying of error " << error;
   if (client_) {
     client_->NotifyError(error);
-    client_ptr_factory_.InvalidateWeakPtrs();
+    client_ptr_factory_.reset();
   }
 }
 
 // TFPPicture allocates X Pixmaps and binds them to textures passed
 // in PictureBuffers from clients to them. TFPPictures are created as
 // a consequence of receiving a set of PictureBuffers from clients and released
 // at the end of decode (or when a new set of PictureBuffers is required).
 //
 // TFPPictures are used for output, contents of VASurfaces passed from decoder
 // are put into the associated pixmap memory and sent to client.
@@ skipping 159 matching lines @@
   if (it == tfp_pictures_.end()) {
     DVLOG(1) << "Picture id " << picture_buffer_id << " does not exist";
     return NULL;
   }
 
   return it->second.get();
 }
 
 VaapiVideoDecodeAccelerator::VaapiVideoDecodeAccelerator(
     Display* x_display,
-    Client* client,
     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_))),
-      client_ptr_factory_(client),
-      client_(client_ptr_factory_.GetWeakPtr()),
       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) {
-  DCHECK(client);
 }
 
 VaapiVideoDecodeAccelerator::~VaapiVideoDecodeAccelerator() {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 }
 
 class XFreeDeleter {
  public:
   void operator()(void* x) const {
     ::XFree(x);
@@ skipping 15 matching lines @@
                         &num_fbconfigs));
   if (!glx_fb_configs)
     return false;
   if (!num_fbconfigs)
     return false;
 
   fb_config_ = glx_fb_configs.get()[0];
   return true;
 }
 
-bool VaapiVideoDecodeAccelerator::Initialize(
-    media::VideoCodecProfile profile) {
+bool VaapiVideoDecodeAccelerator::Initialize(media::VideoCodecProfile profile,
+                                             Client* client) {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
 
+  client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
+  client_ = client_ptr_factory_->GetWeakPtr();
+
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kUninitialized);
   DVLOG(2) << "Initializing VAVDA, profile: " << profile;
 
   if (!make_context_current_.Run())
     return false;
 
   if (!InitializeFBConfig()) {
     DVLOG(1) << "Could not get a usable FBConfig";
     return false;
@@ skipping 588 matching lines @@
 void VaapiVideoDecodeAccelerator::Cleanup() {
   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_.InvalidateWeakPtrs();
+  client_ptr_factory_.reset();
 
   {
     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