Replace VideoStream::SizeCallback with VideoStream::Observer interface.

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 89 matching lines @@
 }
 
 void VideoFramePump::SetLosslessColor(bool want_lossless) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   encode_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoEncoder::SetLosslessColor,
                             base::Unretained(encoder_.get()), want_lossless));
 }
 
-void VideoFramePump::SetSizeCallback(const SizeCallback& size_callback) {
+void VideoFramePump::SetObserver(Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  size_callback_ = size_callback;
+  observer_ = observer;
 }
 
 void VideoFramePump::OnCaptureResult(
     webrtc::DesktopCapturer::Result result,
     std::unique_ptr<webrtc::DesktopFrame> frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   capture_scheduler_.OnCaptureCompleted();
 
   captured_frame_timestamps_->capture_ended_time = base::TimeTicks::Now();
 
   if (frame) {
     webrtc::DesktopVector dpi =
         frame->dpi().is_zero() ? webrtc::DesktopVector(kDefaultDpi, kDefaultDpi)
                                : frame->dpi();
     if (!frame_size_.equals(frame->size()) || !frame_dpi_.equals(dpi)) {
       frame_size_ = frame->size();
       frame_dpi_ = dpi;
-      if (!size_callback_.is_null())
-        size_callback_.Run(frame_size_, frame_dpi_);
+      if (observer_)
+        observer_->OnVideoSizeChanged(this, frame_size_, frame_dpi_);
     }
   }
 
   // Even when |frame| is nullptr 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.
   base::PostTaskAndReplyWithResult(
       encode_task_runner_.get(), FROM_HERE,
       base::Bind(&VideoFramePump::EncodeFrame, encoder_.get(),
                  base::Passed(&frame),
@@ skipping 58 matching lines @@
   }
 }
 
 void VideoFramePump::SendPacket(std::unique_ptr<PacketWithTimestamps> packet) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!send_pending_);
 
   packet->timestamps->can_send_time = base::TimeTicks::Now();
   UpdateFrameTimers(packet->packet.get(), packet->timestamps.get());
 
+  if (observer_) {
+    observer_->OnVideoFrameSent(
+        this, packet->packet->frame_id(),
+        packet->timestamps->input_event_client_timestamp);
+  }
+
   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());
@@ skipping 46 matching lines @@
 }
 
 void VideoFramePump::OnKeepAlivePacketSent() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   keep_alive_timer_.Reset();
 }
 
 }  // namespace protocol
 }  // namespace remoting