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

content/browser/renderer_host/media/media_stream_dispatcher_host.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_dispatcher_host.h"
 
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/common/media/media_stream_messages.h"
 #include "content/common/media/media_stream_options.h"
@@ skipping 11 matching lines @@
       salt_callback_(salt_callback),
       media_stream_manager_(media_stream_manager) {
 }
 
 void MediaStreamDispatcherHost::StreamGenerated(
     int render_view_id,
     int page_request_id,
     const std::string& label,
     const StreamDeviceInfoArray& audio_devices,
     const StreamDeviceInfoArray& video_devices) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "MediaStreamDispatcherHost::StreamGenerated("
            << ", {label = " << label <<  "})";
 
   Send(new MediaStreamMsg_StreamGenerated(
       render_view_id, page_request_id, label, audio_devices,
       video_devices));
 }
 
 void MediaStreamDispatcherHost::StreamGenerationFailed(
     int render_view_id,
     int page_request_id,
     content::MediaStreamRequestResult result) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "MediaStreamDispatcherHost::StreamGenerationFailed("
            << ", {page_request_id = " << page_request_id <<  "}"
            << ", { result= " << result << "})";
 
 
   Send(new MediaStreamMsg_StreamGenerationFailed(render_view_id,
                                                  page_request_id,
                                                  result));
 }
 
 void MediaStreamDispatcherHost::DeviceStopped(int render_view_id,
                                               const std::string& label,
                                               const StreamDeviceInfo& device) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "MediaStreamDispatcherHost::DeviceStopped("
            << "{label = " << label << "}, "
            << "{type = " << device.device.type << "}, "
            << "{device_id = " << device.device.id << "})";
 
   Send(new MediaStreamMsg_DeviceStopped(render_view_id, label, device));
 }
 
 void MediaStreamDispatcherHost::DevicesEnumerated(
     int render_view_id,
     int page_request_id,
     const std::string& label,
     const StreamDeviceInfoArray& devices) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "MediaStreamDispatcherHost::DevicesEnumerated("
            << ", {page_request_id = " << page_request_id <<  "})";
 
   Send(new MediaStreamMsg_DevicesEnumerated(render_view_id, page_request_id,
                                             devices));
 }
 
 void MediaStreamDispatcherHost::DeviceOpened(
     int render_view_id,
     int page_request_id,
     const std::string& label,
     const StreamDeviceInfo& video_device) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "MediaStreamDispatcherHost::DeviceOpened("
            << ", {page_request_id = " << page_request_id <<  "})";
 
   Send(new MediaStreamMsg_DeviceOpened(
       render_view_id, page_request_id, label, video_device));
 }
 
 bool MediaStreamDispatcherHost::OnMessageReceived(
     const IPC::Message& message, bool* message_was_ok) {
   bool handled = true;
@@ skipping 132 matching lines @@
   if (!ChildProcessSecurityPolicyImpl::GetInstance()->CanRequestURL(
           render_process_id_, url)) {
     LOG(ERROR) << "MSDH: Renderer requested a URL it's not allowed to use.";
     return false;
   }
 
   return true;
 }
 
 }  // namespace content