favor DCHECK_CURRENTLY_ON for better logs in content/browser/[f-p]*

content/browser/media/media_internals.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/media/media_internals.h"
 
 #include "base/metrics/histogram.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
@@ skipping 241 matching lines @@
 
 MediaInternals::MediaInternalsUMAHandler::MediaInternalsUMAHandler() {
   registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  NotificationService::AllBrowserContextsAndSources());
 }
 
 void MediaInternals::MediaInternalsUMAHandler::Observe(
     int type,
     const NotificationSource& source,
     const NotificationDetails& details) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(type, NOTIFICATION_RENDERER_PROCESS_TERMINATED);
   RenderProcessHost* process = Source<RenderProcessHost>(source).ptr();
 
   // Post the task to the IO thread to avoid race in updating renderer_info_ map
   // by both SavePlayerState & LogAndClearPlayersInRenderer from different
   // threads.
   // Using base::Unretained() on MediaInternalsUMAHandler is safe since
   // it is owned by MediaInternals and share the same lifetime
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&MediaInternalsUMAHandler::LogAndClearPlayersInRenderer,
                  base::Unretained(this), process->GetID()));
 }
 
 void MediaInternals::MediaInternalsUMAHandler::SavePlayerState(
     const media::MediaLogEvent& event,
     int render_process_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   PlayerInfoMap& player_info = renderer_info_[render_process_id];
   switch (event.type) {
     case media::MediaLogEvent::PIPELINE_ERROR: {
       int status;
       event.params.GetInteger("pipeline_error", &status);
       player_info[event.id].last_pipeline_status =
           static_cast<media::PipelineStatus>(status);
       break;
     }
     case media::MediaLogEvent::PROPERTY_CHANGE:
@@ skipping 27 matching lines @@
       }
       break;
     default:
       break;
   }
   return;
 }
 
 std::string MediaInternals::MediaInternalsUMAHandler::GetUMANameForAVStream(
     const PipelineInfo& player_info) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   static const char kPipelineUmaPrefix[] = "Media.PipelineStatus.AudioVideo.";
   std::string uma_name = kPipelineUmaPrefix;
   if (player_info.video_codec_name == "vp8") {
     uma_name += "VP8.";
   } else if (player_info.video_codec_name == "vp9") {
     uma_name += "VP9.";
   } else if (player_info.video_codec_name == "h264") {
     uma_name += "H264.";
   } else {
     return uma_name + "Other";
@@ skipping 11 matching lines @@
   if (player_info.video_decoder == media::GpuVideoDecoder::kDecoderName) {
     uma_name += "HW";
   } else {
     uma_name += "SW";
   }
   return uma_name;
 }
 
 void MediaInternals::MediaInternalsUMAHandler::ReportUMAForPipelineStatus(
     const PipelineInfo& player_info) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (player_info.has_video && player_info.has_audio) {
     base::LinearHistogram::FactoryGet(
         GetUMANameForAVStream(player_info), 1, media::PIPELINE_STATUS_MAX,
         media::PIPELINE_STATUS_MAX + 1,
         base::HistogramBase::kUmaTargetedHistogramFlag)
         ->Add(player_info.last_pipeline_status);
   } else if (player_info.has_audio) {
     UMA_HISTOGRAM_ENUMERATION("Media.PipelineStatus.AudioOnly",
                               player_info.last_pipeline_status,
                               media::PIPELINE_STATUS_MAX + 1);
   } else if (player_info.has_video) {
     UMA_HISTOGRAM_ENUMERATION("Media.PipelineStatus.VideoOnly",
                               player_info.last_pipeline_status,
                               media::PIPELINE_STATUS_MAX + 1);
   } else {
     UMA_HISTOGRAM_ENUMERATION("Media.PipelineStatus.Unsupported",
                               player_info.last_pipeline_status,
                               media::PIPELINE_STATUS_MAX + 1);
   }
   // Report whether video decoder fallback happened, but only if a video decoder
   // was reported.
   if (!player_info.video_decoder.empty()) {
     UMA_HISTOGRAM_BOOLEAN("Media.VideoDecoderFallback",
                           player_info.video_decoder_changed);
   }
 }
 
 void MediaInternals::MediaInternalsUMAHandler::LogAndClearPlayersInRenderer(
     int render_process_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   auto players_it = renderer_info_.find(render_process_id);
   if (players_it == renderer_info_.end())
     return;
   auto it = players_it->second.begin();
   while (it != players_it->second.end()) {
     ReportUMAForPipelineStatus(it->second);
     players_it->second.erase(it++);
   }
 }
 
 MediaInternals* MediaInternals::GetInstance() {
   return g_media_internals.Pointer();
 }
 
 MediaInternals::MediaInternals()
     : owner_ids_(), uma_handler_(new MediaInternalsUMAHandler()) {
 }
 
 MediaInternals::~MediaInternals() {}
 
 void MediaInternals::OnMediaEvents(
     int render_process_id, const std::vector<media::MediaLogEvent>& events) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Notify observers that |event| has occurred.
   for (auto event = events.begin(); event != events.end(); ++event) {
     base::DictionaryValue dict;
     dict.SetInteger("renderer", render_process_id);
     dict.SetInteger("player", event->id);
     dict.SetString("type", media::MediaLog::EventTypeToString(event->type));
 
     // TODO(dalecurtis): This is technically not correct.  TimeTicks "can't" be
     // converted to to a human readable time format.  See base/time/time.h.
     const double ticks = event->time.ToInternalValue();
@@ skipping 10 matching lines @@
     } else {
       dict.Set("params", event->params.DeepCopy());
     }
 
     SendUpdate(SerializeUpdate("media.onMediaEvent", &dict));
     uma_handler_->SavePlayerState(*event, render_process_id);
   }
 }
 
 void MediaInternals::AddUpdateCallback(const UpdateCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   update_callbacks_.push_back(callback);
 }
 
 void MediaInternals::RemoveUpdateCallback(const UpdateCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   for (size_t i = 0; i < update_callbacks_.size(); ++i) {
     if (update_callbacks_[i].Equals(callback)) {
       update_callbacks_.erase(update_callbacks_.begin() + i);
       return;
     }
   }
   NOTREACHED();
 }
 
 void MediaInternals::SendAudioStreamData() {
   base::string16 audio_stream_update;
   {
     base::AutoLock auto_lock(lock_);
     audio_stream_update = SerializeUpdate(
         "media.onReceiveAudioStreamData", &audio_streams_cached_data_);
   }
   SendUpdate(audio_stream_update);
 }
 
 void MediaInternals::SendVideoCaptureDeviceCapabilities() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   SendUpdate(SerializeUpdate("media.onReceiveVideoCaptureCapabilities",
                              &video_capture_capabilities_cached_data_));
 }
 
 void MediaInternals::UpdateVideoCaptureDeviceCapabilities(
     const media::VideoCaptureDeviceInfos& video_capture_device_infos) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   video_capture_capabilities_cached_data_.Clear();
 
   for (const auto& video_capture_device_info : video_capture_device_infos) {
     base::ListValue* format_list = new base::ListValue();
     for (const auto& format : video_capture_device_info.supported_formats)
       format_list->AppendString(format.ToString());
 
     base::DictionaryValue* device_dict = new base::DictionaryValue();
     device_dict->SetString("id", video_capture_device_info.name.id());
     device_dict->SetString(
@@ skipping 54 matching lines @@
     const std::string& function,
     const base::DictionaryValue* value) {
   SendUpdate(SerializeUpdate(function, value));
 
   base::AutoLock auto_lock(lock_);
   scoped_ptr<base::Value> out_value;
   CHECK(audio_streams_cached_data_.Remove(cache_key, &out_value));
 }
 
 }  // namespace content