More cleanups in FrameStats

remoting/client/plugin/pepper_video_renderer_3d.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/plugin/pepper_video_renderer_3d.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 15 matching lines @@
 // The implementation here requires that the decoder allocates at least 3
 // pictures. PPB_VideoDecoder didn't support this parameter prior to
 // 1.1, so we have to pass 0 for backwards compatibility with older versions of
 // the browser. Currently all API implementations allocate more than 3 buffers
 // by default.
 const uint32_t kMinimumPictureCount = 3;
 
 class PepperVideoRenderer3D::FrameTracker {
  public:
   FrameTracker(std::unique_ptr<VideoPacket> packet,
-               protocol::PerformanceTracker* perf_tracker,
+               protocol::FrameStatsConsumer* stats_consumer,
                const base::Closure& done)
-      : packet_(std::move(packet)), perf_tracker_(perf_tracker), done_(done) {
-    stats_ = protocol::FrameStats::GetForVideoPacket(*packet_);
+      : packet_(std::move(packet)),
+        stats_consumer_(stats_consumer),
+        done_(done) {
+    stats_.host_stats = protocol::HostFrameStats::GetForVideoPacket(*packet_);
+    stats_.client_stats.time_received = base::TimeTicks::Now();
   }
 
   ~FrameTracker() {
-    if (perf_tracker_)
-      perf_tracker_->RecordVideoFrameStats(stats_);
+    if (stats_consumer_)
+      stats_consumer_->OnVideoFrameStats(stats_);
     if (!done_.is_null())
       done_.Run();
   }
 
-  void OnDecoded() { stats_.time_decoded = base::TimeTicks::Now(); }
-  void OnRendered() { stats_.time_rendered = base::TimeTicks::Now(); }
+  void OnDecoded() {
+    stats_.client_stats.time_decoded = base::TimeTicks::Now();
+  }
+  void OnRendered() {
+    stats_.client_stats.time_rendered = base::TimeTicks::Now();
+  }
 
   VideoPacket* packet() { return packet_.get(); }
 
  private:
   std::unique_ptr<VideoPacket> packet_;
-  protocol::PerformanceTracker* perf_tracker_;
+  protocol::FrameStatsConsumer* stats_consumer_;
   protocol::FrameStats stats_;
   base::Closure done_;
 };
 
 class PepperVideoRenderer3D::Picture {
  public:
   Picture(pp::VideoDecoder* decoder, PP_VideoPicture picture)
       : decoder_(decoder), picture_(picture) {}
   ~Picture() { decoder_->RecyclePicture(picture_); }
 
@@ skipping 30 matching lines @@
   force_repaint_ = true;
   PaintIfNeeded();
 }
 
 void PepperVideoRenderer3D::EnableDebugDirtyRegion(bool enable) {
   debug_dirty_region_ = enable;
 }
 
 bool PepperVideoRenderer3D::Initialize(
     const ClientContext& context,
-    protocol::PerformanceTracker* perf_tracker) {
-  perf_tracker_ = perf_tracker;
+    protocol::FrameStatsConsumer* stats_consumer) {
+  stats_consumer_ = stats_consumer;
 
   const int32_t context_attributes[] = {
       PP_GRAPHICS3DATTRIB_ALPHA_SIZE,     8,
       PP_GRAPHICS3DATTRIB_BLUE_SIZE,      8,
       PP_GRAPHICS3DATTRIB_GREEN_SIZE,     8,
       PP_GRAPHICS3DATTRIB_RED_SIZE,       8,
       PP_GRAPHICS3DATTRIB_DEPTH_SIZE,     0,
       PP_GRAPHICS3DATTRIB_STENCIL_SIZE,   0,
       PP_GRAPHICS3DATTRIB_SAMPLES,        0,
       PP_GRAPHICS3DATTRIB_SAMPLE_BUFFERS, 0,
@@ skipping 72 matching lines @@
   return this;
 }
 
 protocol::FrameConsumer* PepperVideoRenderer3D::GetFrameConsumer() {
   // GetFrameConsumer() is used only for WebRTC-based connections which are not
   // supported by the plugin.
   NOTREACHED();
   return nullptr;
 }
 
+protocol::FrameStatsConsumer* PepperVideoRenderer3D::GetFrameStatsConsumer() {
+  return stats_consumer_;
+}
+
 void PepperVideoRenderer3D::ProcessVideoPacket(
     std::unique_ptr<VideoPacket> packet,
     const base::Closure& done) {
   VideoPacket* packet_ptr = packet.get();
   std::unique_ptr<FrameTracker> frame_tracker(
-      new FrameTracker(std::move(packet), perf_tracker_, done));
+      new FrameTracker(std::move(packet), stats_consumer_, done));
 
   // Don't need to do anything if the packet is empty. Host sends empty video
   // packets when the screen is not changing.
   if (!packet_ptr->data().size())
     return;
 
   if (!frame_received_) {
     event_handler_->OnVideoFirstFrameReceived();
     frame_received_ = true;
   }
@@ skipping 302 matching lines @@
   gles2_if_->AttachShader(graphics_.pp_resource(), shader_program_, shader);
   gles2_if_->DeleteShader(graphics_.pp_resource(), shader);
 }
 
 void PepperVideoRenderer3D::CheckGLError() {
   GLenum error = gles2_if_->GetError(graphics_.pp_resource());
   CHECK_EQ(error, static_cast<GLenum>(GL_NO_ERROR)) << "GL error: " << error;
 }
 
 }  // namespace remoting