Two minor cleanups in remoting protocol.

remoting/protocol/video_frame_pump.cc

 // Copyright 2015 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/protocol/video_frame_pump.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
@@ skipping 12 matching lines @@
 
 namespace remoting {
 namespace protocol {
 
 // Interval between empty keep-alive frames. These frames are sent only when the
 // stream is paused or inactive for some other reason (e.g. when blocked on
 // capturer). To prevent PseudoTCP from resetting congestion window this value
 // must be smaller than the minimum RTO used in PseudoTCP, which is 250ms.
 static const int kKeepAlivePacketIntervalMs = 200;
 
-static bool g_enable_timestamps = false;
-
 VideoFramePump::FrameTimestamps::FrameTimestamps() {}
 VideoFramePump::FrameTimestamps::~FrameTimestamps() {}
 
 VideoFramePump::PacketWithTimestamps::PacketWithTimestamps(
     std::unique_ptr<VideoPacket> packet,
     std::unique_ptr<FrameTimestamps> timestamps)
     : packet(std::move(packet)), timestamps(std::move(timestamps)) {}
 
 VideoFramePump::PacketWithTimestamps::~PacketWithTimestamps() {}
 
-// static
-void VideoFramePump::EnableTimestampsForTests() {
-  g_enable_timestamps = true;
-}
-
 VideoFramePump::VideoFramePump(
     scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
     std::unique_ptr<webrtc::DesktopCapturer> capturer,
     std::unique_ptr<VideoEncoder> encoder,
     protocol::VideoStub* video_stub)
     : encode_task_runner_(encode_task_runner),
       capturer_(std::move(capturer)),
       encoder_(std::move(encoder)),
       video_stub_(video_stub),
       keep_alive_timer_(
@@ skipping 155 matching lines @@
   }
 
   send_pending_ = true;
   video_stub_->ProcessVideoPacket(std::move(packet->packet),
                                   base::Bind(&VideoFramePump::OnVideoPacketSent,
                                              weak_factory_.GetWeakPtr()));
 }
 
 void VideoFramePump::UpdateFrameTimers(VideoPacket* packet,
                                        FrameTimestamps* timestamps) {
-  if (g_enable_timestamps)
-    packet->set_timestamp(timestamps->capture_ended_time.ToInternalValue());
-
-
   if (!timestamps->input_event_received_time.is_null()) {
     packet->set_capture_pending_time_ms((timestamps->capture_started_time -
                                          timestamps->input_event_received_time)
                                             .InMilliseconds());
     packet->set_latest_event_timestamp(
         timestamps->input_event_client_timestamp);
   }
 
   packet->set_capture_overhead_time_ms(
       (timestamps->capture_ended_time - timestamps->capture_started_time)
@@ skipping 34 matching lines @@
 }
 
 void VideoFramePump::OnKeepAlivePacketSent() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   keep_alive_timer_.Reset();
 }
 
 }  // namespace protocol
 }  // namespace remoting