VideoCaptureImpl cleanup: merge ctor+Init() and DeInit()+dtor.

content/renderer/media/video_capture_impl_manager_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 <array>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 33 matching lines @@
   virtual void OnPaused(media::VideoCaptureSessionId session_id) = 0;
   virtual void OnResumed(media::VideoCaptureSessionId session_id) = 0;
 };
 
 class MockVideoCaptureImpl : public VideoCaptureImpl {
  public:
   MockVideoCaptureImpl(media::VideoCaptureSessionId session_id,
                        VideoCaptureMessageFilter* filter,
                        PauseResumeCallback* pause_callback,
                        base::Closure destruct_callback)
-      : VideoCaptureImpl(session_id, filter),
-        pause_callback_(pause_callback), destruct_callback_(destruct_callback) {
-  }
+      : VideoCaptureImpl(session_id,
+                         filter,
+                         ChildProcess::current()->io_task_runner()),
+        pause_callback_(pause_callback),
+        destruct_callback_(destruct_callback) {}
 
   ~MockVideoCaptureImpl() override { destruct_callback_.Run(); }
 
   void Send(IPC::Message* message) override {
     IPC_BEGIN_MESSAGE_MAP(MockVideoCaptureImpl, *message)
       IPC_MESSAGE_HANDLER(VideoCaptureHostMsg_Pause, DevicePauseCapture)
       IPC_MESSAGE_HANDLER(VideoCaptureHostMsg_Resume, DeviceResumeCapture)
       default:
         VideoCaptureImpl::Send(message);
         return;
     IPC_END_MESSAGE_MAP()
     delete message;
   }
 
  private:
   void DevicePauseCapture(int device_id) {
     pause_callback_->OnPaused(session_id());
   }
 
   void DeviceResumeCapture(int device_id,
                            media::VideoCaptureSessionId session_id,
                            const media::VideoCaptureParams& params) {
     pause_callback_->OnResumed(session_id);
   }
 
   PauseResumeCallback* const pause_callback_;
-  base::Closure destruct_callback_;
+  const base::Closure destruct_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(MockVideoCaptureImpl);
 };
 
 class MockVideoCaptureImplManager : public VideoCaptureImplManager {
  public:
   MockVideoCaptureImplManager(PauseResumeCallback* pause_callback,
                               base::Closure destruct_video_capture_callback)
       : pause_callback_(pause_callback),
-        destruct_video_capture_callback_(
-          destruct_video_capture_callback) {}
+        destruct_video_capture_callback_(destruct_video_capture_callback) {}
   ~MockVideoCaptureImplManager() override {}
 
  protected:
   std::unique_ptr<VideoCaptureImpl> CreateVideoCaptureImplForTesting(
       media::VideoCaptureSessionId id,
       VideoCaptureMessageFilter* filter) const override {
     return base::MakeUnique<MockVideoCaptureImpl>(
         id, filter, pause_callback_, destruct_video_capture_callback_);
   }
 
  private:
   PauseResumeCallback* const pause_callback_;
-  base::Closure destruct_video_capture_callback_;
+  const base::Closure destruct_video_capture_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(MockVideoCaptureImplManager);
 };
 
 }  // namespace
 
