[Chromoting] More detail video stub information in it2me_standalone_host

remoting/test/fake_connection_event_logger.cc

 // Copyright 2016 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 "remoting/test/fake_connection_event_logger.h"
 
 #include <string>
 
 #include "base/atomicops.h"
 #include "base/callback.h"
@@ skipping 101 matching lines @@
 
 int64_t NoBarrierAtomicInt64::operator*() const {
   AutoLock l(lock_);
   return i_;
 }
 
 #endif  // ifdef ARCH_CPU_64_BITS
 
 class MessageCounter {
  public:
+  MessageCounter(const char* name, const char* unit);
   explicit MessageCounter(const char* name);
 
   int message_count() const { return *count_; }
   int64_t message_size() const { return *size_; }
   int last_message_size() const { return last_size_; }
   double DurationSeconds() const;
   double MessagesPerSecond() const;
   double SizePerSecond() const;
   double AverageMessageSize() const;
   void LogMessage(const ::google::protobuf::MessageLite& message);
-  void DisplayStatistics(std::ostream& os);
+  void LogMessage(int size);
+  virtual void DisplayStatistics(std::ostream& os);
 
  private:
-  std::string name_;
+  const std::string name_;
+  const std::string unit_;
   NoBarrierAtomicInt32 count_;
   NoBarrierAtomicInt64 size_;
   int last_size_ = 0;
   base::Time start_time_;
 
   // Copy or assign the start_time_ of a MessageCounter is senseless.
   DISALLOW_COPY_AND_ASSIGN(MessageCounter);
 };
 
-MessageCounter::MessageCounter(const char* name)
+MessageCounter::MessageCounter(const char* name, const char* unit)
     : name_(name),
+      unit_(unit),
       count_(),
       size_(),
       start_time_(base::Time::Now()) {}
 
+MessageCounter::MessageCounter(const char* name)
+    : MessageCounter(name, "bytes") {}
+
 double MessageCounter::DurationSeconds() const {
   return (base::Time::Now() - start_time_).InSecondsF();
 }
 
 double MessageCounter::MessagesPerSecond() const {
   return static_cast<double>(message_count()) / DurationSeconds();
 }
 double MessageCounter::SizePerSecond() const {
   return static_cast<double>(message_size()) / DurationSeconds();
 }
 
 double MessageCounter::AverageMessageSize() const {
   return static_cast<double>(message_size()) / message_count();
 }
 
 void MessageCounter::LogMessage(
     const ::google::protobuf::MessageLite& message) {
+  LogMessage(message.ByteSize());
+}
+
+void MessageCounter::LogMessage(int size) {
   count_++;
-  last_size_ = message.ByteSize();
-  size_ += message.ByteSize();
+  last_size_ = size;
+  size_ += size;
 }
 
 void MessageCounter::DisplayStatistics(std::ostream& os) {
-  os << name_
-     << ": "
-     << message_size()
-     << " bytes in "
-     << message_count()
-     << " packages, last package "
-     << last_message_size()
-     << " bytes, "
-     << AverageMessageSize()
-     << " bytes/package, "
-     << MessagesPerSecond()
-     << " packages/sec, "
-     << SizePerSecond()
-     << " bytes/sec"
-     << std::endl;
+  os << name_ << ": " << message_size() << " " << unit_ << " in "
+     << message_count() << " packages, last package " << last_message_size()
+     << " " << unit_ << ", " << AverageMessageSize() << " " << unit_
+     << "/package, " << MessagesPerSecond() << " packages/sec, "
+     << SizePerSecond() << " " << unit_ << "/sec" << std::endl;
 }
 
 }  // namespace
 
 // Analyzes messages from DeliverHostMessage function.
 class FakeConnectionEventLogger::CounterClientStub
     : public protocol::ClientStub, public MessageCounter {
  public:
   CounterClientStub();
 
@@ skipping 61 matching lines @@
   }
   done.Run();
 }
 
 // Analyzes messages from ProcessVideoPacket function.
 class FakeConnectionEventLogger::CounterVideoStub
     : public protocol::VideoStub, public MessageCounter {
  public:
   CounterVideoStub(protocol::FakeConnectionToClient* connection);
 
+  void DisplayStatistics(std::ostream& os) override;
+
  private:
   void ProcessVideoPacket(std::unique_ptr<VideoPacket> video_packet,
                           const base::Closure& done) override;
 
   protocol::FakeConnectionToClient* connection_ = nullptr;
+  MessageCounter video_data_;
+  MessageCounter capture_time_;
+  MessageCounter encode_time_;
 };
 
 FakeConnectionEventLogger::CounterVideoStub::CounterVideoStub(
     protocol::FakeConnectionToClient* connection)
     : MessageCounter("video"),
-      connection_(connection) {}
+      connection_(connection),
+      video_data_("video-data"),
+      capture_time_("capture-time", "ms"),
+      encode_time_("encode-time", "ms") {}
+
+void FakeConnectionEventLogger::CounterVideoStub::DisplayStatistics(
+    std::ostream& os) {
+  MessageCounter::DisplayStatistics(os);
+  video_data_.DisplayStatistics(os);
+  capture_time_.DisplayStatistics(os);
+  encode_time_.DisplayStatistics(os);
+}
 
 void FakeConnectionEventLogger::CounterVideoStub::ProcessVideoPacket(
     std::unique_ptr<VideoPacket> video_packet,
     const base::Closure& done) {
   if (video_packet && video_packet->has_capture_overhead_time_ms()) {
     // Not a keepalive packet.
     if (connection_ &&
         connection_->video_feedback_stub()) {
       std::unique_ptr<VideoAck> ack(new VideoAck());
       ack->set_frame_id(video_packet->frame_id());
       connection_->video_feedback_stub()->ProcessVideoAck(std::move(ack));
     }
     LogMessage(*video_packet);
+    video_data_.LogMessage(video_packet->data().size());
+    capture_time_.LogMessage(video_packet->capture_time_ms());
+    encode_time_.LogMessage(video_packet->encode_time_ms());
   }
   done.Run();
 }
 
 FakeConnectionEventLogger::FakeConnectionEventLogger(
     protocol::FakeConnectionToClient* connection)
   : client_stub_(new CounterClientStub()),
     host_stub_(new CounterHostStub()),
     audio_stub_(new CounterAudioStub()),
     video_stub_(new CounterVideoStub(connection)) {}
@@ skipping 20 matching lines @@
                          const FakeConnectionEventLogger& logger) {
   logger.audio_stub_->DisplayStatistics(os);
   logger.video_stub_->DisplayStatistics(os);
   logger.client_stub_->DisplayStatistics(os);
   logger.host_stub_->DisplayStatistics(os);
   return os;
 }
 
 }  // namespace test
 }  // namespace remoting