Pass Client pointer in Initialize() for VDA/VEA

content/common/gpu/media/exynos_video_encode_accelerator.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/media/exynos_video_encode_accelerator.h"
 
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <sys/eventfd.h>
@@ skipping 64 matching lines @@
     : at_device(false), mfc_input(-1) {}
 
 ExynosVideoEncodeAccelerator::MfcInputRecord::MfcInputRecord()
     : at_device(false) {
   fd[0] = fd[1] = -1;
 }
 
 ExynosVideoEncodeAccelerator::MfcOutputRecord::MfcOutputRecord()
     : at_device(false), address(NULL), length(0) {}
 
-ExynosVideoEncodeAccelerator::ExynosVideoEncodeAccelerator(
-    media::VideoEncodeAccelerator::Client* client)
+ExynosVideoEncodeAccelerator::ExynosVideoEncodeAccelerator()
     : child_message_loop_proxy_(base::MessageLoopProxy::current()),
       weak_this_ptr_factory_(this),
       weak_this_(weak_this_ptr_factory_.GetWeakPtr()),
-      client_ptr_factory_(client),
-      client_(client_ptr_factory_.GetWeakPtr()),
       encoder_thread_("ExynosEncoderThread"),
       encoder_state_(kUninitialized),
       output_buffer_byte_size_(0),
       stream_header_size_(0),
       input_format_fourcc_(0),
       output_format_fourcc_(0),
       gsc_fd_(-1),
       gsc_input_streamon_(false),
       gsc_input_buffer_queued_count_(0),
       gsc_output_streamon_(false),
       gsc_output_buffer_queued_count_(0),
       mfc_fd_(-1),
       mfc_input_streamon_(false),
       mfc_input_buffer_queued_count_(0),
       mfc_output_streamon_(false),
       mfc_output_buffer_queued_count_(0),
       device_poll_thread_("ExynosEncoderDevicePollThread"),
-      device_poll_interrupt_fd_(-1) {
-  DCHECK(client_);
-}
+      device_poll_interrupt_fd_(-1) {}
 
 ExynosVideoEncodeAccelerator::~ExynosVideoEncodeAccelerator() {
   DCHECK(!encoder_thread_.IsRunning());
   DCHECK(!device_poll_thread_.IsRunning());
 
   if (device_poll_interrupt_fd_ != -1) {
     close(device_poll_interrupt_fd_);
     device_poll_interrupt_fd_ = -1;
   }
   if (gsc_fd_ != -1) {
     DestroyGscInputBuffers();
     DestroyGscOutputBuffers();
     close(gsc_fd_);
     gsc_fd_ = -1;
   }
   if (mfc_fd_ != -1) {
     DestroyMfcInputBuffers();
     DestroyMfcOutputBuffers();
     close(mfc_fd_);
     mfc_fd_ = -1;
   }
 }
 
 void ExynosVideoEncodeAccelerator::Initialize(
     media::VideoFrame::Format input_format,
     const gfx::Size& input_visible_size,
     media::VideoCodecProfile output_profile,
-    uint32 initial_bitrate) {
+    uint32 initial_bitrate,
+    Client* client) {
   DVLOG(3) << "Initialize(): input_format=" << input_format
            << ", input_visible_size=" << input_visible_size.ToString()
            << ", output_profile=" << output_profile
            << ", initial_bitrate=" << initial_bitrate;
 
+  client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
+  client_ = client_ptr_factory_->GetWeakPtr();
+
   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK_EQ(encoder_state_, kUninitialized);
 
   input_visible_size_ = input_visible_size;
   input_allocated_size_.SetSize((input_visible_size_.width() + 0xF) & ~0xF,
                                 (input_visible_size_.height() + 0xF) & ~0xF);
   converted_visible_size_.SetSize((input_visible_size_.width() + 0x1) & ~0x1,
                                   (input_visible_size_.height() + 0x1) & ~0x1);
   converted_allocated_size_.SetSize(
       (converted_visible_size_.width() + 0xF) & ~0xF,
@@ skipping 183 matching lines @@
           base::Unretained(this),
           bitrate,
           framerate));
 }
 
 void ExynosVideoEncodeAccelerator::Destroy() {
   DVLOG(3) << "Destroy()";
   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
 
   // We're destroying; cancel all callbacks.
-  client_ptr_factory_.InvalidateWeakPtrs();
+  client_ptr_factory_.reset();
 
   // If the encoder thread is running, destroy using posted task.
   if (encoder_thread_.IsRunning()) {
     encoder_thread_.message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&ExynosVideoEncodeAccelerator::DestroyTask,
                    base::Unretained(this)));
     // DestroyTask() will put the encoder into kError state and cause all tasks
     // to no-op.
     encoder_thread_.Stop();
@@ skipping 742 matching lines @@
   if (!child_message_loop_proxy_->BelongsToCurrentThread()) {
     child_message_loop_proxy_->PostTask(
         FROM_HERE,
         base::Bind(
             &ExynosVideoEncodeAccelerator::NotifyError, weak_this_, error));
     return;
   }
 
   if (client_) {
     client_->NotifyError(error);
-    client_ptr_factory_.InvalidateWeakPtrs();
+    client_ptr_factory_.reset();
   }
 }
 
 void ExynosVideoEncodeAccelerator::SetEncoderState(State state) {
   DVLOG(3) << "SetEncoderState(): state=" << state;
 
   // We can touch encoder_state_ only if this is the encoder thread or the
   // encoder thread isn't running.
   if (encoder_thread_.message_loop() != NULL &&
       encoder_thread_.message_loop() != base::MessageLoop::current()) {
@@ skipping 416 matching lines @@
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   if (HANDLE_EINTR(ioctl(mfc_fd_, VIDIOC_REQBUFS, &reqbufs)) != 0)
     DPLOG(ERROR) << "DestroyMfcOutputBuffers(): ioctl() failed: VIDIOC_REQBUFS";
 
   mfc_output_buffer_map_.clear();
   mfc_free_output_buffers_.clear();
 }
 
 }  // namespace content