Replace DCHECK(BrowserThread::CurrentlyOn) with DCHECK_CURRENTLY_ON in content/browser/renderer_hos…

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 <list>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 101 matching lines @@
        *video_type = MEDIA_DEVICE_VIDEO_CAPTURE;
      }
   }
 }
 
 // Private helper method for SendMessageToNativeLog() that obtains the global
 // MediaStreamManager instance on the UI thread before sending |message| to the
 // webrtcLoggingPrivate API.
 void DoAddLogMessage(const std::string& message) {
   // Must be on the UI thread to access BrowserMainLoop.
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   // May be null in tests.
   // TODO(vrk): Handle this more elegantly by having native log messages become
   // no-ops until MediaStreamManager is aware that a renderer process has
   // started logging. crbug.com/333894
   if (content::BrowserMainLoop::GetInstance()) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&MediaStreamManager::AddLogMessageOnIOThread,
                    base::Unretained(content::BrowserMainLoop::GetInstance()
@@ skipping 228 matching lines @@
   }
 }
 
 MediaStreamManager::~MediaStreamManager() {
   DVLOG(1) << "~MediaStreamManager";
   DCHECK(requests_.empty());
   DCHECK(!device_task_runner_);
 }
 
 VideoCaptureManager* MediaStreamManager::video_capture_manager() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(video_capture_manager_.get());
   return video_capture_manager_.get();
 }
 
 AudioInputDeviceManager* MediaStreamManager::audio_input_device_manager() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(audio_input_device_manager_.get());
   return audio_input_device_manager_.get();
 }
 
 std::string MediaStreamManager::MakeMediaAccessRequest(
     int render_process_id,
     int render_view_id,
     int page_request_id,
     const StreamOptions& options,
     const GURL& security_origin,
     const MediaRequestResponseCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // TODO(perkj): The argument list with NULL parameters to DeviceRequest
   // suggests that this is the wrong design. Can this be refactored?
   DeviceRequest* request = new DeviceRequest(NULL,
                                              render_process_id,
                                              render_view_id,
                                              page_request_id,
                                              security_origin,
                                              false,  // user gesture
                                              MEDIA_DEVICE_ACCESS,
@@ skipping 16 matching lines @@
 }
 
 void MediaStreamManager::GenerateStream(MediaStreamRequester* requester,
                                         int render_process_id,
                                         int render_view_id,
                                         const ResourceContext::SaltCallback& sc,
                                         int page_request_id,
                                         const StreamOptions& options,
                                         const GURL& security_origin,
                                         bool user_gesture) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "GenerateStream()";
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kUseFakeUIForMediaStream)) {
     UseFakeUI(scoped_ptr<FakeMediaStreamUIProxy>());
   }
 
   DeviceRequest* request = new DeviceRequest(requester,
                                              render_process_id,
                                              render_view_id,
                                              page_request_id,
@@ skipping 26 matching lines @@
         request->requesting_view_id == render_view_id &&
         request->page_request_id == page_request_id) {
       CancelRequest(request_it->first);
       return;
     }
   }
   NOTREACHED();
 }
 
 void MediaStreamManager::CancelRequest(const std::string& label) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "CancelRequest({label = " << label <<  "})";
   DeviceRequest* request = FindRequest(label);
   if (!request) {
     // The request does not exist.
     LOG(ERROR) << "The request with label = " << label  << " does not exist.";
     return;
   }
 
   if (request->request_type == MEDIA_ENUMERATE_DEVICES) {
     // It isn't an ideal use of "CancelRequest" to make it a requirement
@@ skipping 33 matching lines @@
 
     std::string label = request_it->first;
     ++request_it;
     CancelRequest(label);
   }
 }
 
 void MediaStreamManager::StopStreamDevice(int render_process_id,
                                           int render_view_id,
                                           const std::string& device_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "StopStreamDevice({render_view_id = " << render_view_id <<  "} "
            << ", {device_id = " << device_id << "})";
   // Find the first request for this |render_process_id| and |render_view_id|
   // of type MEDIA_GENERATE_STREAM that has requested to use |device_id| and
   // stop it.
   for (DeviceRequests::iterator request_it = requests_.begin();
        request_it  != requests_.end(); ++request_it) {
     DeviceRequest* request = request_it->second;
     if (request->requesting_process_id != render_process_id ||
         request->requesting_view_id != render_view_id ||
@@ skipping 73 matching lines @@
 }
 
 std::string MediaStreamManager::EnumerateDevices(
     MediaStreamRequester* requester,
     int render_process_id,
     int render_view_id,
     const ResourceContext::SaltCallback& sc,
     int page_request_id,
     MediaStreamType type,
     const GURL& security_origin) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(requester);
   DCHECK(type == MEDIA_DEVICE_AUDIO_CAPTURE ||
          type == MEDIA_DEVICE_VIDEO_CAPTURE);
 
   DeviceRequest* request = new DeviceRequest(requester,
                                              render_process_id,
                                              render_view_id,
                                              page_request_id,
                                              security_origin,
                                              false,  // user gesture
@@ skipping 12 matching lines @@
   // MediaStreamManager is deleted on the UI thread, after the IO thread has
   // been stopped.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&MediaStreamManager::DoEnumerateDevices,
                  base::Unretained(this), label));
   return label;
 }
 
 void MediaStreamManager::DoEnumerateDevices(const std::string& label) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DeviceRequest* request = FindRequest(label);
   if (!request)
     return;  // This can happen if the request has been canceled.
 
   MediaStreamType type;
   EnumerationCache* cache;
   if (request->audio_type() == MEDIA_DEVICE_AUDIO_CAPTURE) {
     DCHECK_EQ(MEDIA_NO_SERVICE, request->video_type());
     type = MEDIA_DEVICE_AUDIO_CAPTURE;
     cache = &audio_enumeration_cache_;
@@ skipping 15 matching lines @@
 }
 
 void MediaStreamManager::OpenDevice(MediaStreamRequester* requester,
                                     int render_process_id,
                                     int render_view_id,
                                     const ResourceContext::SaltCallback& sc,
                                     int page_request_id,
                                     const std::string& device_id,
                                     MediaStreamType type,
                                     const GURL& security_origin) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(type == MEDIA_DEVICE_AUDIO_CAPTURE ||
          type == MEDIA_DEVICE_VIDEO_CAPTURE);
   DVLOG(1) << "OpenDevice ({page_request_id = " << page_request_id <<  "})";
   StreamOptions options;
   if (IsAudioMediaType(type)) {
     options.audio_requested = true;
     options.mandatory_audio.push_back(
         StreamOptions::Constraint(kMediaStreamSourceInfoId, device_id));
   } else if (IsVideoMediaType(type)) {
     options.video_requested = true;
@@ skipping 18 matching lines @@
   // and thus can not handle a response. Using base::Unretained is safe since
   // MediaStreamManager is deleted on the UI thread, after the IO thread has
   // been stopped.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&MediaStreamManager::SetupRequest,
                  base::Unretained(this), label));
 }
 
 void MediaStreamManager::EnsureDeviceMonitorStarted() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   StartMonitoring();
 }
 
 void MediaStreamManager::StopRemovedDevices(
     const StreamDeviceInfoArray& old_devices,
     const StreamDeviceInfoArray& new_devices) {
   DVLOG(1) << "StopRemovedDevices("
            << "{#old_devices = " << old_devices.size() <<  "} "
            << "{#new_devices = " << new_devices.size() << "})";
   for (StreamDeviceInfoArray::const_iterator old_dev_it = old_devices.begin();
@@ skipping 39 matching lines @@
       }
     }
   }
   for (std::vector<int>::const_iterator it = session_ids.begin();
        it != session_ids.end(); ++it) {
     StopDevice(device.type, *it);
   }
 }
 
 void MediaStreamManager::StartMonitoring() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (monitoring_started_)
     return;
 
   if (!base::SystemMonitor::Get())
     return;
 
   monitoring_started_ = true;
   base::SystemMonitor::Get()->AddDevicesChangedObserver(this);
 
   // Enumerate both the audio and video devices to cache the device lists
   // and send them to media observer.
   ++active_enumeration_ref_count_[MEDIA_DEVICE_AUDIO_CAPTURE];
   audio_input_device_manager_->EnumerateDevices(MEDIA_DEVICE_AUDIO_CAPTURE);
   ++active_enumeration_ref_count_[MEDIA_DEVICE_VIDEO_CAPTURE];
   video_capture_manager_->EnumerateDevices(MEDIA_DEVICE_VIDEO_CAPTURE);
 
 #if defined(OS_MACOSX)
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&MediaStreamManager::StartMonitoringOnUIThread,
                  base::Unretained(this)));
 #endif
 }
 
 #if defined(OS_MACOSX)
 void MediaStreamManager::StartMonitoringOnUIThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserMainLoop* browser_main_loop = content::BrowserMainLoop::GetInstance();
   if (browser_main_loop)
     browser_main_loop->device_monitor_mac()->StartMonitoring();
 }
 #endif
 
 void MediaStreamManager::StopMonitoring() {
   DCHECK_EQ(base::MessageLoop::current(), io_loop_);
   if (monitoring_started_) {
     base::SystemMonitor::Get()->RemoveDevicesChangedObserver(this);
@@ skipping 124 matching lines @@
     // Make sure the cache is marked as invalid so that FinalizeEnumerateDevices
     // will be called at the end of the enumeration.
     ClearEnumerationCache(cache);
   }
 #endif
   // If the cache isn't valid, we need to start a full enumeration.
   return !cache->valid;
 }
 
 void MediaStreamManager::StartEnumeration(DeviceRequest* request) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Start monitoring the devices when doing the first enumeration.
   StartMonitoring();
 
   // Start enumeration for devices of all requested device types.
   const MediaStreamType streams[] = { request->audio_type(),
                                       request->video_type() };
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(streams); ++i) {
     if (streams[i] == MEDIA_NO_SERVICE)
       continue;
     request->SetState(streams[i], MEDIA_REQUEST_STATE_REQUESTED);
     DCHECK_GE(active_enumeration_ref_count_[streams[i]], 0);
     if (active_enumeration_ref_count_[streams[i]] == 0) {
       ++active_enumeration_ref_count_[streams[i]];
       GetDeviceManager(streams[i])->EnumerateDevices(streams[i]);
     }
   }
 }
 
 std::string MediaStreamManager::AddRequest(DeviceRequest* request) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Create a label for this request and verify it is unique.
   std::string unique_label;
   do {
     unique_label = RandomLabel();
   } while (requests_.find(unique_label) != requests_.end());
 
   requests_.insert(std::make_pair(unique_label, request));
 
   return unique_label;
 }
 
 MediaStreamManager::DeviceRequest*
 MediaStreamManager::FindRequest(const std::string& label) const {
   DeviceRequests::const_iterator request_it = requests_.find(label);
   return request_it == requests_.end() ? NULL : request_it->second;
 }
 
 void MediaStreamManager::DeleteRequest(const std::string& label) {
   DVLOG(1) << "DeleteRequest({label= " << label << "})";
   DeviceRequests::iterator it = requests_.find(label);
   scoped_ptr<DeviceRequest> request(it->second);
   requests_.erase(it);
 }
 
 void MediaStreamManager::PostRequestToUI(const std::string& label,
                                          DeviceRequest* request) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(request->UIRequest());
   DVLOG(1) << "PostRequestToUI({label= " << label << "})";
 
   const MediaStreamType audio_type = request->audio_type();
   const MediaStreamType video_type = request->video_type();
 
   // Post the request to UI and set the state.
   if (IsAudioMediaType(audio_type))
     request->SetState(audio_type, MEDIA_REQUEST_STATE_PENDING_APPROVAL);
   if (IsVideoMediaType(video_type))
