Pass Client pointer in Initialize() for VDA/VEA

content/common/gpu/client/gpu_video_encode_accelerator_host.cc

 // 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.
 
 #include "content/common/gpu/client/gpu_video_encode_accelerator_host.h"
 
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "content/common/gpu/client/gpu_channel_host.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/media/gpu_video_encode_accelerator.h"
 #include "media/base/video_frame.h"
 
 namespace content {
 
 GpuVideoEncodeAcceleratorHost::GpuVideoEncodeAcceleratorHost(
-    media::VideoEncodeAccelerator::Client* client,
     const scoped_refptr<GpuChannelHost>& gpu_channel_host,
     int32 route_id)
-    : client_(client),
-      client_ptr_factory_(client_),
+    : client_(NULL),
       channel_(gpu_channel_host),
       route_id_(route_id),
       next_frame_id_(0) {
   channel_->AddRoute(route_id_, AsWeakPtr());
 }
 
 GpuVideoEncodeAcceleratorHost::~GpuVideoEncodeAcceleratorHost() {
   if (channel_)
     channel_->RemoveRoute(route_id_);
 }
@@ skipping 34 matching lines @@
   }
   // See OnNotifyError for why this needs to be the last thing in this
   // function.
   OnNotifyError(kPlatformFailureError);
 }
 
 void GpuVideoEncodeAcceleratorHost::Initialize(
     media::VideoFrame::Format input_format,
     const gfx::Size& input_visible_size,
     media::VideoCodecProfile output_profile,
-    uint32 initial_bitrate) {
+    uint32 initial_bitrate,
+    Client* client) {
+  client_ = client;
+  client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client_));
   Send(new AcceleratedVideoEncoderMsg_Initialize(route_id_,
                                                  input_format,
                                                  input_visible_size,
                                                  output_profile,
                                                  initial_bitrate));
 }
 
 void GpuVideoEncodeAcceleratorHost::Encode(
     const scoped_refptr<media::VideoFrame>& frame,
     bool force_keyframe) {
@@ skipping 58 matching lines @@
 void GpuVideoEncodeAcceleratorHost::Destroy() {
   Send(new GpuChannelMsg_DestroyVideoEncoder(route_id_));
   delete this;
 }
 
 void GpuVideoEncodeAcceleratorHost::NotifyError(Error error) {
   DVLOG(2) << "NotifyError(): error=" << error;
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(&media::VideoEncodeAccelerator::Client::NotifyError,
-                 client_ptr_factory_.GetWeakPtr(),
+                 client_ptr_factory_->GetWeakPtr(),
                  error));
 }
 
 void GpuVideoEncodeAcceleratorHost::OnNotifyInitializeDone() {
   DVLOG(2) << "OnNotifyInitializeDone()";
   if (client_)
     client_->NotifyInitializeDone();
 }
 
 void GpuVideoEncodeAcceleratorHost::OnRequireBitstreamBuffers(
@@ skipping 37 matching lines @@
            << ", payload_size=" << payload_size
            << ", key_frame=" << key_frame;
   if (client_)
     client_->BitstreamBufferReady(bitstream_buffer_id, payload_size, key_frame);
 }
 
 void GpuVideoEncodeAcceleratorHost::OnNotifyError(Error error) {
   DVLOG(2) << "OnNotifyError(): error=" << error;
   if (!client_)
     return;
-  client_ptr_factory_.InvalidateWeakPtrs();
+  client_ptr_factory_.reset();
 
   // Client::NotifyError() may Destroy() |this|, so calling it needs to be the
   // last thing done on this stack!
   media::VideoEncodeAccelerator::Client* client = NULL;
   std::swap(client_, client);
   client->NotifyError(error);
 }
 
 void GpuVideoEncodeAcceleratorHost::Send(IPC::Message* message) {
   if (!channel_) {
     DLOG(ERROR) << "Send(): no channel";
     delete message;
     NotifyError(kPlatformFailureError);
   } else if (!channel_->Send(message)) {
     DLOG(ERROR) << "Send(): sending failed: message->type()="
                 << message->type();
     NotifyError(kPlatformFailureError);
   }
 }
 
 }  // namespace content