Remove implicit conversions from scoped_refptr to T* in content/browser/renderer_host/

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/command_line.h"
 #include "base/file_util.h"
@@ skipping 370 matching lines @@
   void CloseSession() {
     if (opened_device_label_.empty())
       return;
     media_stream_manager_->CancelRequest(opened_device_label_);
     opened_device_label_.clear();
     opened_session_id_ = kInvalidMediaCaptureSessionId;
   }
 
  protected:
   void StartCapture() {
-    EXPECT_CALL(*host_, OnNewBufferCreated(kDeviceId, _, _, _))
-        .Times(AnyNumber()).WillRepeatedly(Return());
+    EXPECT_CALL(*host_.get(), OnNewBufferCreated(kDeviceId, _, _, _))
+        .Times(AnyNumber())
+        .WillRepeatedly(Return());
 
     base::RunLoop run_loop;
-    EXPECT_CALL(*host_, OnBufferFilled(kDeviceId, _, _, _))
-        .Times(AnyNumber()).WillOnce(ExitMessageLoop(
-            message_loop_, run_loop.QuitClosure()));
+    EXPECT_CALL(*host_.get(), OnBufferFilled(kDeviceId, _, _, _))
+        .Times(AnyNumber())
+        .WillOnce(ExitMessageLoop(message_loop_, run_loop.QuitClosure()));
 
     media::VideoCaptureParams params;
     params.requested_format = media::VideoCaptureFormat(
         gfx::Size(352, 288), 30, media::PIXEL_FORMAT_I420);
     host_->OnStartCapture(kDeviceId, opened_session_id_, params);
     run_loop.Run();
   }
 
   void StartStopCapture() {
     // Quickly start and then stop capture, without giving much chance for
     // asynchronous start operations to complete.
     InSequence s;
     base::RunLoop run_loop;
-    EXPECT_CALL(*host_, OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_STOPPED));
+    EXPECT_CALL(*host_.get(),
+                OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_STOPPED));
     media::VideoCaptureParams params;
     params.requested_format = media::VideoCaptureFormat(
         gfx::Size(352, 288), 30, media::PIXEL_FORMAT_I420);
     host_->OnStartCapture(kDeviceId, opened_session_id_, params);
     host_->OnStopCapture(kDeviceId);
     run_loop.RunUntilIdle();
   }
 
 #ifdef DUMP_VIDEO
   void CaptureAndDumpVideo(int width, int height, int frame_rate) {
@@ skipping 10 matching lines @@
     params.requested_format =
         media::VideoCaptureFormat(gfx::Size(width, height), frame_rate);
     host_->SetDumpVideo(true);
     host_->OnStartCapture(kDeviceId, opened_session_id_, params);
     run_loop.Run();
   }
 #endif
 
   void StopCapture() {
     base::RunLoop run_loop;
-    EXPECT_CALL(*host_, OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_STOPPED))
+    EXPECT_CALL(*host_.get(),
+                OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_STOPPED))
         .WillOnce(ExitMessageLoop(message_loop_, run_loop.QuitClosure()));
 
     host_->OnStopCapture(kDeviceId);
     host_->SetReturnReceivedDibs(true);
     host_->ReturnReceivedDibs(kDeviceId);
 
     run_loop.Run();
 
     host_->SetReturnReceivedDibs(false);
     // Expect the VideoCaptureDevice has been stopped
     EXPECT_EQ(0u, host_->entries_.size());
   }
 
   void NotifyPacketReady() {
     base::RunLoop run_loop;
-    EXPECT_CALL(*host_, OnBufferFilled(kDeviceId, _, _, _))
-        .Times(AnyNumber()).WillOnce(ExitMessageLoop(
-            message_loop_, run_loop.QuitClosure()))
+    EXPECT_CALL(*host_.get(), OnBufferFilled(kDeviceId, _, _, _))
+        .Times(AnyNumber())
+        .WillOnce(ExitMessageLoop(message_loop_, run_loop.QuitClosure()))
         .RetiresOnSaturation();
     run_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.
     base::RunLoop().RunUntilIdle();
   }
 
   scoped_refptr<MockVideoCaptureHost> host_;
 
  private:
   StrictMock<MockMediaStreamRequester> stream_requester_;
   scoped_ptr<media::AudioManager> audio_manager_;
   scoped_ptr<MediaStreamManager> media_stream_manager_;
   content::TestBrowserThreadBundle thread_bundle_;
   content::TestBrowserContext browser_context_;
   content::TestContentBrowserClient browser_client_;
   scoped_refptr<base::MessageLoopProxy> message_loop_;
   int opened_session_id_;
   std::string opened_device_label_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureHostTest);
 };
 
 TEST_F(VideoCaptureHostTest, CloseSessionWithoutStopping) {
   StartCapture();
 
   // When the session is closed via the stream without stopping capture, the
   // ENDED event is sent.
-  EXPECT_CALL(*host_, OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_ENDED))
-      .Times(1);
+  EXPECT_CALL(*host_.get(),
+              OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_ENDED)).Times(1);
   CloseSession();
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(VideoCaptureHostTest, StopWhileStartPending) {
   StartStopCapture();
 }
 
 TEST_F(VideoCaptureHostTest, StartCapturePlayStop) {
   StartCapture();
   NotifyPacketReady();
   NotifyPacketReady();
   ReturnReceivedPackets();
   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