Rmoving the notion of task runner from MediaStreamProvider interface.

content/browser/renderer_host/media/media_stream_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.
 
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1209 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!device_task_runner_.get());
   device_task_runner_ = audio_manager_->GetTaskRunner();
 
   // TODO(dalecurtis): Remove ScopedTracker below once crbug.com/457525 is
   // fixed.
   tracked_objects::ScopedTracker tracking_profile2(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "457525 MediaStreamManager::InitializeDeviceManagersOnIOThread 2"));
   audio_input_device_manager_ = new AudioInputDeviceManager(audio_manager_);
-  audio_input_device_manager_->Register(this, device_task_runner_);
+  audio_input_device_manager_->RegisterListener(this);
 
   // TODO(dalecurtis): Remove ScopedTracker below once crbug.com/457525 is
   // fixed.
   tracked_objects::ScopedTracker tracking_profile3(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "457525 MediaStreamManager::InitializeDeviceManagersOnIOThread 3"));
   // We want to be notified of IO message loop destruction to delete the thread
   // and the device managers.
   base::MessageLoop::current()->AddDestructionObserver(this);
 
   // TODO(dalecurtis): Remove ScopedTracker below once crbug.com/457525 is
   // fixed.
   tracked_objects::ScopedTracker tracking_profile4(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "457525 MediaStreamManager::InitializeDeviceManagersOnIOThread 4"));
-  video_capture_manager_ =
-      new VideoCaptureManager(media::VideoCaptureDeviceFactory::CreateFactory(
-          BrowserThread::GetTaskRunnerForThread(BrowserThread::UI)));
 #if defined(OS_WIN)
   // Use an STA Video Capture Thread to try to avoid crashes on enumeration of
   // buggy third party Direct Show modules, http://crbug.com/428958.
   video_capture_thread_.init_com_with_mta(false);
   CHECK(video_capture_thread_.Start());
-  video_capture_manager_->Register(this, video_capture_thread_.task_runner());
+  video_capture_manager_ = new VideoCaptureManager(
+      media::VideoCaptureDeviceFactory::CreateFactory(
+          BrowserThread::GetTaskRunnerForThread(BrowserThread::UI)),
+      video_capture_thread_.task_runner());
 #else
-  video_capture_manager_->Register(this, device_task_runner_);
+  video_capture_manager_ = new VideoCaptureManager(
+      media::VideoCaptureDeviceFactory::CreateFactory(
+          BrowserThread::GetTaskRunnerForThread(BrowserThread::UI)),
+      device_task_runner_);
 #endif
 
+  video_capture_manager_->RegisterListener(this);
+
   media_devices_manager_.reset(
       new MediaDevicesManager(audio_manager_, video_capture_manager_, this));
 }
 
 void MediaStreamManager::Opened(MediaStreamType stream_type,
                                 int capture_session_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "Opened({stream_type = " << stream_type <<  "} "
            << "{capture_session_id = " << capture_session_id << "})";
   // Find the request(s) containing this device and mark it as used.
@@ skipping 267 matching lines @@
     }
   }
 
   CancelRequest(label);
 }
 
 void MediaStreamManager::WillDestroyCurrentMessageLoop() {
   DVLOG(3) << "MediaStreamManager::WillDestroyCurrentMessageLoop()";
   DCHECK(CalledOnIOThread());
   DCHECK(requests_.empty());
-  if (device_task_runner_.get()) {
+  if (media_devices_manager_)
     media_devices_manager_->StopMonitoring();
+  if (video_capture_manager_)
+    video_capture_manager_->UnregisterListener();
+  if (audio_input_device_manager_)
+    audio_input_device_manager_->UnregisterListener();
 
-    video_capture_manager_->Unregister();
-    audio_input_device_manager_->Unregister();
-    device_task_runner_ = NULL;
-  }
-
-  audio_input_device_manager_ = NULL;
-  video_capture_manager_ = NULL;
-  media_devices_manager_ = NULL;
-  g_media_stream_manager_tls_ptr.Pointer()->Set(NULL);
+  device_task_runner_ = nullptr;
+  audio_input_device_manager_ = nullptr;
+  video_capture_manager_ = nullptr;
+  media_devices_manager_ = nullptr;
+  g_media_stream_manager_tls_ptr.Pointer()->Set(nullptr);
 }
 
 void MediaStreamManager::NotifyDevicesChanged(
     MediaDeviceType device_type,
     const MediaDeviceInfoArray& devices) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   MediaObserver* media_observer =
       GetContentClient()->browser()->GetMediaObserver();
 
   MediaStreamType stream_type = ConvertToMediaStreamType(device_type);
@@ skipping 38 matching lines @@
   return true;
 }
 
 MediaStreamProvider* MediaStreamManager::GetDeviceManager(
     MediaStreamType stream_type) {
   if (IsVideoMediaType(stream_type))
     return video_capture_manager();
   else if (IsAudioInputMediaType(stream_type))
     return audio_input_device_manager();
   NOTREACHED();
-  return NULL;
+  return nullptr;
 }
 
 void MediaStreamManager::OnMediaStreamUIWindowId(MediaStreamType video_type,
                                                  StreamDeviceInfoArray devices,
                                                  gfx::NativeViewId window_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!window_id)
     return;
 
   if (video_type != MEDIA_DESKTOP_VIDEO_CAPTURE)
@@ skipping 121 matching lines @@
     return devices;
 
   for (auto& device : devices) {
     device.camera_calibration =
         video_capture_manager()->GetCameraCalibration(device.id);
   }
   return devices;
 }
 
 }  // namespace content