Remove MediaStreamDeviceThread in favor of using AudioThread.

content/browser/renderer_host/media/video_capture_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/video_capture_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 #include "content/browser/renderer_host/media/video_capture_controller_event_handler.h"
 #include "content/browser/renderer_host/media/web_contents_video_capture_device.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/media_stream_request.h"
+#include "media/base/scoped_histogram_timer.h"
 #include "media/video/capture/fake_video_capture_device.h"
 #include "media/video/capture/video_capture_device.h"
 
 #if defined(ENABLE_SCREEN_CAPTURE)
 #include "content/browser/renderer_host/media/screen_capture_device.h"
 #endif
 
 namespace content {
 
 // Starting id for the first capture session.
@@ skipping 92 matching lines @@
       FROM_HERE,
       base::Bind(&VideoCaptureManager::OnStop, this, capture_session_id,
                  stopped_cb));
 }
 
 void VideoCaptureManager::UseFakeDevice() {
   use_fake_device_ = true;
 }
 
 void VideoCaptureManager::OnEnumerateDevices(MediaStreamType stream_type) {
+  SCOPED_UMA_HISTOGRAM_TIMER(
+      "Media.VideoCaptureManager.OnEnumerateDevicesTime");
   DCHECK(IsOnDeviceThread());
 
   media::VideoCaptureDevice::Names device_names;
   GetAvailableDevices(stream_type, &device_names);
 
   scoped_ptr<StreamDeviceInfoArray> devices(new StreamDeviceInfoArray());
   for (media::VideoCaptureDevice::Names::iterator it =
            device_names.begin(); it != device_names.end(); ++it) {
     bool opened = DeviceOpened(*it);
     devices->push_back(StreamDeviceInfo(
         stream_type, it->device_name, it->unique_id, opened));
   }
 
   PostOnDevicesEnumerated(stream_type, devices.Pass());
 }
 
 void VideoCaptureManager::OnOpen(int capture_session_id,
                                  const StreamDeviceInfo& device) {
+  SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.OnOpenTime");
   DCHECK(IsOnDeviceThread());
   DCHECK(devices_.find(capture_session_id) == devices_.end());
   DVLOG(1) << "VideoCaptureManager::OnOpen, id " << capture_session_id;
 
   // Check if another session has already opened this device. If so, just
   // use that opened device.
   media::VideoCaptureDevice* video_capture_device = GetOpenedDevice(device);
   if (video_capture_device) {
     DeviceEntry& new_entry = devices_[capture_session_id];
     new_entry.stream_type = device.device.type;
@@ skipping 43 matching lines @@
     return;
   }
 
   DeviceEntry& new_entry = devices_[capture_session_id];
   new_entry.stream_type = device.device.type;
   new_entry.capture_device = video_capture_device;
   PostOnOpened(device.device.type, capture_session_id);
 }
 
 void VideoCaptureManager::OnClose(int capture_session_id) {
+  SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.OnCloseTime");
   DCHECK(IsOnDeviceThread());
   DVLOG(1) << "VideoCaptureManager::OnClose, id " << capture_session_id;
 
   VideoCaptureDevices::iterator device_it = devices_.find(capture_session_id);
   if (device_it == devices_.end()) {
     return;
   }
   const DeviceEntry removed_entry = device_it->second;
   devices_.erase(device_it);
 
@@ skipping 17 matching lines @@
     }
     delete removed_entry.capture_device;
   }
 
   PostOnClosed(removed_entry.stream_type, capture_session_id);
 }
 
 void VideoCaptureManager::OnStart(
     const media::VideoCaptureParams capture_params,
     media::VideoCaptureDevice::EventHandler* video_capture_receiver) {
+  SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.OnStartTime");
   DCHECK(IsOnDeviceThread());
   DCHECK(video_capture_receiver != NULL);
   DVLOG(1) << "VideoCaptureManager::OnStart, (" << capture_params.width
            << ", " << capture_params.height
            << ", " << capture_params.frame_per_second
            << ", " << capture_params.session_id
            << ")";
 
   media::VideoCaptureDevice* video_capture_device =
       GetDeviceInternal(capture_params.session_id);
@@ skipping 11 matching lines @@
   // video_capture_device. video_capture_receiver to perform actions.
   video_capture_device->Allocate(capture_params.width, capture_params.height,
                                  capture_params.frame_per_second,
                                  video_capture_receiver);
   video_capture_device->Start();
 }
 
 void VideoCaptureManager::OnStop(
     const media::VideoCaptureSessionId capture_session_id,
     base::Closure stopped_cb) {
+  SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.OnStopTime");
   DCHECK(IsOnDeviceThread());
   DVLOG(1) << "VideoCaptureManager::OnStop, id " << capture_session_id;
 
   VideoCaptureDevices::iterator it = devices_.find(capture_session_id);
   if (it != devices_.end()) {
     media::VideoCaptureDevice* video_capture_device = it->second.capture_device;
     // Possible errors are signaled to video_capture_receiver by
     // video_capture_device. video_capture_receiver to perform actions.
     video_capture_device->Stop();
     video_capture_device->DeAllocate();
@@ skipping 265 matching lines @@
 
     VideoCaptureDevices::iterator dit = devices_.find(capture_session_id);
     if (dit != devices_.end()) {
       return dit->second.capture_device;
     }
   }
   return NULL;
 }
 
 }  // namespace content