Implement video frame acknowledgements in the chromoting protocol.

remoting/client/software_video_renderer.cc

 // Copyright 2014 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/client/software_video_renderer.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 323 matching lines @@
   decode_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SoftwareVideoRenderer::Core::OnSessionConfig,
                             base::Unretained(core_.get()), config));
 }
 
 ChromotingStats* SoftwareVideoRenderer::GetStats() {
   DCHECK(CalledOnValidThread());
   return &stats_;
 }
 
-void SoftwareVideoRenderer::ProcessVideoPacket(scoped_ptr<VideoPacket> packet,
-                                                const base::Closure& done) {
+void SoftwareVideoRenderer::ProcessVideoPacket(
+    scoped_ptr<VideoPacket> packet,
+    const ProgressCallback& progress_callback) {
   DCHECK(CalledOnValidThread());
 
   // If the video packet is empty then drop it. Empty packets are used to
   // maintain activity on the network.
   if (!packet->has_data() || packet->data().size() == 0) {
-    done.Run();
+    progress_callback.Run(PacketProgress::DONE);
     return;
   }
 
   // Add one frame to the counter.
   stats_.video_frame_rate()->Record(1);
 
   // Record other statistics received from host.
   stats_.video_bandwidth()->Record(packet->data().size());
   if (packet->has_capture_time_ms())
     stats_.video_capture_ms()->Record(packet->capture_time_ms());
   if (packet->has_encode_time_ms())
     stats_.video_encode_ms()->Record(packet->encode_time_ms());
   if (packet->has_latest_event_timestamp() &&
       packet->latest_event_timestamp() > latest_event_timestamp_) {
     latest_event_timestamp_ = packet->latest_event_timestamp();
     base::TimeDelta round_trip_latency =
         base::Time::Now() -
         base::Time::FromInternalValue(packet->latest_event_timestamp());
     stats_.round_trip_ms()->Record(round_trip_latency.InMilliseconds());
   }
 
   // Measure the latency between the last packet being received and presented.
   base::Time decode_start = base::Time::Now();
 
   base::Closure decode_done = base::Bind(&SoftwareVideoRenderer::OnPacketDone,
                                          weak_factory_.GetWeakPtr(),
-                                         decode_start, done);
+                                         decode_start, progress_callback);

[Wez, 2015/02/03 00:54:32]

nit: Note that because you're binding this via a WeakPtr to OnPacketDone, the
|progress_callback| may not get called if the SWVideoRenderer is torn down
between a decode and the OnPacketDone(); is calling code capable of coping with
that?

[Sergey Ulanov, 2015/02/09 19:14:54]

Yes. These are not like Pepper callbacks that are guaranteed to be called even
when the object is destroyed.

 
   decode_task_runner_->PostTask(FROM_HERE, base::Bind(
       &SoftwareVideoRenderer::Core::DecodePacket,
       base::Unretained(core_.get()), base::Passed(&packet), decode_done));
 }
 
 void SoftwareVideoRenderer::DrawBuffer(webrtc::DesktopFrame* buffer) {
   decode_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SoftwareVideoRenderer::Core::DrawBuffer,
                             base::Unretained(core_.get()), buffer));
@@ skipping 15 matching lines @@
 
 void SoftwareVideoRenderer::SetOutputSizeAndClip(
     const webrtc::DesktopSize& view_size,
     const webrtc::DesktopRect& clip_area) {
   decode_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SoftwareVideoRenderer::Core::SetOutputSizeAndClip,
                  base::Unretained(core_.get()), view_size, clip_area));
 }
 
-void SoftwareVideoRenderer::OnPacketDone(base::Time decode_start,
-                                          const base::Closure& done) {
+void SoftwareVideoRenderer::OnPacketDone(
+    base::Time decode_start,
+    const ProgressCallback& progress_callback) {
   DCHECK(CalledOnValidThread());
 
   // Record the latency between the packet being received and presented.
   stats_.video_decode_ms()->Record(
       (base::Time::Now() - decode_start).InMilliseconds());
 
-  done.Run();
+  progress_callback.Run(PacketProgress::DONE);
 }
 
 }  // namespace remoting