Rename sequence_number to timestamp.

remoting/host/video_scheduler.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 REMOTING_HOST_VIDEO_SCHEDULER_H_
 #define REMOTING_HOST_VIDEO_SCHEDULER_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 96 matching lines @@
   void Start();
 
   // Stop scheduling frame captures. This object cannot be re-used once
   // it has been stopped.
   void Stop();
 
   // Pauses or resumes scheduling of frame captures.  Pausing/resuming captures
   // only affects capture scheduling and does not stop/start the capturer.
   void Pause(bool pause);
 
-  // Updates the sequence number embedded in VideoPackets.
-  // Sequence numbers are used for performance measurements.
-  void UpdateSequenceNumber(int64 sequence_number);
+  // Updates event timestamp from the last event received from the client. This
+  // value is sent back to the client for roundtrip latency estimates.
+  void SetLastEventTimestamp(int64 last_event_timestamp);

[Wez, 2015/01/07 23:56:19]

s/Last/Latest

Or rename this to OnEventTimestamp()?

[Sergey Ulanov, 2015/01/08 17:40:26]

Done.

 
   // Sets whether the video encoder should be requested to encode losslessly,
   // or to use a lossless color space (typically requiring higher bandwidth).
   void SetLosslessEncode(bool want_lossless);
   void SetLosslessColor(bool want_lossless);
 
  private:
   friend class base::RefCountedThreadSafe<VideoScheduler>;
   ~VideoScheduler() override;
 
@@ skipping 29 matching lines @@
   // Callback for |video_stub_| called after a keep-alive packet is sent.
   void OnKeepAlivePacketSent();
 
   // Send updated cursor shape to client.
   void SendCursorShape(scoped_ptr<protocol::CursorShapeInfo> cursor_shape);
 
   // Encoder thread -----------------------------------------------------------
 
   // Encode a frame, passing generated VideoPackets to SendVideoPacket().
   void EncodeFrame(scoped_ptr<webrtc::DesktopFrame> frame,
-                   int64 sequence_number,
+                   int64 last_event_timestamp,
                    base::TimeTicks timestamp);
 
-  void EncodedDataAvailableCallback(int64 sequence_number,
+  void EncodedDataAvailableCallback(int64 last_event_timestamp,
                                     scoped_ptr<VideoPacket> packet);
 
   // Task runners used by this class.
   scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
 
   // Used to capture frames. Always accessed on the capture thread.
   scoped_ptr<webrtc::DesktopCapturer> capturer_;
 
@@ skipping 23 matching lines @@
   // Set when the capturer is capturing a frame.
   bool capture_pending_;
 
   // True if the previous scheduled capture was skipped.
   bool did_skip_frame_;
 
   // True if capture of video frames is paused.
   bool is_paused_;
 
   // Number updated by the caller to trace performance.
-  int64 sequence_number_;
+  int64 last_event_timestamp_;
 
   // An object to schedule capturing.
   CaptureScheduler scheduler_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoScheduler);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_VIDEO_SCHEDULER_H_