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

content/browser/renderer_host/media/media_stream_dispatcher_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 <string>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/media/media_stream_dispatcher_host.h"
@@ skipping 142 matching lines @@
     media_stream_manager_.reset(new MediaStreamManager(audio_manager_.get()));
     // Make sure we use fake devices to avoid long delays.
     media_stream_manager_->UseFakeDevice();
 
     host_ = new MockMediaStreamDispatcherHost(message_loop_.get(),
                                               media_stream_manager_.get());
 
     // Use the fake content client and browser.
     content_client_.reset(new TestContentClient);
     SetContentClient(content_client_.get());
-    old_browser_client_ = SetBrowserClientForTesting(host_);
+    old_browser_client_ = SetBrowserClientForTesting(host_.get());
   }
 
   virtual void SetupFakeUI(bool expect_started) {
     scoped_ptr<MockMediaStreamUI> stream_ui(new MockMediaStreamUI());
     if (expect_started) {
       EXPECT_CALL(*stream_ui, OnStarted(_));
     }
     media_stream_manager_->UseFakeUI(stream_ui.PassAs<MediaStreamUI>());
   }
 
@@ skipping 16 matching lines @@
   scoped_ptr<media::AudioManager> audio_manager_;
   scoped_ptr<MediaStreamManager> media_stream_manager_;
   ContentBrowserClient* old_browser_client_;
   scoped_ptr<ContentClient> content_client_;
 };
 
 TEST_F(MediaStreamDispatcherHostTest, GenerateStream) {
   StreamOptions options(MEDIA_NO_SERVICE, MEDIA_DEVICE_VIDEO_CAPTURE);
 
   SetupFakeUI(true);
-  EXPECT_CALL(*host_, OnStreamGenerated(kRenderId, kPageRequestId, 0, 1));
+  EXPECT_CALL(*host_.get(), OnStreamGenerated(kRenderId, kPageRequestId, 0, 1));
   host_->OnGenerateStream(kPageRequestId, options);
 
   WaitForResult();
 
   std::string label =  host_->label_;
 
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
   EXPECT_EQ(host_->NumberOfStreams(), 1u);
 
   host_->OnStopGeneratedStream(label);
   EXPECT_EQ(host_->NumberOfStreams(), 0u);
 }
 
 TEST_F(MediaStreamDispatcherHostTest, GenerateThreeStreams) {
   // This test opens three video capture devices. Two fake devices exists and it
   // is expected the last call to |Open()| will open the first device again, but
   // with a different label.
   StreamOptions options(MEDIA_NO_SERVICE, MEDIA_DEVICE_VIDEO_CAPTURE);
 
   // Generate first stream.
   SetupFakeUI(true);
-  EXPECT_CALL(*host_, OnStreamGenerated(kRenderId, kPageRequestId, 0, 1));
+  EXPECT_CALL(*host_.get(), OnStreamGenerated(kRenderId, kPageRequestId, 0, 1));
   host_->OnGenerateStream(kPageRequestId, options);
 
   WaitForResult();
 
   // Check the latest generated stream.
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
   std::string label1 = host_->label_;
   std::string device_id1 = host_->video_devices_.front().device.id;
 
   // Check that we now have one opened streams.
   EXPECT_EQ(host_->NumberOfStreams(), 1u);
 
   // Generate second stream.
   SetupFakeUI(true);
-  EXPECT_CALL(*host_, OnStreamGenerated(kRenderId, kPageRequestId + 1, 0, 1));
-  host_->OnGenerateStream(kPageRequestId+1, options);
-
+  EXPECT_CALL(*host_.get(),
+              OnStreamGenerated(kRenderId, kPageRequestId + 1, 0, 1));
+  host_->OnGenerateStream(kPageRequestId + 1, options);
 
   WaitForResult();
 
   // Check the latest generated stream.
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
   std::string label2 = host_->label_;
   std::string device_id2 = host_->video_devices_.front().device.id;
   EXPECT_EQ(device_id1, device_id2);
   EXPECT_NE(label1, label2);
 
   // Check that we now have two opened streams.
   EXPECT_EQ(2u, host_->NumberOfStreams());
 
   // Generate third stream.
   SetupFakeUI(true);
-  EXPECT_CALL(*host_, OnStreamGenerated(kRenderId, kPageRequestId + 2, 0, 1));
-  host_->OnGenerateStream(kPageRequestId+2, options);
+  EXPECT_CALL(*host_.get(),
+              OnStreamGenerated(kRenderId, kPageRequestId + 2, 0, 1));
+  host_->OnGenerateStream(kPageRequestId + 2, options);
 
   WaitForResult();
 
   // Check the latest generated stream.
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
   std::string label3 = host_->label_;
   std::string device_id3 = host_->video_devices_.front().device.id;
   EXPECT_EQ(device_id1, device_id3);
   EXPECT_NE(label1, label3);
   EXPECT_NE(label2, label3);
 
   // Check that we now have three opened streams.
   EXPECT_EQ(host_->NumberOfStreams(), 3u);
 
   host_->OnStopGeneratedStream(label1);
   host_->OnStopGeneratedStream(label2);
   host_->OnStopGeneratedStream(label3);
   EXPECT_EQ(host_->NumberOfStreams(), 0u);
 }
 
 TEST_F(MediaStreamDispatcherHostTest, FailOpenVideoDevice) {
   StreamOptions options(MEDIA_NO_SERVICE, MEDIA_DEVICE_VIDEO_CAPTURE);
 
   media::FakeVideoCaptureDevice::SetFailNextCreate();
   SetupFakeUI(false);
   host_->OnGenerateStream(kPageRequestId, options);
-  EXPECT_CALL(*host_, OnStreamGenerationFailed(kRenderId, kPageRequestId));
+  EXPECT_CALL(*host_.get(),
+              OnStreamGenerationFailed(kRenderId, kPageRequestId));
   WaitForResult();
 }
 
 TEST_F(MediaStreamDispatcherHostTest, CancelPendingStreamsOnChannelClosing) {
   StreamOptions options(MEDIA_NO_SERVICE, MEDIA_DEVICE_VIDEO_CAPTURE);
 
   // Create multiple GenerateStream requests.
   size_t streams = 5;
   for (size_t i = 1; i <= streams; ++i) {
     host_->OnGenerateStream(kPageRequestId + i, options);
     EXPECT_EQ(host_->NumberOfStreams(), i);
   }
 
   // Calling OnChannelClosing() to cancel all the pending requests.
   host_->OnChannelClosing();
 
   // Streams should have been cleaned up.
   EXPECT_EQ(host_->NumberOfStreams(), 0u);
 }
 
 TEST_F(MediaStreamDispatcherHostTest, StopGeneratedStreamsOnChannelClosing) {
   StreamOptions options(MEDIA_NO_SERVICE, MEDIA_DEVICE_VIDEO_CAPTURE);
 
   // Create first group of streams.
   size_t generated_streams = 3;
   for (size_t i = 0; i < generated_streams; ++i) {
     SetupFakeUI(true);
-    EXPECT_CALL(*host_, OnStreamGenerated(kRenderId, kPageRequestId + i, 0, 1));
+    EXPECT_CALL(*host_.get(),
+                OnStreamGenerated(kRenderId, kPageRequestId + i, 0, 1));
     host_->OnGenerateStream(kPageRequestId + i, options);
 
     // Wait until the stream is generated.
     WaitForResult();
   }
   EXPECT_EQ(host_->NumberOfStreams(), generated_streams);
 
   // Calling OnChannelClosing() to cancel all the pending/generated streams.
   host_->OnChannelClosing();
 
   message_loop_->RunUntilIdle();
 
   // Streams should have been cleaned up.
   EXPECT_EQ(host_->NumberOfStreams(), 0u);
 }
 
 TEST_F(MediaStreamDispatcherHostTest, CloseFromUI) {
   StreamOptions options(MEDIA_NO_SERVICE, MEDIA_DEVICE_VIDEO_CAPTURE);
 
   base::Closure close_callback;
   scoped_ptr<MockMediaStreamUI> stream_ui(new MockMediaStreamUI());
   EXPECT_CALL(*stream_ui, OnStarted(_))
     .WillOnce(SaveArg<0>(&close_callback));
   media_stream_manager_->UseFakeUI(stream_ui.PassAs<MediaStreamUI>());
 
-  EXPECT_CALL(*host_, OnStreamGenerated(kRenderId, kPageRequestId, 0, 1));
-  EXPECT_CALL(*host_, OnStreamGenerationFailed(kRenderId, kPageRequestId));
+  EXPECT_CALL(*host_.get(), OnStreamGenerated(kRenderId, kPageRequestId, 0, 1));
+  EXPECT_CALL(*host_.get(),
+              OnStreamGenerationFailed(kRenderId, kPageRequestId));
   host_->OnGenerateStream(kPageRequestId, options);
 
   WaitForResult();
 
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
   EXPECT_EQ(host_->NumberOfStreams(), 1u);
 
   ASSERT_FALSE(close_callback.is_null());
   close_callback.Run();
   message_loop_->RunUntilIdle();
 
   EXPECT_EQ(host_->NumberOfStreams(), 0u);
 }
 
 };  // namespace content