[Chromoting] Send DesktopFrame::capturer_id() to client through WebrtcVideoStream

remoting/protocol/webrtc_video_stream.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/webrtc_video_stream.h"
 
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "remoting/base/constants.h"
 #include "remoting/codec/webrtc_video_encoder_vpx.h"
 #include "remoting/protocol/frame_stats.h"
 #include "remoting/protocol/host_video_stats_dispatcher.h"
 #include "remoting/protocol/webrtc_dummy_video_capturer.h"
 #include "remoting/protocol/webrtc_frame_scheduler_simple.h"
 #include "remoting/protocol/webrtc_transport.h"
 #include "third_party/webrtc/api/mediastreaminterface.h"
 #include "third_party/webrtc/api/peerconnectioninterface.h"
 #include "third_party/webrtc/api/test/fakeconstraints.h"
 #include "third_party/webrtc/media/base/videocapturer.h"
 
 namespace remoting {
 namespace protocol {
 
 const char kStreamLabel[] = "screen_stream";
 const char kVideoLabel[] = "screen_video";
 
-struct WebrtcVideoStream::FrameTimestamps {
+struct WebrtcVideoStream::FrameStats {
   // The following fields is not null only for one frame after each incoming
   // input event.
   InputEventTimestamps input_event_timestamps;
 
   base::TimeTicks capture_started_time;
   base::TimeTicks capture_ended_time;
   base::TimeDelta capture_delay;
   base::TimeTicks encode_started_time;
   base::TimeTicks encode_ended_time;
+
+  uint32_t capturer_id = 0;
 };
 
-struct WebrtcVideoStream::EncodedFrameWithTimestamps {
+struct WebrtcVideoStream::EncodedFrameWithStats {
   std::unique_ptr<WebrtcVideoEncoder::EncodedFrame> frame;
-  std::unique_ptr<FrameTimestamps> timestamps;
+  std::unique_ptr<FrameStats> stats;
 };
 
 WebrtcVideoStream::WebrtcVideoStream()
     : video_stats_dispatcher_(kStreamLabel), weak_factory_(this) {}
 
 WebrtcVideoStream::~WebrtcVideoStream() {
   if (stream_) {
     for (const auto& track : stream_->GetVideoTracks()) {
       stream_->RemoveTrack(track.get());
     }
@@ skipping 78 matching lines @@
 void WebrtcVideoStream::SetObserver(Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   observer_ = observer;
 }
 
 void WebrtcVideoStream::OnCaptureResult(
     webrtc::DesktopCapturer::Result result,
     std::unique_ptr<webrtc::DesktopFrame> frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  captured_frame_timestamps_->capture_ended_time = base::TimeTicks::Now();
-  captured_frame_timestamps_->capture_delay =
+  captured_frame_stats_->capture_ended_time = base::TimeTicks::Now();
+  captured_frame_stats_->capture_delay =
       base::TimeDelta::FromMilliseconds(frame ? frame->capture_time_ms() : 0);
 
   WebrtcVideoEncoder::FrameParams frame_params;
   if (!scheduler_->OnFrameCaptured(frame.get(), &frame_params)) {
     return;
   }
 
   // TODO(sergeyu): Handle ERROR_PERMANENT result here.
   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 (observer_)
         observer_->OnVideoSizeChanged(this, frame_size_, frame_dpi_);
     }
   }
 
   base::PostTaskAndReplyWithResult(
       encode_task_runner_.get(), FROM_HERE,
       base::Bind(&WebrtcVideoStream::EncodeFrame, encoder_.get(),
                  base::Passed(std::move(frame)), frame_params,
-                 base::Passed(std::move(captured_frame_timestamps_))),
+                 base::Passed(std::move(captured_frame_stats_))),
       base::Bind(&WebrtcVideoStream::OnFrameEncoded,
                  weak_factory_.GetWeakPtr()));
 }
 
 void WebrtcVideoStream::OnChannelInitialized(
     ChannelDispatcherBase* channel_dispatcher) {
   DCHECK(&video_stats_dispatcher_ == channel_dispatcher);
 }
 void WebrtcVideoStream::OnChannelClosed(
     ChannelDispatcherBase* channel_dispatcher) {
   DCHECK(&video_stats_dispatcher_ == channel_dispatcher);
   LOG(WARNING) << "video_stats channel was closed.";
 }
 
 void WebrtcVideoStream::CaptureNextFrame() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  captured_frame_timestamps_.reset(new FrameTimestamps());
-  captured_frame_timestamps_->capture_started_time = base::TimeTicks::Now();
-  captured_frame_timestamps_->input_event_timestamps =
+  captured_frame_stats_.reset(new FrameStats());
+  captured_frame_stats_->capture_started_time = base::TimeTicks::Now();
+  captured_frame_stats_->input_event_timestamps =
       event_timestamps_source_->TakeLastEventTimestamps();
 
   capturer_->CaptureFrame();
 }
 
 // static
-WebrtcVideoStream::EncodedFrameWithTimestamps WebrtcVideoStream::EncodeFrame(
+WebrtcVideoStream::EncodedFrameWithStats WebrtcVideoStream::EncodeFrame(
     WebrtcVideoEncoder* encoder,
     std::unique_ptr<webrtc::DesktopFrame> frame,
     WebrtcVideoEncoder::FrameParams params,
-    std::unique_ptr<WebrtcVideoStream::FrameTimestamps> timestamps) {
-  EncodedFrameWithTimestamps result;
-  result.timestamps = std::move(timestamps);
-  result.timestamps->encode_started_time = base::TimeTicks::Now();
+    std::unique_ptr<WebrtcVideoStream::FrameStats> stats) {
+  EncodedFrameWithStats result;
+  result.stats = std::move(stats);
+  result.stats->encode_started_time = base::TimeTicks::Now();
   result.frame = encoder->Encode(frame.get(), params);
-  result.timestamps->encode_ended_time = base::TimeTicks::Now();
+  result.stats->encode_ended_time = base::TimeTicks::Now();
+  if (frame) {
+    result.stats->capturer_id = frame->capturer_id();
+  }
   return result;
 }
 
-void WebrtcVideoStream::OnFrameEncoded(EncodedFrameWithTimestamps frame) {
+void WebrtcVideoStream::OnFrameEncoded(EncodedFrameWithStats frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   HostFrameStats stats;
   scheduler_->OnFrameEncoded(frame.frame.get(), &stats);
 
   if (!frame.frame) {
     return;
   }
 
   webrtc::EncodedImageCallback::Result result =
       webrtc_transport_->video_encoder_factory()->SendEncodedFrame(
-          *frame.frame, frame.timestamps->capture_started_time);
+          *frame.frame, frame.stats->capture_started_time);
   if (result.error != webrtc::EncodedImageCallback::Result::OK) {
     // TODO(sergeyu): Stop the stream.
     LOG(ERROR) << "Failed to send video frame.";
     return;
   }
 
   // Send FrameStats message.
   if (video_stats_dispatcher_.is_connected()) {
     stats.frame_size = frame.frame ? frame.frame->data.size() : 0;
 
-    if (!frame.timestamps->input_event_timestamps.is_null()) {
+    if (!frame.stats->input_event_timestamps.is_null()) {
       stats.capture_pending_delay =
-          frame.timestamps->capture_started_time -
-          frame.timestamps->input_event_timestamps.host_timestamp;
+          frame.stats->capture_started_time -
+          frame.stats->input_event_timestamps.host_timestamp;
       stats.latest_event_timestamp =
-          frame.timestamps->input_event_timestamps.client_timestamp;
+          frame.stats->input_event_timestamps.client_timestamp;
     }
 
-    stats.capture_delay = frame.timestamps->capture_delay;
+    stats.capture_delay = frame.stats->capture_delay;
 
     // Total overhead time for IPC and threading when capturing frames.
-    stats.capture_overhead_delay = (frame.timestamps->capture_ended_time -
-                                    frame.timestamps->capture_started_time) -
-                                   stats.capture_delay;
+    stats.capture_overhead_delay =
+        (frame.stats->capture_ended_time - frame.stats->capture_started_time) -
+        stats.capture_delay;
 
-    stats.encode_pending_delay = frame.timestamps->encode_started_time -
-                                 frame.timestamps->capture_ended_time;
+    stats.encode_pending_delay =
+        frame.stats->encode_started_time - frame.stats->capture_ended_time;
 
-    stats.encode_delay = frame.timestamps->encode_ended_time -
-                         frame.timestamps->encode_started_time;
+    stats.encode_delay =
+        frame.stats->encode_ended_time - frame.stats->encode_started_time;
+
+    stats.capturer_id = frame.stats->capturer_id;
 
     video_stats_dispatcher_.OnVideoFrameStats(result.frame_id, stats);
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting