Refactor VideoCapturerDelegate to use WeakPtr instead of refcount.

content/renderer/media/media_stream_video_capture_source_unittest.cc

 // Copyright 2014 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 "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/child/child_process.h"
@@ skipping 12 matching lines @@
  public:
   explicit MockVideoCapturerDelegate(const StreamDeviceInfo& device_info)
       : VideoCapturerDelegate(device_info) {}
 
   MOCK_METHOD3(StartCapture,
                void(const media::VideoCaptureParams& params,
                     const VideoCaptureDeliverFrameCB& new_frame_callback,
                     const RunningCallback& running_callback));
   MOCK_METHOD0(StopCapture, void());
 
- private:
   virtual ~MockVideoCapturerDelegate() {}
 };
 
 class MediaStreamVideoCapturerSourceTest : public testing::Test {
  public:
   MediaStreamVideoCapturerSourceTest()
      : child_process_(new ChildProcess()),
        source_(NULL),
+       delegate_(NULL),
        source_stopped_(false) {
   }
 
   void TearDown() override {
     webkit_source_.reset();
     blink::WebHeap::collectAllGarbageForTesting();
   }
 
   void InitWithDeviceInfo(const StreamDeviceInfo& device_info) {
-    delegate_ = new MockVideoCapturerDelegate(device_info);
+    scoped_ptr<MockVideoCapturerDelegate> delegate(
+        new MockVideoCapturerDelegate(device_info));
+    delegate_ = delegate.get();
     source_ = new MediaStreamVideoCapturerSource(
         device_info,
         base::Bind(&MediaStreamVideoCapturerSourceTest::OnSourceStopped,
                     base::Unretained(this)),
-        delegate_);
+        delegate.Pass());
 
     webkit_source_.initialize(base::UTF8ToUTF16("dummy_source_id"),
                               blink::WebMediaStreamSource::TypeVideo,
                               base::UTF8ToUTF16("dummy_source_name"),
                               false /* remote */ , true /* readonly */);
     webkit_source_.setExtraData(source_);
     webkit_source_id_ = webkit_source_.id();
   }
 
   blink::WebMediaStreamTrack StartSource() {
     MockMediaConstraintFactory factory;
     bool enabled = true;
     // CreateVideoTrack will trigger OnConstraintsApplied.
     return MediaStreamVideoTrack::CreateVideoTrack(
         source_, factory.CreateWebMediaConstraints(),
         base::Bind(
             &MediaStreamVideoCapturerSourceTest::OnConstraintsApplied,
             base::Unretained(this)),
             enabled);
   }
 
   MockVideoCapturerDelegate& mock_delegate() {
-    return *static_cast<MockVideoCapturerDelegate*>(delegate_.get());
+    return *delegate_;
   }
 
   void OnSourceStopped(const blink::WebMediaStreamSource& source) {
     source_stopped_ =  true;
     EXPECT_EQ(source.id(), webkit_source_id_);
   }
 
  protected:
   void OnConstraintsApplied(MediaStreamSource* source,
                             MediaStreamRequestResult result,
                             const blink::WebString& result_name) {
   }
 
   base::MessageLoopForUI message_loop_;
   scoped_ptr<ChildProcess> child_process_;
   blink::WebMediaStreamSource webkit_source_;
-  MediaStreamVideoCapturerSource* source_;  // owned by webkit_source.
-  scoped_refptr<VideoCapturerDelegate> delegate_;
+  MediaStreamVideoCapturerSource* source_;  // owned by |webkit_source_|.
+  MockVideoCapturerDelegate* delegate_; // owned by |source|.
   blink::WebString webkit_source_id_;
   bool source_stopped_;
 };
 
 TEST_F(MediaStreamVideoCapturerSourceTest, TabCaptureAllowResolutionChange) {
   StreamDeviceInfo device_info;
   device_info.device.type = MEDIA_TAB_VIDEO_CAPTURE;
   InitWithDeviceInfo(device_info);
 
   EXPECT_CALL(mock_delegate(), StartCapture(
@@ skipping 18 matching lines @@
       testing::_,
       testing::_)).Times(1);
   blink::WebMediaStreamTrack track = StartSource();
   // When the track goes out of scope, the source will be stopped.
   EXPECT_CALL(mock_delegate(), StopCapture());
 }
 
 TEST_F(MediaStreamVideoCapturerSourceTest, Ended) {
   StreamDeviceInfo device_info;
   device_info.device.type = MEDIA_DESKTOP_VIDEO_CAPTURE;
-  delegate_ = new VideoCapturerDelegate(device_info);
+  scoped_ptr<VideoCapturerDelegate> delegate(
+      new VideoCapturerDelegate(device_info));
+  VideoCapturerDelegate* delegate_ptr = delegate.get();
   source_ = new MediaStreamVideoCapturerSource(
       device_info,
       base::Bind(&MediaStreamVideoCapturerSourceTest::OnSourceStopped,
                  base::Unretained(this)),
-      delegate_);
+      delegate.Pass());
   webkit_source_.initialize(base::UTF8ToUTF16("dummy_source_id"),
                             blink::WebMediaStreamSource::TypeVideo,
                             base::UTF8ToUTF16("dummy_source_name"),
                             false /* remote */ , true /* readonly */);
   webkit_source_.setExtraData(source_);
   webkit_source_id_ = webkit_source_.id();
   blink::WebMediaStreamTrack track = StartSource();
   message_loop_.RunUntilIdle();
 
-  delegate_->OnStateUpdateOnRenderThread(VIDEO_CAPTURE_STATE_STARTED);
+  delegate_ptr->OnStateUpdateOnRenderThread(VIDEO_CAPTURE_STATE_STARTED);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateLive,
             webkit_source_.readyState());
 
   EXPECT_FALSE(source_stopped_);
-  delegate_->OnStateUpdateOnRenderThread(VIDEO_CAPTURE_STATE_ERROR);
+  delegate_ptr->OnStateUpdateOnRenderThread(VIDEO_CAPTURE_STATE_ERROR);
   message_loop_.RunUntilIdle();
   EXPECT_EQ(blink::WebMediaStreamSource::ReadyStateEnded,
             webkit_source_.readyState());
   // Verify that MediaStreamSource::SourceStoppedCallback has been triggered.
   EXPECT_TRUE(source_stopped_);
 }
 
 class FakeMediaStreamVideoSink : public MediaStreamVideoSink {
  public:
   FakeMediaStreamVideoSink(base::TimeTicks* capture_time,
@@ skipping 50 matching lines @@
       base::Bind(deliver_frame_cb,
                  media::VideoFrame::CreateBlackFrame(gfx::Size(2, 2)),
                  media::VideoCaptureFormat(),
                  reference_capture_time));
   run_loop.Run();
   FakeMediaStreamVideoSink::RemoveFromVideoTrack(&fake_sink, track);
   EXPECT_EQ(reference_capture_time, capture_time);
 }
 
 }  // namespace content