-class VideoCaptureImplManagerTest
-    : public ::testing::Test, public PauseResumeCallback {
+class VideoCaptureImplManagerTest : public ::testing::Test,
+                                    public PauseResumeCallback {
  public:
   VideoCaptureImplManagerTest()
-      : manager_(new MockVideoCaptureImplManager(
-            this, BindToCurrentLoop(cleanup_run_loop_.QuitClosure()))) {
-    params_.requested_format = media::VideoCaptureFormat(
-        gfx::Size(176, 144), 30, media::PIXEL_FORMAT_I420);
-    child_process_.reset(new ChildProcess());
-  }
-
-  void FakeChannelSetup() {
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner =
-        child_process_->io_task_runner();
-    if (!task_runner->BelongsToCurrentThread()) {
-      task_runner->PostTask(
-          FROM_HERE, base::Bind(&VideoCaptureImplManagerTest::FakeChannelSetup,
-                                base::Unretained(this)));
-      return;
-    }
-    manager_->video_capture_message_filter()->OnFilterAdded(NULL);
-  }
+      : child_process_(new ChildProcess()),
+        manager_(new MockVideoCaptureImplManager(
+            this,
+            BindToCurrentLoop(cleanup_run_loop_.QuitClosure()))) {}
 
  protected:
   static constexpr size_t kNumClients = 3;
 
   std::array<base::Closure, kNumClients> StartCaptureForAllClients(
       bool same_session_id) {
     base::RunLoop run_loop;
     base::Closure quit_closure = BindToCurrentLoop(run_loop.QuitClosure());
     EXPECT_CALL(*this, OnStarted(_)).Times(kNumClients - 1)
         .RetiresOnSaturation();
     EXPECT_CALL(*this, OnStarted(_)).WillOnce(RunClosure(quit_closure))
         .RetiresOnSaturation();
     std::array<base::Closure, kNumClients> stop_callbacks;
-    for (size_t i = 0; i < kNumClients; ++i)
+    media::VideoCaptureParams params;
+    params.requested_format = media::VideoCaptureFormat(
+        gfx::Size(176, 144), 30, media::PIXEL_FORMAT_I420);
+    for (size_t i = 0; i < kNumClients; ++i) {
       stop_callbacks[i] = StartCapture(
           same_session_id ? 0 : static_cast<media::VideoCaptureSessionId>(i),
-          params_);
-    FakeChannelSetup();
+          params);
+    }
+    child_process_->io_task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&VideoCaptureMessageFilter::OnFilterAdded,
+                   base::Unretained(manager_->video_capture_message_filter()),
+                   nullptr));
     run_loop.Run();
     return stop_callbacks;
   }
 
   void StopCaptureForAllClients(
       std::array<base::Closure, kNumClients>* stop_callbacks) {
     base::RunLoop run_loop;
     base::Closure quit_closure = BindToCurrentLoop(run_loop.QuitClosure());
     EXPECT_CALL(*this, OnStopped(_)).Times(kNumClients - 1)
         .RetiresOnSaturation();
     EXPECT_CALL(*this, OnStopped(_)).WillOnce(RunClosure(quit_closure))
         .RetiresOnSaturation();
     for (size_t i = 0; i < kNumClients; ++i)
       (*stop_callbacks)[i].Run();
     run_loop.Run();
   }
 
   MOCK_METHOD2(OnFrameReady,
                void(const scoped_refptr<media::VideoFrame>&,
                     base::TimeTicks estimated_capture_time));
   MOCK_METHOD1(OnStarted, void(media::VideoCaptureSessionId id));
   MOCK_METHOD1(OnStopped, void(media::VideoCaptureSessionId id));
   MOCK_METHOD1(OnPaused, void(media::VideoCaptureSessionId id));
   MOCK_METHOD1(OnResumed, void(media::VideoCaptureSessionId id));
 
   void OnStateUpdate(media::VideoCaptureSessionId id, VideoCaptureState state) {
-    switch (state) {
-      case VIDEO_CAPTURE_STATE_STARTED:
-        OnStarted(id);
-        break;
-      case VIDEO_CAPTURE_STATE_STOPPED:
-        OnStopped(id);
-        break;
-      default:
-        NOTREACHED();
-    }
+    if (state == VIDEO_CAPTURE_STATE_STARTED)
+      OnStarted(id);
+    else if (state == VIDEO_CAPTURE_STATE_STOPPED)
+      OnStopped(id);
+    else
+      NOTREACHED();
   }
 
   base::Closure StartCapture(media::VideoCaptureSessionId id,
                              const media::VideoCaptureParams& params) {
     return manager_->StartCapture(
         id, params, base::Bind(&VideoCaptureImplManagerTest::OnStateUpdate,
                                base::Unretained(this), id),
         base::Bind(&VideoCaptureImplManagerTest::OnFrameReady,
                    base::Unretained(this)));
   }
 
-  base::MessageLoop message_loop_;
-  std::unique_ptr<ChildProcess> child_process_;
-  media::VideoCaptureParams params_;
+  const base::MessageLoop message_loop_;
+  const std::unique_ptr<ChildProcess> child_process_;
   base::RunLoop cleanup_run_loop_;
   std::unique_ptr<MockVideoCaptureImplManager> manager_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureImplManagerTest);
 };
 
 // Multiple clients with the same session id. There is only one
 // media::VideoCapture object.
 TEST_F(VideoCaptureImplManagerTest, MultipleClients) {
@@ skipping 90 matching lines @@
     run_loop.Run();
   }
 
   StopCaptureForAllClients(&stop_callbacks);
   for (size_t i = 0; i < kNumClients; ++i)
     release_callbacks[i].Run();
   cleanup_run_loop_.Run();
 }
 
 }  // namespace content