Incorporating logging into Cast

media/cast/logging/logging_impl.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 "base/debug/trace_event.h"
 #include "base/metrics/histogram.h"
 #include "media/cast/logging/logging_impl.h"
 
 namespace media {
 namespace cast {
 
 LoggingImpl::LoggingImpl(base::TickClock* clock,
+                         scoped_refptr<base::TaskRunner> main_thread_proxy,
                          bool enable_data_collection,
                          bool enable_uma_stats,
                          bool enable_tracing)
-    : enable_data_collection_(enable_data_collection),
+    : main_thread_proxy_(main_thread_proxy),
+      enable_data_collection_(enable_data_collection),
       enable_uma_stats_(enable_uma_stats),
       enable_tracing_(enable_tracing),
       raw_(clock),
       stats_(clock) {}
 
 LoggingImpl::~LoggingImpl() {}
 
 void LoggingImpl::InsertFrameEvent(CastLoggingEvent event,
                                    uint32 rtp_timestamp,
                                    uint8 frame_id) {
+  DCHECK(main_thread_proxy_->RunsTasksOnCurrentThread());
   if (enable_data_collection_) {
     raw_.InsertFrameEvent(event, rtp_timestamp, frame_id);
     stats_.InsertFrameEvent(event, rtp_timestamp, frame_id);
   }
   if (enable_tracing_) {
     std::string event_string = CastLoggingToString(event);
     TRACE_EVENT_INSTANT2(event_string.c_str(), "FE",
         TRACE_EVENT_SCOPE_THREAD, "rtp_timestamp", rtp_timestamp, "frame_id",
         frame_id);
   }
 }
 
 void LoggingImpl::InsertFrameEventWithSize(CastLoggingEvent event,
                                            uint32 rtp_timestamp,
                                            uint8 frame_id,
                                            int frame_size) {
+  DCHECK(main_thread_proxy_->RunsTasksOnCurrentThread());
   if (enable_data_collection_) {
     raw_.InsertFrameEventWithSize(event, rtp_timestamp, frame_id, frame_size);
     stats_.InsertFrameEventWithSize(event, rtp_timestamp, frame_id, frame_size);
   }
   if (enable_uma_stats_) {
     UMA_HISTOGRAM_COUNTS(CastLoggingToString(event), frame_size);
   }
   if (enable_tracing_) {
     std::string event_string = CastLoggingToString(event);
     TRACE_EVENT_INSTANT2(event_string.c_str(), "FES",
         TRACE_EVENT_SCOPE_THREAD, "rtp_timestamp", rtp_timestamp, "frame_size",
         frame_size);
   }
 
 }
 
 void LoggingImpl::InsertFrameEventWithDelay(CastLoggingEvent event,
                                             uint32 rtp_timestamp,
                                             uint8 frame_id,
                                             base::TimeDelta delay) {
+  DCHECK(main_thread_proxy_->RunsTasksOnCurrentThread());
   if (enable_data_collection_) {
     raw_.InsertFrameEventWithDelay(event, rtp_timestamp, frame_id, delay);
     stats_.InsertFrameEventWithDelay(event, rtp_timestamp, frame_id, delay);
   }
   if (enable_uma_stats_) {
     UMA_HISTOGRAM_TIMES(CastLoggingToString(event), delay);
   }
    if (enable_tracing_) {
       std::string event_string = CastLoggingToString(event);
       TRACE_EVENT_INSTANT2(event_string.c_str(), "FED",
           TRACE_EVENT_SCOPE_THREAD, "rtp_timestamp", rtp_timestamp, "delay",
           delay.InMilliseconds());
   }
 }
 
 void LoggingImpl::InsertPacketEvent(CastLoggingEvent event,
                                     uint32 rtp_timestamp,
                                     uint8 frame_id,
                                     uint16 packet_id,
                                     uint16 max_packet_id,
-                                    int size) {
+                                    size_t size) {
+  DCHECK(main_thread_proxy_->RunsTasksOnCurrentThread());
   if (enable_data_collection_) {
     raw_.InsertPacketEvent(event, rtp_timestamp, frame_id, packet_id,
                            max_packet_id, size);
     stats_.InsertPacketEvent(event, rtp_timestamp, frame_id, packet_id,
                              max_packet_id, size);
   }
     if (enable_tracing_) {
       std::string event_string = CastLoggingToString(event);
       TRACE_EVENT_INSTANT2(event_string.c_str(), "PE",
           TRACE_EVENT_SCOPE_THREAD, "rtp_timestamp", rtp_timestamp,
           "packet_id", packet_id);
     }
 }
 
 void LoggingImpl::InsertGenericEvent(CastLoggingEvent event, int value) {
+  DCHECK(main_thread_proxy_->RunsTasksOnCurrentThread());
   if (enable_data_collection_) {
     raw_.InsertGenericEvent(event, value);
     stats_.InsertGenericEvent(event, value);
   }
   if (enable_uma_stats_) {
     UMA_HISTOGRAM_COUNTS(CastLoggingToString(event), value);
   }
   if (enable_tracing_) {
     std::string event_string = CastLoggingToString(event);
     TRACE_EVENT_INSTANT1(event_string.c_str(), "GE",
         TRACE_EVENT_SCOPE_THREAD, "value", value);
   }
 }
 
 
 // should just get the entire class, would be much easier.
 FrameRawMap LoggingImpl::GetFrameRawData() {
+  DCHECK(main_thread_proxy_->RunsTasksOnCurrentThread());
   return raw_.GetFrameData();
 }
 
 PacketRawMap LoggingImpl::GetPacketRawData() {
- return raw_.GetPacketData();
+  DCHECK(main_thread_proxy_->RunsTasksOnCurrentThread());
+  return raw_.GetPacketData();
 }
 
 GenericRawMap LoggingImpl::GetGenericRawData() {
- return raw_.GetGenericData();
+  DCHECK(main_thread_proxy_->RunsTasksOnCurrentThread());
+  return raw_.GetGenericData();
 }
 
 const FrameStatsMap* LoggingImpl::GetFrameStatsData() {
+  DCHECK(main_thread_proxy_->RunsTasksOnCurrentThread());
   // Get stats data.
   const FrameStatsMap* stats = stats_.GetFrameStatsData();
   if (enable_uma_stats_) {
     FrameStatsMap::const_iterator it;
     for (it = stats->begin(); it != stats->end(); ++it) {
       // Check for an active event.
       if (it->second->framerate_fps > 0) {
         std::string event_string = CastLoggingToString(it->first);
         UMA_HISTOGRAM_COUNTS(event_string.append("_framerate_fps"),
                              it->second->framerate_fps);
@@ skipping 14 matching lines @@
                              it->second->min_delay_ms);
         UMA_HISTOGRAM_COUNTS(event_string.append("_max_delay_ms"),
                              it->second->max_delay_ms);
       }
     }
   }
   return stats;
 }
 
 const PacketStatsMap* LoggingImpl::GetPacketStatsData() {
+  DCHECK(main_thread_proxy_->RunsTasksOnCurrentThread());
   // Get stats data.
   const PacketStatsMap* stats = stats_.GetPacketStatsData();
   if (enable_uma_stats_) {
     PacketStatsMap::const_iterator it;
     for (it = stats->begin(); it != stats->end(); ++it) {
       if (it->second > 0) {
         std::string event_string = CastLoggingToString(it->first);
         UMA_HISTOGRAM_COUNTS(event_string.append("_bitrate_kbps"), it->second);
       }
     }
   }
   return stats;
 }
 
 const GenericStatsMap* LoggingImpl::GetGenericStatsData() {
+  DCHECK(main_thread_proxy_->RunsTasksOnCurrentThread());
   // Get stats data.
   const GenericStatsMap* stats = stats_.GetGenericStatsData();
    if (enable_uma_stats_) {
     GenericStatsMap::const_iterator it;
     for (it = stats->begin(); it != stats->end(); ++it) {
       if (it->second > 0) {
         UMA_HISTOGRAM_COUNTS(CastLoggingToString(it->first), it->second);
       }
     }
   }
   return stats;
 }
 
 void LoggingImpl::Reset() {
+  DCHECK(main_thread_proxy_->RunsTasksOnCurrentThread());
   raw_.Reset();
   stats_.Reset();
 }
 
 }  // namespace cast
 }  // namespace media