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 "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 14 matching lines @@
 
 ACTION_P(RunClosure, closure) {
   closure.Run();
 }
 
 class MockVideoCaptureImpl : public VideoCaptureImpl {
  public:
   MockVideoCaptureImpl(media::VideoCaptureSessionId session_id,
                        VideoCaptureMessageFilter* filter,
                        base::Closure destruct_callback)
-      : VideoCaptureImpl(session_id, filter),
-        destruct_callback_(destruct_callback) {
-  }
+      : VideoCaptureImpl(session_id,
+                         filter,
+                         ChildProcess::current()->io_task_runner()),
+        destruct_callback_(destruct_callback) {}
 
   ~MockVideoCaptureImpl() override { destruct_callback_.Run(); }
 
  private:
-  base::Closure destruct_callback_;
+  const base::Closure destruct_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(MockVideoCaptureImpl);
 };
 
 class MockVideoCaptureImplManager : public VideoCaptureImplManager {
  public:
   explicit MockVideoCaptureImplManager(
       base::Closure destruct_video_capture_callback)
       : destruct_video_capture_callback_(
           destruct_video_capture_callback) {}
   ~MockVideoCaptureImplManager() override {}
 
  protected:
   VideoCaptureImpl* CreateVideoCaptureImplForTesting(
       media::VideoCaptureSessionId id,
       VideoCaptureMessageFilter* filter) const override {
     return new MockVideoCaptureImpl(id,
                                     filter,
                                     destruct_video_capture_callback_);
   }
 
  private:
-  base::Closure destruct_video_capture_callback_;
+  const base::Closure destruct_video_capture_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(MockVideoCaptureImplManager);
 };
 
 class VideoCaptureImplManagerTest : public ::testing::Test {
  public:
   VideoCaptureImplManagerTest()
-      : manager_(new MockVideoCaptureImplManager(
-          BindToCurrentLoop(cleanup_run_loop_.QuitClosure()))) {
+      : child_process_(new ChildProcess()),
+        manager_(new MockVideoCaptureImplManager(
+            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;
@@ skipping 22 matching lines @@
   }
 
   base::Closure StartCapture(const media::VideoCaptureParams& params) {
     return manager_->StartCapture(
         0, params, base::Bind(&VideoCaptureImplManagerTest::OnStateUpdate,
                               base::Unretained(this)),
         base::Bind(&VideoCaptureImplManagerTest::OnFrameReady,
                    base::Unretained(this)));
   }
 
-  base::MessageLoop message_loop_;
-  std::unique_ptr<ChildProcess> child_process_;
+  const base::MessageLoop message_loop_;
+  const std::unique_ptr<ChildProcess> child_process_;
   media::VideoCaptureParams params_;
   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.
@@ skipping 27 matching lines @@
   cleanup_run_loop_.Run();
 }
 
 TEST_F(VideoCaptureImplManagerTest, NoLeak) {
   manager_->UseDevice(0).Reset();
   manager_.reset();
   cleanup_run_loop_.Run();
 }
 
 }  // namespace content