Rename sequence_number to timestamp.

remoting/host/video_scheduler.cc

 // 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.
 
 #include "remoting/host/video_scheduler.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 46 matching lines @@
       network_task_runner_(network_task_runner),
       capturer_(capturer.Pass()),
       mouse_cursor_monitor_(mouse_cursor_monitor.Pass()),
       encoder_(encoder.Pass()),
       cursor_stub_(cursor_stub),
       video_stub_(video_stub),
       pending_frames_(0),
       capture_pending_(false),
       did_skip_frame_(false),
       is_paused_(false),
-      sequence_number_(0) {
+      latest_event_timestamp_(0) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   DCHECK(capturer_);
   DCHECK(mouse_cursor_monitor_);
   DCHECK(encoder_);
   DCHECK(cursor_stub_);
   DCHECK(video_stub_);
 }
 
 // Public methods --------------------------------------------------------------
 
@@ skipping 11 matching lines @@
   if (owned_frame) {
     scheduler_.RecordCaptureTime(
         base::TimeDelta::FromMilliseconds(owned_frame->capture_time_ms()));
   }
 
   // Even when |frame| is NULL we still need to post it to the encode thread
   // to make sure frames are freed in the same order they are received and
   // that we don't start capturing frame n+2 before frame n is freed.
   encode_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::EncodeFrame, this,
-                            base::Passed(&owned_frame), sequence_number_,
+                            base::Passed(&owned_frame), latest_event_timestamp_,
                             base::TimeTicks::Now()));
 
   // If a frame was skipped, try to capture it again.
   if (did_skip_frame_) {
     capture_task_runner_->PostTask(
         FROM_HERE, base::Bind(&VideoScheduler::CaptureNextFrame, this));
   }
 }
 
 void VideoScheduler::OnMouseCursor(webrtc::MouseCursor* cursor) {
@@ skipping 64 matching lines @@
 
   if (is_paused_ != pause) {
     is_paused_ = pause;
 
     // Restart captures if we're resuming and there are none scheduled.
     if (!is_paused_ && capture_timer_ && !capture_timer_->IsRunning())
       CaptureNextFrame();
   }
 }
 
-void VideoScheduler::UpdateSequenceNumber(int64 sequence_number) {
+void VideoScheduler::SetLatestEventTimestamp(int64 latest_event_timestamp) {
   if (!capture_task_runner_->BelongsToCurrentThread()) {
     DCHECK(network_task_runner_->BelongsToCurrentThread());
     capture_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&VideoScheduler::UpdateSequenceNumber,
-                              this, sequence_number));
+        FROM_HERE, base::Bind(&VideoScheduler::SetLatestEventTimestamp,
+                              this, latest_event_timestamp));
     return;
   }
 
-  sequence_number_ = sequence_number;
+  latest_event_timestamp_ = latest_event_timestamp;
 }
 
 void VideoScheduler::SetLosslessEncode(bool want_lossless) {
   if (!encode_task_runner_->BelongsToCurrentThread()) {
     DCHECK(network_task_runner_->BelongsToCurrentThread());
     encode_task_runner_->PostTask(
         FROM_HERE, base::Bind(&VideoScheduler::SetLosslessEncode,
                               this, want_lossless));
     return;
   }
@@ skipping 158 matching lines @@
   if (!cursor_stub_)
     return;
 
   cursor_stub_->SetCursorShape(*cursor_shape);
 }
 
 // Encoder thread --------------------------------------------------------------
 
 void VideoScheduler::EncodeFrame(
     scoped_ptr<webrtc::DesktopFrame> frame,
-    int64 sequence_number,
+    int64 latest_event_timestamp,
     base::TimeTicks timestamp) {
   DCHECK(encode_task_runner_->BelongsToCurrentThread());
 
   // If there is nothing to encode then send an empty packet.
   if (!frame || frame->updated_region().is_empty()) {
     capture_task_runner_->DeleteSoon(FROM_HERE, frame.release());
     scoped_ptr<VideoPacket> packet(new VideoPacket());
-    packet->set_client_sequence_number(sequence_number);
+    packet->set_latest_event_timestamp(latest_event_timestamp);
     network_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(
             &VideoScheduler::SendVideoPacket, this, base::Passed(&packet)));
     return;
   }
 
   scoped_ptr<VideoPacket> packet = encoder_->Encode(*frame);
-  packet->set_client_sequence_number(sequence_number);
+  packet->set_latest_event_timestamp(latest_event_timestamp);
 
   if (g_enable_timestamps) {
     packet->set_timestamp(timestamp.ToInternalValue());
   }
 
   // Destroy the frame before sending |packet| because SendVideoPacket() may
   // trigger another frame to be captured, and the screen capturer expects the
   // old frame to be freed by then.
   frame.reset();
 
   scheduler_.RecordEncodeTime(
       base::TimeDelta::FromMilliseconds(packet->encode_time_ms()));
   network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::SendVideoPacket, this,
                             base::Passed(&packet)));
 }
 
 }  // namespace remoting