src/media/cast/logging/stats_event_subscriber.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/cast/logging/stats_event_subscriber.h"
   6
   7 #include "base/logging.h"
   8
   9 namespace media {
  10 namespace cast {
  11
  12 StatsEventSubscriber::StatsEventSubscriber(EventMediaType event_media_type)
  13     : event_media_type_(event_media_type) {}
  14
  15 StatsEventSubscriber::~StatsEventSubscriber() {
  16   DCHECK(thread_checker_.CalledOnValidThread());
  17 }
  18
  19 void StatsEventSubscriber::OnReceiveFrameEvent(const FrameEvent& frame_event) {
  20   DCHECK(thread_checker_.CalledOnValidThread());
  21
  22   CastLoggingEvent type = frame_event.type;
  23   if (GetEventMediaType(type) != event_media_type_)
  24     return;
  25
  26   FrameStatsMap::iterator it = frame_stats_.find(type);
  27   if (it == frame_stats_.end()) {
  28     FrameLogStats stats;
  29     stats.first_event_time = frame_event.timestamp;
  30     stats.last_event_time = frame_event.timestamp;
  31     stats.event_counter = 1;
  32     stats.sum_size = frame_event.size;
  33     stats.min_delay = frame_event.delay_delta;
  34     stats.max_delay = frame_event.delay_delta;
  35     stats.sum_delay = frame_event.delay_delta;
  36     frame_stats_.insert(std::make_pair(type, stats));
  37   } else {
  38     ++(it->second.event_counter);
  39     it->second.last_event_time = frame_event.timestamp;
  40     it->second.sum_size += frame_event.size;
  41     it->second.sum_delay += frame_event.delay_delta;
  42     if (frame_event.delay_delta > it->second.max_delay)
  43       it->second.max_delay = frame_event.delay_delta;
  44     if (frame_event.delay_delta < it->second.min_delay)
  45       it->second.min_delay = frame_event.delay_delta;
  46   }
  47 }
  48
  49 void StatsEventSubscriber::OnReceivePacketEvent(
  50     const PacketEvent& packet_event) {
  51   DCHECK(thread_checker_.CalledOnValidThread());
  52
  53   CastLoggingEvent type = packet_event.type;
  54   if (GetEventMediaType(type) != event_media_type_)
  55     return;
  56
  57   PacketStatsMap::iterator it = packet_stats_.find(type);
  58   if (it == packet_stats_.end()) {
  59     PacketLogStats stats;
  60     stats.first_event_time = packet_event.timestamp;
  61     stats.last_event_time = packet_event.timestamp;
  62     stats.event_counter = 1;
  63     stats.sum_size = packet_event.size;
  64     packet_stats_.insert(std::make_pair(type, stats));
  65   } else {
  66     it->second.last_event_time = packet_event.timestamp;
  67     ++(it->second.event_counter);
  68     it->second.sum_size += packet_event.size;
  69   }
  70 }
  71
  72 void StatsEventSubscriber::OnReceiveGenericEvent(
  73     const GenericEvent& generic_event) {
  74   DCHECK(thread_checker_.CalledOnValidThread());
  75
  76   CastLoggingEvent type = generic_event.type;
  77   if (GetEventMediaType(type) != event_media_type_)
  78     return;
  79
  80   GenericStatsMap::iterator it = generic_stats_.find(type);
  81   if (it == generic_stats_.end()) {
  82     GenericLogStats stats;
  83     stats.first_event_time = generic_event.timestamp;
  84     stats.last_event_time = generic_event.timestamp;
  85     stats.event_counter = 1;
  86     stats.sum = generic_event.value;
  87     stats.sum_squared = generic_event.value * generic_event.value;
  88     stats.min = generic_event.value;
  89     stats.max = generic_event.value;
  90     generic_stats_.insert(std::make_pair(type, stats));
  91   } else {
  92     it->second.last_event_time = generic_event.timestamp;
  93     ++(it->second.event_counter);
  94     it->second.sum += generic_event.value;
  95     it->second.sum_squared += generic_event.value * generic_event.value;
  96     if (it->second.min > generic_event.value) {
  97       it->second.min = generic_event.value;
  98     } else if (it->second.max < generic_event.value) {
  99       it->second.max = generic_event.value;
 100     }
 101   }
 102 }
 103
 104 void StatsEventSubscriber::GetFrameStats(FrameStatsMap* frame_stats_map) const {
 105   DCHECK(thread_checker_.CalledOnValidThread());
 106   DCHECK(frame_stats_map);
 107
 108   frame_stats_map->clear();
 109   frame_stats_map->insert(frame_stats_.begin(), frame_stats_.end());
 110 }
 111
 112 void StatsEventSubscriber::GetPacketStats(
 113     PacketStatsMap* packet_stats_map) const {
 114   DCHECK(thread_checker_.CalledOnValidThread());
 115   DCHECK(packet_stats_map);
 116
 117   packet_stats_map->clear();
 118   packet_stats_map->insert(packet_stats_.begin(), packet_stats_.end());
 119 }
 120
 121 void StatsEventSubscriber::GetGenericStats(
 122     GenericStatsMap* generic_stats_map) const {
 123   DCHECK(thread_checker_.CalledOnValidThread());
 124   DCHECK(generic_stats_map);
 125
 126   generic_stats_map->clear();
 127   generic_stats_map->insert(generic_stats_.begin(), generic_stats_.end());
 128 }
 129
 130 void StatsEventSubscriber::Reset() {
 131   DCHECK(thread_checker_.CalledOnValidThread());
 132
 133   frame_stats_.clear();
 134   packet_stats_.clear();
 135   generic_stats_.clear();
 136 }
 137
 138 }  // namespace cast
 139 }  // namespace media