Replace DCHECK(BrowserThread::CurrentlyOn) with DCHECK_CURRENTLY_ON in extensions.

chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_api.cc

 // Copyright 2013 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 "chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_api.h"
 
 #include "base/lazy_instance.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
@@ skipping 91 matching lines @@
     : resource_context_(NULL) {
 }
 
 WebrtcAudioPrivateFunction::~WebrtcAudioPrivateFunction() {
 }
 
 void WebrtcAudioPrivateFunction::GetOutputDeviceNames() {
   scoped_refptr<base::SingleThreadTaskRunner> audio_manager_runner =
       AudioManager::Get()->GetTaskRunner();
   if (!audio_manager_runner->BelongsToCurrentThread()) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     audio_manager_runner->PostTask(
         FROM_HERE,
         base::Bind(&WebrtcAudioPrivateFunction::GetOutputDeviceNames, this));
     return;
   }
 
   scoped_ptr<AudioDeviceNames> device_names(new AudioDeviceNames);
   AudioManager::Get()->GetAudioOutputDeviceNames(device_names.get());
 
   BrowserThread::PostTask(
@@ skipping 48 matching lines @@
       FROM_HERE,
       base::Bind(&WebrtcAudioPrivateFunction::OnHMACCalculated, this, hmac));
 }
 
 void WebrtcAudioPrivateFunction::OnHMACCalculated(const std::string& hmac) {
   NOTREACHED();
 }
 
 std::string WebrtcAudioPrivateFunction::CalculateHMACImpl(
     const std::string& raw_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // We don't hash the default device name, and we always return
   // "default" for the default device. There is code in SetActiveSink
   // that transforms "default" to the empty string, and code in
   // GetActiveSink that ensures we return "default" if we get the
   // empty string as the current device ID.
   if (raw_id.empty() || raw_id == media::AudioManagerBase::kDefaultDeviceId)
     return media::AudioManagerBase::kDefaultDeviceId;
 
   GURL security_origin(source_url().GetOrigin());
   return content::GetHMACForMediaDeviceID(
       resource_context()->GetMediaDeviceIDSalt(),
       security_origin,
       raw_id);
 }
 
 void WebrtcAudioPrivateFunction::InitResourceContext() {
   resource_context_ = GetProfile()->GetResourceContext();
 }
 
 content::ResourceContext* WebrtcAudioPrivateFunction::resource_context() const {
   DCHECK(resource_context_);  // Did you forget to InitResourceContext()?
   return resource_context_;
 }
 
 bool WebrtcAudioPrivateGetSinksFunction::RunImpl() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   InitResourceContext();
   GetOutputDeviceNames();
 
   return true;
 }
 
 void WebrtcAudioPrivateGetSinksFunction::OnOutputDeviceNames(
     scoped_ptr<AudioDeviceNames> raw_ids) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   std::vector<linked_ptr<wap::SinkInfo> > results;
   for (AudioDeviceNames::const_iterator it = raw_ids->begin();
        it != raw_ids->end();
        ++it) {
     linked_ptr<wap::SinkInfo> info(new wap::SinkInfo);
     info->sink_id = CalculateHMACImpl(it->unique_id);
     info->sink_label = it->device_name;
     // TODO(joi): Add other parameters.
     results.push_back(info);
@@ skipping 13 matching lines @@
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&WebrtcAudioPrivateGetSinksFunction::DoneOnUIThread, this));
 }
 
 void WebrtcAudioPrivateGetSinksFunction::DoneOnUIThread() {
   SendResponse(true);
 }
 
 bool WebrtcAudioPrivateGetActiveSinkFunction::RunImpl() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   InitResourceContext();
 
   scoped_ptr<wap::GetActiveSink::Params> params(
       wap::GetActiveSink::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   return GetControllerList(params->tab_id);
 }
 
 void WebrtcAudioPrivateGetActiveSinkFunction::OnControllerList(
     const RenderViewHost::AudioOutputControllerList& controllers) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (controllers.empty()) {
     // If there is no current audio stream for the rvh, we return an
     // empty string as the sink ID.
     DVLOG(2) << "chrome.webrtcAudioPrivate.getActiveSink: No controllers.";
     results_.reset(
         wap::GetActiveSink::Results::Create(std::string()).release());
     SendResponse(true);
   } else {
     DVLOG(2) << "chrome.webrtcAudioPrivate.getActiveSink: "
              << controllers.size() << " controllers.";
     // TODO(joi): Debug-only, DCHECK that all items have the same ID.
 
     // Send the raw ID through CalculateHMAC, and send the result in
     // OnHMACCalculated.
     (*controllers.begin())->GetOutputDeviceId(
         base::Bind(&WebrtcAudioPrivateGetActiveSinkFunction::CalculateHMAC,
                    this));
   }
 }
 
 void WebrtcAudioPrivateGetActiveSinkFunction::OnHMACCalculated(
     const std::string& hmac_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   std::string result = hmac_id;
   if (result.empty()) {
     DVLOG(2) << "Received empty ID, replacing with default ID.";
     result = media::AudioManagerBase::kDefaultDeviceId;
   }
   results_.reset(wap::GetActiveSink::Results::Create(result).release());
   SendResponse(true);
 }
 
 WebrtcAudioPrivateSetActiveSinkFunction::
 WebrtcAudioPrivateSetActiveSinkFunction()
     : tab_id_(0),
       num_remaining_sink_ids_(0) {
 }
 
 WebrtcAudioPrivateSetActiveSinkFunction::
 ~WebrtcAudioPrivateSetActiveSinkFunction() {
 }
 
 bool WebrtcAudioPrivateSetActiveSinkFunction::RunImpl() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   scoped_ptr<wap::SetActiveSink::Params> params(
       wap::SetActiveSink::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   InitResourceContext();
 
   tab_id_ = params->tab_id;
   sink_id_ = params->sink_id;
 
   return GetControllerList(tab_id_);
 }
 
 void WebrtcAudioPrivateSetActiveSinkFunction::OnControllerList(
     const RenderViewHost::AudioOutputControllerList& controllers) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   controllers_ = controllers;
   num_remaining_sink_ids_ = controllers_.size();
   if (num_remaining_sink_ids_ == 0) {
     error_ = extensions::ErrorUtils::FormatErrorMessage(
         "No active stream for tab with id: *.",
         base::IntToString(tab_id_));
     SendResponse(false);
   } else {
     // We need to get the output device names, and calculate the HMAC
     // for each, to find the raw ID for the ID provided to this API
     // function call.
     GetOutputDeviceNames();
   }
 }
 
 void WebrtcAudioPrivateSetActiveSinkFunction::OnOutputDeviceNames(
     scoped_ptr<AudioDeviceNames> device_names) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   std::string raw_sink_id;
   if (sink_id_ == media::AudioManagerBase::kDefaultDeviceId) {
     DVLOG(2) << "Received default ID, replacing with empty ID.";
     raw_sink_id = "";
   } else {
     for (AudioDeviceNames::const_iterator it = device_names->begin();
          it != device_names->end();
          ++it) {
       if (sink_id_ == CalculateHMACImpl(it->unique_id)) {
@@ skipping 31 matching lines @@
 WebrtcAudioPrivateGetAssociatedSinkFunction::
 WebrtcAudioPrivateGetAssociatedSinkFunction() {
 }
 
 WebrtcAudioPrivateGetAssociatedSinkFunction::
 ~WebrtcAudioPrivateGetAssociatedSinkFunction() {
 }
 
 bool WebrtcAudioPrivateGetAssociatedSinkFunction::RunImpl() {
   params_ = wap::GetAssociatedSink::Params::Create(*args_);
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   InitResourceContext();
 
   AudioManager::Get()->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&WebrtcAudioPrivateGetAssociatedSinkFunction::
                  GetDevicesOnDeviceThread, this));
 
   return true;
 }
 
 void WebrtcAudioPrivateGetAssociatedSinkFunction::GetDevicesOnDeviceThread() {
   DCHECK(AudioManager::Get()->GetTaskRunner()->BelongsToCurrentThread());
   AudioManager::Get()->GetAudioInputDeviceNames(&source_devices_);
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&WebrtcAudioPrivateGetAssociatedSinkFunction::
                  GetRawSourceIDOnIOThread,
                  this));
 }
 
 void
 WebrtcAudioPrivateGetAssociatedSinkFunction::GetRawSourceIDOnIOThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   GURL security_origin(params_->security_origin);
   std::string source_id_in_origin(params_->source_id_in_origin);
 
   // Find the raw source ID for source_id_in_origin.
   std::string raw_source_id;
   for (AudioDeviceNames::const_iterator it = source_devices_.begin();
        it != source_devices_.end();
        ++it) {
     const std::string& id = it->unique_id;
@@ skipping 27 matching lines @@
   if (!raw_source_id.empty()) {
     raw_sink_id =
         AudioManager::Get()->GetAssociatedOutputDeviceID(raw_source_id);
   }
 
   CalculateHMAC(raw_sink_id);
 }
 
 void WebrtcAudioPrivateGetAssociatedSinkFunction::OnHMACCalculated(
     const std::string& associated_sink_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (associated_sink_id == media::AudioManagerBase::kDefaultDeviceId) {
     DVLOG(2) << "Got default ID, replacing with empty ID.";
     results_.reset(wap::GetAssociatedSink::Results::Create("").release());
   } else {
     results_.reset(
         wap::GetAssociatedSink::Results::Create(associated_sink_id).release());
   }
 
   SendResponse(true);
 }
 
 }  // namespace extensions