Update content/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

content/browser/renderer_host/media/video_capture_controller.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/browser/renderer_host/media/video_capture_controller.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 160 matching lines @@
   if (client) {
     pending_clients_.remove(client);
     return;
   }
 
   client = FindClient(id, event_handler, controller_clients_);
   if (!client)
     return;
 
   // Take back all buffers held by the |client|.
-  if (buffer_pool_) {
+  if (buffer_pool_.get()) {
     for (std::set<int>::iterator buffer_it = client->buffers.begin();
-         buffer_it != client->buffers.end(); ++buffer_it) {
+         buffer_it != client->buffers.end();
+         ++buffer_it) {
       int buffer_id = *buffer_it;
       buffer_pool_->RelinquishConsumerHold(buffer_id, 1);
     }
   }
   client->buffers.clear();
 
   int session_id = client->parameters.session_id;
   delete client;
   controller_clients_.remove(client);
 
@@ skipping 45 matching lines @@
   // called to stop, check if restart is needed. This could happen when
   // capture needs to be restarted due to resolution change.
   if (!buffer_pool_->IsAnyBufferHeldForConsumers() &&
       state_ == VIDEO_CAPTURE_STATE_STOPPING) {
     PostStopping();
   }
 }
 
 scoped_refptr<media::VideoFrame> VideoCaptureController::ReserveOutputBuffer() {
   base::AutoLock lock(buffer_pool_lock_);
-  if (!buffer_pool_)
+  if (!buffer_pool_.get())
     return NULL;
   return buffer_pool_->ReserveForProducer(0);
 }
 
 // Implements VideoCaptureDevice::EventHandler.
 // OnIncomingCapturedFrame is called the thread running the capture device.
 // I.e.- DirectShow thread on windows and v4l2_thread on Linux.
 void VideoCaptureController::OnIncomingCapturedFrame(
     const uint8* data,
     int length,
     base::Time timestamp,
     int rotation,
     bool flip_vert,
     bool flip_horiz) {
   DCHECK(frame_info_.color == media::VideoCaptureCapability::kI420 ||
          frame_info_.color == media::VideoCaptureCapability::kYV12 ||
          (rotation == 0 && !flip_vert && !flip_horiz));
 
   scoped_refptr<media::VideoFrame> dst;
   {
     base::AutoLock lock(buffer_pool_lock_);
-    if (!buffer_pool_)
+    if (!buffer_pool_.get())
       return;
     dst = buffer_pool_->ReserveForProducer(rotation);
   }
 
-  if (!dst)
+  if (!dst.get())
     return;
 
   uint8* yplane = dst->data(media::VideoFrame::kYPlane);
   uint8* uplane = dst->data(media::VideoFrame::kUPlane);
   uint8* vplane = dst->data(media::VideoFrame::kVPlane);
 
   // Do color conversion from the camera format to I420.
   switch (frame_info_.color) {
     case media::VideoCaptureCapability::kColorUnknown:  // Color format not set.
       break;
@@ skipping 73 matching lines @@
 
 // OnIncomingCapturedVideoFrame is called the thread running the capture device.
 void VideoCaptureController::OnIncomingCapturedVideoFrame(
     const scoped_refptr<media::VideoFrame>& frame,
     base::Time timestamp) {
 
   scoped_refptr<media::VideoFrame> target;
   {
     base::AutoLock lock(buffer_pool_lock_);
 
-    if (!buffer_pool_)
+    if (!buffer_pool_.get())
       return;
 
     // If this is a frame that belongs to the buffer pool, we can forward it
     // directly to the IO thread and be done.
     if (buffer_pool_->RecognizeReservedBuffer(frame)) {
       BrowserThread::PostTask(BrowserThread::IO,
           FROM_HERE,
           base::Bind(&VideoCaptureController::DoIncomingCapturedFrameOnIOThread,
                      this, frame, timestamp));
       return;
     }
     // Otherwise, this is a frame that belongs to the caller, and we must copy
     // it to a frame from the buffer pool.
     target = buffer_pool_->ReserveForProducer(0);
   }
 
-  if (!target)
+  if (!target.get())
     return;
 
   // Validate the inputs.
   if (frame->coded_size() != target->coded_size())
     return;  // Only exact copies are supported.
   if (!(frame->format() == media::VideoFrame::I420 ||
         frame->format() == media::VideoFrame::YV12 ||
         frame->format() == media::VideoFrame::RGB32)) {
     NOTREACHED() << "Unsupported format passed to OnIncomingCapturedVideoFrame";
     return;
@@ skipping 17 matching lines @@
     case media::VideoFrame::NATIVE_TEXTURE: {
       NOTREACHED();
       break;
     }
     case media::VideoFrame::I420:
     case media::VideoFrame::YV12: {
       DCHECK(!chopped_width_ && !chopped_height_);
       media::CopyYPlane(frame->data(kYPlane),
                         frame->stride(kYPlane),
                         frame->rows(kYPlane),
-                        target);
+                        target.get());
       media::CopyUPlane(frame->data(kUPlane),
                         frame->stride(kUPlane),
                         frame->rows(kUPlane),
-                        target);
+                        target.get());
       media::CopyVPlane(frame->data(kVPlane),
                         frame->stride(kVPlane),
                         frame->rows(kVPlane),
-                        target);
+                        target.get());
       break;
     }
     case media::VideoFrame::YV12A: {
       DCHECK(!chopped_width_ && !chopped_height_);
       media::CopyYPlane(frame->data(kYPlane),
                         frame->stride(kYPlane),
                         frame->rows(kYPlane),
-                        target);
+                        target.get());
       media::CopyUPlane(frame->data(kUPlane),
                         frame->stride(kUPlane),
                         frame->rows(kUPlane),
-                        target);
+                        target.get());
       media::CopyVPlane(frame->data(kVPlane),
                         frame->stride(kVPlane),
                         frame->rows(kVPlane),
-                        target);
+                        target.get());
       media::CopyAPlane(frame->data(kAPlane),
                         frame->stride(kAPlane),
                         frame->rows(kAPlane),
-                        target);
+                        target.get());
       break;
     }
     case media::VideoFrame::RGB32: {
       media::ConvertRGB32ToYUV(frame->data(kRGBPlane),
                                target->data(kYPlane),
                                target->data(kUPlane),
                                target->data(kVPlane),
                                target->coded_size().width(),
                                target->coded_size().height(),
                                frame->stride(kRGBPlane),
@@ skipping 49 matching lines @@
   BrowserThread::PostTask(BrowserThread::IO,
       FROM_HERE,
       base::Bind(&VideoCaptureController::DoDeviceStoppedOnIOThread, this));
 }
 
 void VideoCaptureController::DoIncomingCapturedFrameOnIOThread(
     const scoped_refptr<media::VideoFrame>& reserved_frame,
     base::Time timestamp) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  if (!buffer_pool_)
+  if (!buffer_pool_.get())
     return;
 
   int buffer_id = buffer_pool_->RecognizeReservedBuffer(reserved_frame);
   if (!buffer_id) {
     NOTREACHED();
     return;
   }
 
   int count = 0;
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
     for (ControllerClients::iterator client_it = controller_clients_.begin();
          client_it != controller_clients_.end(); ++client_it) {
       if ((*client_it)->session_closed)
         continue;
 
       (*client_it)->event_handler->OnBufferReady((*client_it)->controller_id,
                                                  buffer_id, timestamp);
       (*client_it)->buffers.insert(buffer_id);
       count++;
     }
   }
 
   buffer_pool_->HoldForConsumers(reserved_frame, buffer_id, count);
 }
 
 void VideoCaptureController::DoFrameInfoOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(!buffer_pool_)
