Preliminary change for new rtc rendering algorithm

media/base/video_frame.h

 // Copyright (c) 2012 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 MEDIA_BASE_VIDEO_FRAME_H_
 #define MEDIA_BASE_VIDEO_FRAME_H_
 
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 358 matching lines @@
   void set_timestamp(base::TimeDelta timestamp) {
     timestamp_ = timestamp;
   }
 
   // It uses |client| to insert a new sync point and potentially waits on a
   // older sync point. The final sync point will be used to release this
   // VideoFrame.
   // This method is thread safe. Both blink and compositor threads can call it.
   void UpdateReleaseSyncPoint(SyncPointClient* client);
 
+  // Record the ideal time instant to render this frame.

[DaleCurtis, 2015/07/30 05:55:24]

VideoFrame is already in a crufty situation so we want to avoid adding any more
one off fields like this. Can you deliver the render time through another
mechanism? Either by set_timestamp(render_time - base::TimeTicks()) or via a new
VideoFrameMetadata field?

[qiangchen, 2015/07/30 17:40:26]

I'll consider using VideoFrameMetadata. Should I also remove the methods, and
let the caller to retrieve information from metadata?

P.S.

Now the timestamp of media::VideoFrame is essentially the RTP timestamp/90000. 
While the render_time calculated in Jitter Buffer is derived by an equation
fitting not from a static formula, which is necessary and powerful as it can
kill the clock rate inconsistency. 

Thus we should use render_time as the guidance of frame selection. But I'm not
sure if we simply set timestamp to be render_time, the loss of the raw timestamp
would affect something else.

[DaleCurtis, 2015/07/30 17:52:33]

Before you go the metadata approach, I would see if you can just overwrite the
existing timestamp() field at this point; it shouldn't be too hard to
investigate the few call sites within WebRTC that use timestamp().

Definitely we don't want a new render_time() and set_render_time() on VideoFrame
though; either you'll need to add a new VideoFrameMetadata field or stuff the
value into the timestamp field (most ideal).

+  base::TimeTicks render_time();
+  void set_render_time(base::TimeTicks render_time);
+
  private:
   friend class base::RefCountedThreadSafe<VideoFrame>;
 
   static scoped_refptr<VideoFrame> WrapExternalStorage(
       VideoPixelFormat format,
       StorageType storage_type,
       const gfx::Size& coded_size,
       const gfx::Rect& visible_rect,
       const gfx::Size& natural_size,
       uint8* data,
@@ skipping 82 matching lines @@
 
   std::vector<base::Closure> done_callbacks_;
 
   base::TimeDelta timestamp_;
 
   base::Lock release_sync_point_lock_;
   uint32 release_sync_point_;
 
   VideoFrameMetadata metadata_;
 
+  base::TimeTicks render_time_;
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(VideoFrame);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_VIDEO_FRAME_H_