Rework PerformanceTracker to make it usable with WebRTC

remoting/client/plugin/pepper_video_renderer_3d.h

 // 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.
 
 #ifndef REMOTING_CLIENT_PLUGIN_PEPPER_VIDEO_RENDERER_3D_H_
 #define REMOTING_CLIENT_PLUGIN_PEPPER_VIDEO_RENDERER_3D_H_
 
 #include <stdint.h>
 
-#include <deque>
+#include <list>
 #include <memory>
 #include <string>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "ppapi/cpp/graphics_3d.h"
 #include "ppapi/cpp/instance_handle.h"
 #include "ppapi/cpp/video_decoder.h"
 #include "ppapi/utility/completion_callback_factory.h"
 #include "remoting/client/plugin/pepper_video_renderer.h"
@@ skipping 23 matching lines @@
   // VideoRenderer interface.
   void OnSessionConfig(const protocol::SessionConfig& config) override;
   protocol::VideoStub* GetVideoStub() override;
   protocol::FrameConsumer* GetFrameConsumer() override;
 
   // protocol::VideoStub interface.
   void ProcessVideoPacket(std::unique_ptr<VideoPacket> packet,
                           const base::Closure& done) override;
 
  private:
-  class PendingPacket;
+  // Class responsible for tracking state of a frame until it's rendered.
+  class FrameTracker;
+
   class Picture;
 
   // Callback for pp::VideoDecoder::Initialize().
   void OnInitialized(int32_t result);
 
-  // Passes one picture from |pending_packets_| to the |video_decoder_|.
+  // Passes one picture from |pending_frames_| to the |video_decoder_|.
   void DecodeNextPacket();
 
   // Callback for pp::VideoDecoder::Decode().
   void OnDecodeDone(int32_t result);
 
   // Fetches next picture from the |video_decoder_|.
   void GetNextPicture();
 
   // Callback for pp::VideoDecoder::GetPicture().
   void OnPictureReady(int32_t result, PP_VideoPicture picture);
@@ skipping 27 matching lines @@
 
   webrtc::DesktopSize frame_size_;
 
   webrtc::DesktopSize view_size_;
 
   bool initialization_finished_ = false;
   bool decode_pending_ = false;
   bool get_picture_pending_ = false;
   bool paint_pending_ = false;
 
   // Queue of packets that that have been received, but haven't been passed to

[Jamie, 2016/06/24 23:53:21]

s/Queue/List/ (or just remove "List of" from this and the next comment).

[Sergey Ulanov, 2016/06/25 05:34:03]

Done.

   // the decoder yet.
-  std::deque<PendingPacket*> pending_packets_;
+  std::list<std::unique_ptr<FrameTracker>> pending_frames_;
 
-  // The current picture shown on the screen or being rendered. Must be deleted
-  // before |video_decoder_|.
-  std::unique_ptr<Picture> current_picture_;
+  // List of frames that have been decoded but for which we haven't received the
+  // pictures yet.
+  std::list<std::unique_ptr<FrameTracker>> decoded_frames_;
 
   // The next picture to be rendered. PaintIfNeeded() will copy it to
   // |current_picture_| and render it after that. Must be deleted
   // before |video_decoder_|.
   std::unique_ptr<Picture> next_picture_;
 
+  // FrameTracker instances in |next_picture_|.
+  std::list<std::unique_ptr<FrameTracker>> next_picture_frames_;
+
+  // The current picture shown on the screen or being rendered. Must be deleted
+  // before |video_decoder_|.
+  std::unique_ptr<Picture> current_picture_;
+
+  // FrameTrackers for frames in |current_picture_|. The queue is emptied once
+  // the |current_picture_| is rendered.
+  std::list<std::unique_ptr<FrameTracker>> current_picture_frames_;
+
   // Set to true if the screen has been resized and needs to be repainted.
   bool force_repaint_ = false;
 
   // The texture type for which |shader_program| was initialized. Can be either
   // 0, GL_TEXTURE_2D, GL_TEXTURE_RECTANGLE_ARB or GL_TEXTURE_EXTERNAL_OES. 0
   // indicates that |shader_program_| hasn't been intialized.
   uint32_t current_shader_program_texture_target_ = 0;
 
   // Shader program ID.
   unsigned int shader_program_ = 0;
 
   // Location of the scale value to be passed to the |shader_program_|.
   int shader_texcoord_scale_location_ = 0;
 
   // True if the renderer has received frame from the host.
   bool frame_received_ = false;
 
   // True if dirty regions are to be sent to |event_handler_| for debugging.
   bool debug_dirty_region_ = false;
 
   pp::CompletionCallbackFactory<PepperVideoRenderer3D> callback_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PepperVideoRenderer3D);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_CLIENT_PLUGIN_PEPPER_VIDEO_RENDERER_3D_H_