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

content/browser/renderer_host/media/video_capture_manager.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_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 44 matching lines @@
 
 VideoCaptureManager::~VideoCaptureManager() {
   DCHECK(devices_.empty());
   DCHECK(controllers_.empty());
 }
 
 void VideoCaptureManager::Register(MediaStreamProviderListener* listener,
                                    base::MessageLoopProxy* device_thread_loop) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!listener_);
-  DCHECK(!device_loop_);
+  DCHECK(!device_loop_.get());
   listener_ = listener;
   device_loop_ = device_thread_loop;
 }
 
 void VideoCaptureManager::Unregister() {
   DCHECK(listener_);
   listener_ = NULL;
 }
 
 void VideoCaptureManager::EnumerateDevices(MediaStreamType stream_type) {
@@ skipping 404 matching lines @@
     base::Callback<void(VideoCaptureController*)> added_cb) {
   DCHECK(IsOnDeviceThread());
 
   media::VideoCaptureDevice* video_capture_device =
       GetDeviceInternal(capture_params.session_id);
   scoped_refptr<VideoCaptureController> controller;
   if (video_capture_device) {
     Controllers::iterator cit = controllers_.find(video_capture_device);
     if (cit == controllers_.end()) {
       controller = new VideoCaptureController(this);
-      controllers_[video_capture_device] = new Controller(controller, handler);
+      controllers_[video_capture_device] =
+          new Controller(controller.get(), handler);
     } else {
       controllers_[video_capture_device]->handlers.push_front(handler);
       controller = controllers_[video_capture_device]->controller;
     }
   }
-  added_cb.Run(controller);
+  added_cb.Run(controller.get());
 }
 
 void VideoCaptureManager::RemoveController(
     VideoCaptureController* controller,
     VideoCaptureControllerEventHandler* handler) {
   DCHECK(handler);
   device_loop_->PostTask(
       FROM_HERE,
       base::Bind(&VideoCaptureManager::DoRemoveControllerOnDeviceThread, this,
                  make_scoped_refptr(controller), handler));
 }
 
 void VideoCaptureManager::DoRemoveControllerOnDeviceThread(
     VideoCaptureController* controller,
     VideoCaptureControllerEventHandler* handler) {
   DCHECK(IsOnDeviceThread());
 
   for (Controllers::iterator cit = controllers_.begin();
        cit != controllers_.end(); ++cit) {
-    if (controller == cit->second->controller) {
+    if (controller == cit->second->controller.get()) {
       Handlers& handlers = cit->second->handlers;
       for (Handlers::iterator hit = handlers.begin();
            hit != handlers.end(); ++hit) {
         if ((*hit) == handler) {
           handlers.erase(hit);
           break;
         }
       }
       if (handlers.empty() && cit->second->ready_to_delete) {
         delete cit->second;
@@ skipping 30 matching lines @@
 
     VideoCaptureDevices::iterator dit = devices_.find(capture_session_id);
     if (dit != devices_.end()) {
       return dit->second.capture_device;
     }
   }
   return NULL;
 }
 
 }  // namespace content