Cast channel logging: log additional statistics.

extensions/browser/api/cast_channel/logger.cc

 // Copyright 2014 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 "extensions/browser/api/cast_channel/logger.h"
 
 #include "base/strings/string_util.h"
 #include "base/time/tick_clock.h"
 #include "extensions/browser/api/cast_channel/cast_auth_util.h"
 #include "extensions/browser/api/cast_channel/logger_util.h"
@@ skipping 90 matching lines @@
 }  // namespace
 
 Logger::AggregatedSocketEventLog::AggregatedSocketEventLog() {
 }
 
 Logger::AggregatedSocketEventLog::~AggregatedSocketEventLog() {
 }
 
 Logger::Logger(scoped_ptr<base::TickClock> clock,
                base::TimeTicks unix_epoch_time_ticks)
-    : clock_(clock.Pass()),
-      unix_epoch_time_ticks_(unix_epoch_time_ticks),
-      num_evicted_aggregated_socket_events_(0),
-      num_evicted_socket_events_(0) {
+    : clock_(clock.Pass()), unix_epoch_time_ticks_(unix_epoch_time_ticks) {
   DCHECK(clock_);
 
   // Logger may not be necessarily be created on the IO thread, but logging
   // happens exclusively there.
   thread_checker_.DetachFromThread();
 }
 
 Logger::~Logger() {
 }
 
 void Logger::LogNewSocketEvent(const CastSocket& cast_socket) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   int channel_id = cast_socket.id();
   SocketEvent event = CreateEvent(proto::CAST_SOCKET_CREATED);
-  LogSocketEvent(channel_id, event);
+  AggregatedSocketEvent& aggregated_socket_event =
+      LogSocketEvent(channel_id, event);
 
-  AggregatedSocketEvent& aggregated_socket_event =
-      aggregated_socket_events_.find(channel_id)
-          ->second->aggregated_socket_event;
   const net::IPAddressNumber& ip = cast_socket.ip_endpoint().address();
   aggregated_socket_event.set_endpoint_id(ip.back());
   aggregated_socket_event.set_channel_auth_type(cast_socket.channel_auth() ==
                                                         CHANNEL_AUTH_TYPE_SSL
                                                     ? proto::SSL
                                                     : proto::SSL_VERIFIED);
 }
 
 void Logger::LogSocketEvent(int channel_id, EventType event_type) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 14 matching lines @@
 }
 
 void Logger::LogSocketEventWithRv(int channel_id,
                                   EventType event_type,
                                   int rv) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   SocketEvent event = CreateEvent(event_type);
   event.set_net_return_value(rv);
 
-  LogSocketEvent(channel_id, event);
+  AggregatedSocketEvent& aggregated_socket_event =
+      LogSocketEvent(channel_id, event);
+
+  if ((event_type == proto::SOCKET_READ || event_type == proto::SOCKET_WRITE) &&
+      rv > 0) {
+    if (event_type == proto::SOCKET_READ) {
+      aggregated_socket_event.set_bytes_read(
+          aggregated_socket_event.bytes_read() + rv);
+    } else {
+      aggregated_socket_event.set_bytes_written(
+          aggregated_socket_event.bytes_written() + rv);
+    }
+  }
 }
 
 void Logger::LogSocketReadyState(int channel_id, proto::ReadyState new_state) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   SocketEvent event = CreateEvent(proto::READY_STATE_CHANGED);
   event.set_ready_state(new_state);
 
   LogSocketEvent(channel_id, event);
 }
@@ skipping 63 matching lines @@
 }
 
 SocketEvent Logger::CreateEvent(EventType event_type) {
   SocketEvent event;
   event.set_type(event_type);
   event.set_timestamp_micros(clock_->NowTicks().ToInternalValue() -
                              unix_epoch_time_ticks_.ToInternalValue());
   return event;
 }
 
-void Logger::LogSocketEvent(int channel_id, const SocketEvent& socket_event) {
+AggregatedSocketEvent& Logger::LogSocketEvent(int channel_id,
+                                              const SocketEvent& socket_event) {
   AggregatedSocketEventLogMap::iterator it =
       aggregated_socket_events_.find(channel_id);
   if (it == aggregated_socket_events_.end()) {
     if (aggregated_socket_events_.size() >= kMaxSocketsToLog) {
       AggregatedSocketEventLogMap::iterator erase_it =
           aggregated_socket_events_.begin();
 
-      num_evicted_aggregated_socket_events_++;
-      num_evicted_socket_events_ += erase_it->second->socket_events.size();
+      log_.set_num_evicted_aggregated_socket_events(
+          log_.num_evicted_aggregated_socket_events() + 1);
+      log_.set_num_evicted_socket_events(
+          log_.num_evicted_socket_events() +
+          erase_it->second->socket_events.size());
 
       aggregated_socket_events_.erase(erase_it);
     }
 
     it = aggregated_socket_events_
              .insert(std::make_pair(
                  channel_id, make_linked_ptr(new AggregatedSocketEventLog)))
              .first;
     it->second->aggregated_socket_event.set_id(channel_id);
   }
 
   std::deque<proto::SocketEvent>& socket_events = it->second->socket_events;
   if (socket_events.size() >= kMaxEventsPerSocket) {
     socket_events.pop_front();
-    num_evicted_socket_events_++;
+    log_.set_num_evicted_socket_events(log_.num_evicted_socket_events() + 1);
   }
 
   socket_events.push_back(socket_event);
 
   it->second->last_errors.event_type = socket_event.type();
   if (socket_event.has_net_return_value()) {
     it->second->last_errors.net_return_value = socket_event.net_return_value();
   }
   if (socket_event.has_challenge_reply_error_type()) {
     it->second->last_errors.challenge_reply_error_type =
         socket_event.challenge_reply_error_type();
   }
   if (socket_event.has_nss_error_code())
     it->second->last_errors.nss_error_code = socket_event.nss_error_code();
+
+  return it->second->aggregated_socket_event;
 }
 
 scoped_ptr<char[]> Logger::GetLogs(size_t* length) const {
   *length = 0;
 
   Log log;
-  log.set_num_evicted_aggregated_socket_events(
-      num_evicted_aggregated_socket_events_);
-  log.set_num_evicted_socket_events(num_evicted_socket_events_);
+  // Copy "global" values from |log_|. Don't use |log_| directly since this
+  // function is const.
+  log.CopyFrom(log_);
 
   for (AggregatedSocketEventLogMap::const_iterator it =
            aggregated_socket_events_.begin();
        it != aggregated_socket_events_.end();
        ++it) {
     AggregatedSocketEvent* new_aggregated_socket_event =
         log.add_aggregated_socket_event();
     new_aggregated_socket_event->CopyFrom(it->second->aggregated_socket_event);
 
     const std::deque<SocketEvent>& socket_events = it->second->socket_events;
@@ skipping 11 matching lines @@
   if (!log.SerializeToString(&serialized)) {
     VLOG(2) << "Failed to serialized proto to string.";
     return scoped_ptr<char[]>();
   }
 
   return Compress(serialized, length);
 }
 
 void Logger::Reset() {
   aggregated_socket_events_.clear();
-  num_evicted_aggregated_socket_events_ = 0;
-  num_evicted_socket_events_ = 0;
+  log_.Clear();
 }
 
 LastErrors Logger::GetLastErrors(int channel_id) const {
   AggregatedSocketEventLogMap::const_iterator it =
       aggregated_socket_events_.find(channel_id);
   if (it != aggregated_socket_events_.end()) {
     return it->second->last_errors;
   } else {
     return LastErrors();
   }
 }
 
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions