VideoCapture: remove last remnants of IPC

content/renderer/media/video_capture_impl_manager.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.
 //
 // Implementation notes about interactions with VideoCaptureImpl.
 //
 // How is VideoCaptureImpl used:
 //
 // VideoCaptureImpl is an IO thread object while VideoCaptureImplManager
 // lives only on the render thread. It is only possible to access an
@@ skipping 14 matching lines @@
 #include "content/renderer/media/video_capture_impl_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/child/child_process.h"
 #include "content/renderer/media/video_capture_impl.h"
-#include "content/renderer/media/video_capture_message_filter.h"
 
 namespace content {
 
 struct VideoCaptureImplManager::DeviceEntry {
   media::VideoCaptureSessionId session_id;
 
   // To be used and destroyed only on the IO thread.
   std::unique_ptr<VideoCaptureImpl> impl;
 
   // Number of clients using |impl|.
   int client_count;
 
   // This is set to true if this device is being suspended, via
   // VideoCaptureImplManager::Suspend().
   // See also: VideoCaptureImplManager::is_suspending_all_.
   bool is_individually_suspended;
 
   DeviceEntry()
       : session_id(0), client_count(0), is_individually_suspended(false) {}
   DeviceEntry(DeviceEntry&& other) = default;
   DeviceEntry& operator=(DeviceEntry&& other) = default;
   ~DeviceEntry() = default;
 };
 
 VideoCaptureImplManager::VideoCaptureImplManager()
     : next_client_id_(0),
-      filter_(new VideoCaptureMessageFilter()),
       render_main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       is_suspending_all_(false),
       weak_factory_(this) {}
 
 VideoCaptureImplManager::~VideoCaptureImplManager() {
   DCHECK(render_main_task_runner_->BelongsToCurrentThread());
   if (devices_.empty())
     return;
   // Forcibly release all video capture resources.
   for (auto& entry : devices_) {
     ChildProcess::current()->io_task_runner()->DeleteSoon(FROM_HERE,
                                                           entry.impl.release());
   }
   devices_.clear();
 }
 
 base::Closure VideoCaptureImplManager::UseDevice(
     media::VideoCaptureSessionId id) {
+  DVLOG(1) << __func__ << " session id: " << id;
   DCHECK(render_main_task_runner_->BelongsToCurrentThread());
   auto it = std::find_if(
       devices_.begin(), devices_.end(),
       [id] (const DeviceEntry& entry) { return entry.session_id == id; });
   if (it == devices_.end()) {
     devices_.push_back(DeviceEntry());
     it = devices_.end() - 1;
     it->session_id = id;
-    it->impl = CreateVideoCaptureImplForTesting(id, filter_.get());
-    if (!it->impl) {
-      it->impl.reset(new VideoCaptureImpl(
-          id, filter_.get(), ChildProcess::current()->io_task_runner()));
-    }
+    it->impl = CreateVideoCaptureImplForTesting(id);
+    if (!it->impl)
+      it->impl.reset(new VideoCaptureImpl(id));
   }
   ++it->client_count;
 
   // Design limit: When there are multiple clients, VideoCaptureImplManager
   // would have to individually track which ones requested suspending/resuming,
   // in order to determine whether the whole device should be suspended.
   // Instead, handle the non-common use case of multiple clients by just
   // resuming the suspended device, and disable suspend functionality while
   // there are multiple clients.
   if (it->is_individually_suspended)
@@ skipping 94 matching lines @@
       devices_.begin(), devices_.end(),
       [id] (const DeviceEntry& entry) { return entry.session_id == id; });
   DCHECK(it != devices_.end());
   ChildProcess::current()->io_task_runner()->PostTask(
       FROM_HERE, base::Bind(&VideoCaptureImpl::GetDeviceFormatsInUse,
                             base::Unretained(it->impl.get()), callback));
 }
 
 std::unique_ptr<VideoCaptureImpl>
 VideoCaptureImplManager::CreateVideoCaptureImplForTesting(
-    media::VideoCaptureSessionId id,
-    VideoCaptureMessageFilter* filter) const {
+    media::VideoCaptureSessionId session_id) const {
   return std::unique_ptr<VideoCaptureImpl>();
 }
 
 void VideoCaptureImplManager::StopCapture(int client_id,
                                           media::VideoCaptureSessionId id) {
   DCHECK(render_main_task_runner_->BelongsToCurrentThread());
   const auto it = std::find_if(
       devices_.begin(), devices_.end(),
       [id] (const DeviceEntry& entry) { return entry.session_id == id; });
   DCHECK(it != devices_.end());
@@ skipping 26 matching lines @@
   for (auto& entry : devices_) {
     if (entry.is_individually_suspended)
       continue;  // Either: 1) Already suspended; or 2) Should not be resumed.
     ChildProcess::current()->io_task_runner()->PostTask(
         FROM_HERE, base::Bind(&VideoCaptureImpl::SuspendCapture,
                               base::Unretained(entry.impl.get()), suspend));
   }
 }
 
 }  // namespace content