More cleanups in FrameStats

remoting/client/software_video_renderer.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 "remoting/client/software_video_renderer.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 28 matching lines @@
     std::unique_ptr<VideoPacket> packet,
     std::unique_ptr<webrtc::DesktopFrame> frame) {
   if (!decoder->DecodePacket(*packet, frame.get()))
     frame.reset();
   return frame;
 }
 
 }  // namespace
 
 SoftwareVideoRenderer::SoftwareVideoRenderer(protocol::FrameConsumer* consumer)
-    : consumer_(consumer),
-      weak_factory_(this) {
+    : consumer_(consumer), weak_factory_(this) {
   thread_checker_.DetachFromThread();
 }
 
 SoftwareVideoRenderer::SoftwareVideoRenderer(
     scoped_refptr<base::SingleThreadTaskRunner> decode_task_runner,
     protocol::FrameConsumer* consumer,
-    protocol::PerformanceTracker* perf_tracker)
+    protocol::FrameStatsConsumer* stats_consumer)
     : decode_task_runner_(decode_task_runner),
       consumer_(consumer),
-      perf_tracker_(perf_tracker),
+      stats_consumer_(stats_consumer),
       weak_factory_(this) {}
 
 SoftwareVideoRenderer::~SoftwareVideoRenderer() {
   if (decoder_)
     decode_task_runner_->DeleteSoon(FROM_HERE, decoder_.release());
 }
 
 bool SoftwareVideoRenderer::Initialize(
     const ClientContext& client_context,
-    protocol::PerformanceTracker* perf_tracker) {
+    protocol::FrameStatsConsumer* stats_consumer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   decode_task_runner_ = client_context.decode_task_runner();
-  perf_tracker_ = perf_tracker;
+  stats_consumer_ = stats_consumer;
   return true;
 }
 
 void SoftwareVideoRenderer::OnSessionConfig(
     const protocol::SessionConfig& config) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Initialize decoder based on the selected codec.
   ChannelConfig::Codec codec = config.video_config().codec;
   if (codec == ChannelConfig::CODEC_VERBATIM) {
@@ skipping 14 matching lines @@
 
 protocol::VideoStub* SoftwareVideoRenderer::GetVideoStub() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return this;
 }
 
 protocol::FrameConsumer* SoftwareVideoRenderer::GetFrameConsumer() {
   return consumer_;
 }
 
+protocol::FrameStatsConsumer* SoftwareVideoRenderer::GetFrameStatsConsumer() {
+  return stats_consumer_;
+}
+
 void SoftwareVideoRenderer::ProcessVideoPacket(
     std::unique_ptr<VideoPacket> packet,
     const base::Closure& done) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   base::ScopedClosureRunner done_runner(done);
 
-  std::unique_ptr<protocol::FrameStats> frame_stats(new protocol::FrameStats(
-      protocol::FrameStats::GetForVideoPacket(*packet)));
+  std::unique_ptr<protocol::FrameStats> frame_stats(new protocol::FrameStats());
+  frame_stats->host_stats =
+      protocol::HostFrameStats::GetForVideoPacket(*packet);
+  frame_stats->client_stats.time_received = base::TimeTicks::Now();
 
   // If the video packet is empty then there is nothing to decode. Empty packets
   // are used to maintain activity on the network. Stats for such packets still
   // need to be reported.
   if (!packet->has_data() || packet->data().size() == 0) {
-    if (perf_tracker_)
-      perf_tracker_->RecordVideoFrameStats(*frame_stats);
+    if (stats_consumer_)
+      stats_consumer_->OnVideoFrameStats(*frame_stats);
     return;
   }
 
   if (packet->format().has_screen_width() &&
       packet->format().has_screen_height()) {
     source_size_.set(packet->format().screen_width(),
                      packet->format().screen_height());
   }
 
   if (packet->format().has_x_dpi() && packet->format().has_y_dpi()) {
@@ skipping 21 matching lines @@
                  weak_factory_.GetWeakPtr(), base::Passed(&frame_stats),
                  done_runner.Release()));
 }
 
 void SoftwareVideoRenderer::RenderFrame(
     std::unique_ptr<protocol::FrameStats> stats,
     const base::Closure& done,
     std::unique_ptr<webrtc::DesktopFrame> frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  stats->time_decoded = base::TimeTicks::Now();
-
+  stats->client_stats.time_decoded = base::TimeTicks::Now();
   if (!frame) {
     if (!done.is_null())
       done.Run();
     return;
   }
 
   consumer_->DrawFrame(
       std::move(frame),
       base::Bind(&SoftwareVideoRenderer::OnFrameRendered,
                  weak_factory_.GetWeakPtr(), base::Passed(&stats), done));
 }
 
 void SoftwareVideoRenderer::OnFrameRendered(
     std::unique_ptr<protocol::FrameStats> stats,
     const base::Closure& done) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  stats->time_rendered = base::TimeTicks::Now();
-  if (perf_tracker_)
-    perf_tracker_->RecordVideoFrameStats(*stats);
+  stats->client_stats.time_rendered = base::TimeTicks::Now();
+  if (stats_consumer_)
+    stats_consumer_->OnVideoFrameStats(*stats);
 
   if (!done.is_null())
     done.Run();
 }
 
 }  // namespace remoting