Update VideoFramePump to pass un-changed frames to encoders.

remoting/host/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/host/video_frame_pump.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/time/time.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/video_stub.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 namespace remoting {
 
 namespace {
 
-// Helper used to encode frames on the encode thread.
-//
-// TODO(sergeyu): This functions doesn't do much beside calling
-// VideoEncoder::Encode(). It's only needed to handle empty frames properly and
-// that logic can be moved to VideoEncoder implementations.
 scoped_ptr<VideoPacket> EncodeFrame(VideoEncoder* encoder,
                                     scoped_ptr<webrtc::DesktopFrame> frame) {
-  // If there is nothing to encode then send an empty packet.
-  if (!frame || frame->updated_region().is_empty())
-    return make_scoped_ptr(new VideoPacket());
+  scoped_ptr<VideoPacket> packet;
 
-  return encoder->Encode(*frame);
+  // If |frame| is non-NULL then let the encoder process it.
+  if (frame) {
+    packet = encoder->Encode(*frame);
+  }
+
+  // If |frame| is NULL, or the encoder returned nothing, return an empty
+  // packet.
+  if (!packet) {
+    packet.reset(new VideoPacket());
+  }
+
+  return packet.Pass();
 }
 
 }  // namespace
 
 // 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;
 
@@ skipping 122 matching lines @@
                  weak_factory_.GetWeakPtr()));
 }
 
 void VideoFramePump::OnKeepAlivePacketSent() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   keep_alive_timer_.Reset();
 }
 
 }  // namespace remoting