@@ skipping 26 matching lines @@
     request->ui_proxy = MediaStreamUIProxy::Create();
   }
 
   request->ui_proxy->RequestAccess(
       *request->UIRequest(),
       base::Bind(&MediaStreamManager::HandleAccessRequestResponse,
                  base::Unretained(this), label));
 }
 
 void MediaStreamManager::SetupRequest(const std::string& label) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DeviceRequest* request = FindRequest(label);
   if (!request) {
     DVLOG(1) << "SetupRequest label " << label << " doesn't exist!!";
     return;  // This can happen if the request has been canceled.
   }
 
   if (!request->security_origin.is_valid()) {
     LOG(ERROR) << "Invalid security origin. "
                << request->security_origin;
     FinalizeRequestFailed(label,
@@ skipping 264 matching lines @@
 void MediaStreamManager::FinalizeOpenDevice(const std::string& label,
                                             DeviceRequest* request) {
   const StreamDeviceInfoArray& requested_devices = request->devices;
   request->requester->DeviceOpened(request->requesting_view_id,
                                    request->page_request_id,
                                    label, requested_devices.front());
 }
 
 void MediaStreamManager::FinalizeEnumerateDevices(const std::string& label,
                                                   DeviceRequest* request) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_EQ(request->request_type, MEDIA_ENUMERATE_DEVICES);
 
   if (request->security_origin.is_valid()) {
     for (StreamDeviceInfoArray::iterator it = request->devices.begin();
          it != request->devices.end(); ++it) {
       TranslateDeviceIdToSourceId(request, &it->device);
     }
   } else {
     request->devices.clear();
   }
@@ skipping 39 matching lines @@
     DeviceRequest* request,
     const MediaStreamDevices& devices) {
   if (!request->callback.is_null())
     request->callback.Run(devices, request->ui_proxy.Pass());
 
   // Delete the request since it is done.
   DeleteRequest(label);
 }
 
 void MediaStreamManager::InitializeDeviceManagersOnIOThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (device_task_runner_)
     return;
 
   device_task_runner_ = audio_manager_->GetWorkerTaskRunner();
 
   audio_input_device_manager_ = new AudioInputDeviceManager(audio_manager_);
   audio_input_device_manager_->Register(this, device_task_runner_);
 
   video_capture_manager_ = new VideoCaptureManager();
   video_capture_manager_->Register(this, device_task_runner_);
 
   // We want to be notified of IO message loop destruction to delete the thread
   // and the device managers.
   io_loop_ = base::MessageLoop::current();
   io_loop_->AddDestructionObserver(this);
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kUseFakeDeviceForMediaStream)) {
     DVLOG(1) << "Using fake device";
     UseFakeDevice();
   }
 }
 
 void MediaStreamManager::Opened(MediaStreamType stream_type,
                                 int capture_session_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  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.
   // It can be used in several requests since the same device can be
   // requested from the same web page.
   for (DeviceRequests::iterator request_it = requests_.begin();
        request_it != requests_.end(); ++request_it) {
     const std::string& label = request_it->first;
     DeviceRequest* request = request_it->second;
     StreamDeviceInfoArray* devices = &(request->devices);
@@ skipping 52 matching lines @@
                    label),
         base::Bind(&MediaStreamManager::OnMediaStreamUIWindowId,
                    base::Unretained(this),
                    request->video_type(),
                    request->devices));
   }
 }
 
 void MediaStreamManager::Closed(MediaStreamType stream_type,
                                 int capture_session_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
 void MediaStreamManager::DevicesEnumerated(
     MediaStreamType stream_type, const StreamDeviceInfoArray& devices) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "DevicesEnumerated("
            << "{stream_type = " << stream_type << "})" << std::endl;
 
   std::string log_message = "New device enumeration result:\n" +
                             GetLogMessageString(stream_type, devices);
   SendMessageToNativeLog(log_message);
 
   // Only cache the device list when the device list has been changed.
   bool need_update_clients = false;
   EnumerationCache* cache =
@@ skipping 70 matching lines @@
 
 // static
 void MediaStreamManager::SendMessageToNativeLog(const std::string& message) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(DoAddLogMessage, message));
 }
 
 void MediaStreamManager::AddLogMessageOnIOThread(const std::string& message) {
   // Get render process ids on the IO thread.
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Grab all unique process ids that request a MediaStream or have a
   // MediaStream running.
   std::set<int> requesting_process_ids;
   for (DeviceRequests::const_iterator it = requests_.begin();
        it != requests_.end(); ++it) {
     DeviceRequest* request = it->second;
     if (request->request_type == MEDIA_GENERATE_STREAM)
       requesting_process_ids.insert(request->requesting_process_id);
   }
 
   // MediaStreamManager is a singleton in BrowserMainLoop, which owns the UI
   // thread. MediaStreamManager has the same lifetime as the UI thread, so it is
   // safe to use base::Unretained.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&MediaStreamManager::AddLogMessageOnUIThread,
                  base::Unretained(this),
                  requesting_process_ids,
                  message));
 }
 
 void MediaStreamManager::AddLogMessageOnUIThread(
     const std::set<int>& requesting_process_ids,
     const std::string& message) {
 #if defined(ENABLE_WEBRTC)
   // Must be on the UI thread to access RenderProcessHost from process ID.
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   for (std::set<int>::const_iterator it = requesting_process_ids.begin();
        it != requesting_process_ids.end(); ++it) {
     // Log the message to all renderers that are requesting a MediaStream or
     // have a MediaStream running.
     content::RenderProcessHostImpl* render_process_host_impl =
         static_cast<content::RenderProcessHostImpl*>(
             content::RenderProcessHost::FromID(*it));
     if (render_process_host_impl)
       render_process_host_impl->WebRtcLogMessage(message);
   }
 #endif
 }
 
 void MediaStreamManager::HandleAccessRequestResponse(
     const std::string& label,
     const MediaStreamDevices& devices,
     content::MediaStreamRequestResult result) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "HandleAccessRequestResponse("
            << ", {label = " << label <<  "})";
 
   DeviceRequest* request = FindRequest(label);
   if (!request) {
     // The request has been canceled before the UI returned.
     return;
   }
 
   if (request->request_type == MEDIA_DEVICE_ACCESS) {
@@ skipping 81 matching lines @@
   }
 
   if (!found_video && IsVideoMediaType(request->video_type()))
     request->SetState(request->video_type(), MEDIA_REQUEST_STATE_ERROR);
 
   if (RequestDone(*request))
     HandleRequestDone(label, request);
 }
 
 void MediaStreamManager::StopMediaStreamFromBrowser(const std::string& label) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   DeviceRequest* request = FindRequest(label);
   if (!request)
     return;
 
   // Notify renderers that the devices in the stream will be stopped.
   if (request->requester) {
     for (StreamDeviceInfoArray::iterator device_it = request->devices.begin();
          device_it != request->devices.end(); ++device_it) {
       request->requester->DeviceStopped(request->requesting_view_id,
                                         label,
                                         *device_it);
     }
   }
 
   CancelRequest(label);
 }
 
 void MediaStreamManager::UseFakeDevice() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   video_capture_manager()->UseFakeDevice();
   audio_input_device_manager()->UseFakeDevice();
 }
 
 void MediaStreamManager::UseFakeUI(scoped_ptr<FakeMediaStreamUIProxy> fake_ui) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   use_fake_ui_ = true;
   fake_ui_ = fake_ui.Pass();
 }
 
 void MediaStreamManager::WillDestroyCurrentMessageLoop() {
   DVLOG(3) << "MediaStreamManager::WillDestroyCurrentMessageLoop()";
   DCHECK_EQ(base::MessageLoop::current(), io_loop_);
   DCHECK(requests_.empty());
   if (device_task_runner_) {
     StopMonitoring();
 
     video_capture_manager_->Unregister();
     audio_input_device_manager_->Unregister();
     device_task_runner_ = NULL;
   }
 
   audio_input_device_manager_ = NULL;
   video_capture_manager_ = NULL;
 }
 
 void MediaStreamManager::NotifyDevicesChanged(
     MediaStreamType stream_type,
     const StreamDeviceInfoArray& devices) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   MediaObserver* media_observer =
       GetContentClient()->browser()->GetMediaObserver();
   if (media_observer == NULL)
     return;
 
   // Map the devices to MediaStreamDevices.
   MediaStreamDevices new_devices;
   for (StreamDeviceInfoArray::const_iterator it = devices.begin();
        it != devices.end(); ++it) {
     new_devices.push_back(it->device);
   }
 
   if (IsAudioMediaType(stream_type)) {
     MediaCaptureDevicesImpl::GetInstance()->OnAudioCaptureDevicesChanged(
         new_devices);
     media_observer->OnAudioCaptureDevicesChanged();
   } else if (IsVideoMediaType(stream_type)) {
     MediaCaptureDevicesImpl::GetInstance()->OnVideoCaptureDevicesChanged(
         new_devices);
     media_observer->OnVideoCaptureDevicesChanged();
   } else {
     NOTREACHED();
   }
 }
 
 bool MediaStreamManager::RequestDone(const DeviceRequest& request) const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   const bool requested_audio = IsAudioMediaType(request.audio_type());
   const bool requested_video = IsVideoMediaType(request.video_type());
 
   const bool audio_done =
       !requested_audio ||
       request.state(request.audio_type()) == MEDIA_REQUEST_STATE_DONE ||
       request.state(request.audio_type()) == MEDIA_REQUEST_STATE_ERROR;
   if (!audio_done)
     return false;