+  DCHECK(!buffer_pool_.get())
       << "Device is restarted without releasing shared memory.";
 
   // Allocate memory only when device has been started.
   if (state_ != VIDEO_CAPTURE_STATE_STARTED)
     return;
 
   scoped_refptr<VideoCaptureBufferPool> buffer_pool =
       new VideoCaptureBufferPool(
           gfx::Size(frame_info_.width, frame_info_.height), kNoOfBuffers);
 
@@ skipping 40 matching lines @@
     PostStopping();
   }
 }
 
 void VideoCaptureController::SendFrameInfoAndBuffers(ControllerClient* client) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(frame_info_available_);
   client->event_handler->OnFrameInfo(client->controller_id,
                                      frame_info_.width, frame_info_.height,
                                      frame_info_.frame_rate);
-  if (!buffer_pool_)
+  if (!buffer_pool_.get())
     return;
 
   for (int buffer_id = 1; buffer_id <= buffer_pool_->count(); ++buffer_id) {
     base::SharedMemoryHandle remote_handle =
         buffer_pool_->ShareToProcess(buffer_id, client->render_process_handle);
 
     client->event_handler->OnBufferCreated(client->controller_id,
                                            remote_handle,
                                            buffer_pool_->GetMemorySize(),
                                            buffer_id);
@@ skipping 30 matching lines @@
 
 // This function is called when all buffers have been returned to controller,
 // or when device is stopped. It decides whether the device needs to be
 // restarted.
 void VideoCaptureController::PostStopping() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_EQ(state_, VIDEO_CAPTURE_STATE_STOPPING);
 
   // When clients still have some buffers, or device has not been stopped yet,
   // do nothing.
-  if ((buffer_pool_ && buffer_pool_->IsAnyBufferHeldForConsumers()) ||
+  if ((buffer_pool_.get() && buffer_pool_->IsAnyBufferHeldForConsumers()) ||
       device_in_use_)
     return;
 
   {
     base::AutoLock lock(buffer_pool_lock_);
     buffer_pool_ = NULL;
   }
 
   // No more client. Therefore the controller is stopped.
   if (controller_clients_.empty() && pending_clients_.empty()) {
@@ skipping 21 matching lines @@
     controller_clients_.push_back((*client_it));
     pending_clients_.erase(client_it++);
   }
   // Request the manager to start the actual capture.
   video_capture_manager_->Start(current_params_, this);
   state_ = VIDEO_CAPTURE_STATE_STARTED;
   device_in_use_ = true;
 }
 
 }  // namespace content