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

content/browser/renderer_host/media/video_capture_host_unittest.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 <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 205 matching lines @@
 
     host_ = new MockVideoCaptureHost(media_stream_manager_.get());
 
     // Simulate IPC channel connected.
     host_->OnChannelConnected(base::GetCurrentProcId());
   }
 
   virtual void TearDown() OVERRIDE {
     // Verifies and removes the expectations on host_ and
     // returns true iff successful.
-    Mock::VerifyAndClearExpectations(host_);
+    Mock::VerifyAndClearExpectations(host_.get());
 
-    EXPECT_CALL(*host_, OnStateChanged(kDeviceId,
-                                       VIDEO_CAPTURE_STATE_STOPPED))
+    EXPECT_CALL(*host_.get(),
+                OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_STOPPED))
         .Times(AnyNumber());
 
     // Simulate closing the IPC channel.
     host_->OnChannelClosing();
 
     // Release the reference to the mock object. The object will be destructed
     // on message_loop_.
     host_ = NULL;
 
     // We need to continue running message_loop_ to complete all destructions.
     message_loop_->RunUntilIdle();
 
     // Delete the IO message loop.  This will cause the MediaStreamManager to be
     // notified so it will stop its device thread and device managers.
     message_loop_.reset();
   }
 
   void StartCapture() {
     InSequence s;
     // 1. First - get info about the new resolution
-    EXPECT_CALL(*host_, OnDeviceInfo(kDeviceId));
+    EXPECT_CALL(*host_.get(), OnDeviceInfo(kDeviceId));
 
     // 2. Change state to started
-    EXPECT_CALL(*host_, OnStateChanged(kDeviceId,
-                                       VIDEO_CAPTURE_STATE_STARTED));
+    EXPECT_CALL(*host_.get(),
+                OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_STARTED));
 
     // 3. Newly created buffers will arrive.
-    EXPECT_CALL(*host_, OnNewBufferCreated(kDeviceId, _, _, _))
-        .Times(AnyNumber())
-        .WillRepeatedly(Return());
+    EXPECT_CALL(*host_.get(), OnNewBufferCreated(kDeviceId, _, _, _))
+        .Times(AnyNumber()).WillRepeatedly(Return());
 
     // 4. First filled buffer will arrive.
-    EXPECT_CALL(*host_, OnBufferFilled(kDeviceId, _, _))
-        .Times(AnyNumber())
-        .WillOnce(ExitMessageLoop(message_loop_.get()));
+    EXPECT_CALL(*host_.get(), OnBufferFilled(kDeviceId, _, _))
+        .Times(AnyNumber()).WillOnce(ExitMessageLoop(message_loop_.get()));
 
     media::VideoCaptureParams params;
     params.width = 352;
     params.height = 288;
     params.frame_per_second = 30;
     params.session_id = kTestFakeDeviceId;
     host_->OnStartCapture(kDeviceId, params);
     message_loop_->Run();
   }
 
@@ skipping 16 matching lines @@
     params.height = heigt;
     params.frame_per_second = frame_rate;
     params.session_id = kTestFakeDeviceId;
     host_->SetDumpVideo(true);
     host_->OnStartCapture(kDeviceId, params);
     message_loop_->Run();
   }
 #endif
 
   void StopCapture() {
-    EXPECT_CALL(*host_, OnStateChanged(kDeviceId,
-                                       VIDEO_CAPTURE_STATE_STOPPED))
+    EXPECT_CALL(*host_.get(),
+                OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_STOPPED))
         .WillOnce(ExitMessageLoop(message_loop_.get()));
 
     host_->OnStopCapture(kDeviceId);
     host_->SetReturnReceviedDibs(true);
     host_->ReturnReceivedDibs(kDeviceId);
 
     message_loop_->Run();
 
     host_->SetReturnReceviedDibs(false);
     // Expect the VideoCaptureDevice has been stopped
     EXPECT_EQ(0u, host_->entries_.size());
   }
 
   void NotifyPacketReady() {
-    EXPECT_CALL(*host_, OnBufferFilled(kDeviceId, _, _))
-        .Times(AnyNumber())
-        .WillOnce(ExitMessageLoop(message_loop_.get()))
+    EXPECT_CALL(*host_.get(), OnBufferFilled(kDeviceId, _, _))
+        .Times(AnyNumber()).WillOnce(ExitMessageLoop(message_loop_.get()))
         .RetiresOnSaturation();
     message_loop_->Run();
   }
 
   void ReturnReceivedPackets() {
     host_->ReturnReceivedDibs(kDeviceId);
   }
 
   void SimulateError() {
     // Expect a change state to error state  sent through IPC.
-    EXPECT_CALL(*host_, OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_ERROR))
-        .Times(1);
+    EXPECT_CALL(*host_.get(),
+                OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_ERROR)).Times(1);
     VideoCaptureControllerID id(kDeviceId);
     host_->OnError(id);
     // Wait for the error callback.
     message_loop_->RunUntilIdle();
   }
 
   scoped_refptr<MockVideoCaptureHost> host_;
 
  private:
   scoped_ptr<base::MessageLoop> message_loop_;
@@ skipping 16 matching lines @@
   StopCapture();
 }
 
 TEST_F(VideoCaptureHostTest, StartCaptureErrorStop) {
   StartCapture();
   SimulateError();
   StopCapture();
 }
 
 TEST_F(VideoCaptureHostTest, StartCaptureError) {
-  EXPECT_CALL(*host_, OnStateChanged(kDeviceId,
-                                     VIDEO_CAPTURE_STATE_STOPPED))
-      .Times(0);
+  EXPECT_CALL(*host_.get(),
+              OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_STOPPED)).Times(0);
   StartCapture();
   NotifyPacketReady();
   SimulateError();
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(200));
 }
 
 #ifdef DUMP_VIDEO
 TEST_F(VideoCaptureHostTest, CaptureAndDumpVideoVga) {
   CaptureAndDumpVideo(640, 480, 30);
 }
 TEST_F(VideoCaptureHostTest, CaptureAndDump720P) {
   CaptureAndDumpVideo(1280, 720, 30);
 }
 #endif
 
 }  // namespace content