@@ skipping 14 matching lines @@
     return video_capture_manager();
   } else if (IsAudioMediaType(stream_type)) {
     return audio_input_device_manager();
   }
   NOTREACHED();
   return NULL;
 }
 
 void MediaStreamManager::OnDevicesChanged(
     base::SystemMonitor::DeviceType device_type) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // NOTE: This method is only called in response to physical audio/video device
   // changes (from the operating system).
 
   MediaStreamType stream_type;
   if (device_type == base::SystemMonitor::DEVTYPE_AUDIO_CAPTURE) {
     stream_type = MEDIA_DEVICE_AUDIO_CAPTURE;
   } else if (device_type == base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE) {
     stream_type = MEDIA_DEVICE_VIDEO_CAPTURE;
   } else {
     return;  // Uninteresting device change.
   }
 
   // Always do enumeration even though some enumeration is in progress,
   // because those enumeration commands could be sent before these devices
   // change.
   ++active_enumeration_ref_count_[stream_type];
   GetDeviceManager(stream_type)->EnumerateDevices(stream_type);
 }
 
 void MediaStreamManager::OnMediaStreamUIWindowId(MediaStreamType video_type,
                                                  StreamDeviceInfoArray devices,
                                                  gfx::NativeViewId window_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!window_id)
     return;
 
   // Pass along for desktop capturing. Ignored for other stream types.
   if (video_type == MEDIA_DESKTOP_VIDEO_CAPTURE) {
     for (StreamDeviceInfoArray::iterator it = devices.begin();
          it != devices.end();
          ++it) {
       if (it->device.type == MEDIA_DESKTOP_VIDEO_CAPTURE) {
         video_capture_manager_->SetDesktopCaptureWindowId(it->session_id,
                                                           window_id);
         break;
       }
     }
   }
 }
 
 }  // namespace content