Add metadata to media::VideoFrame and plumb it through IPC/MediaStream.

media/cast/sender/video_sender.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 "media/cast/sender/video_sender.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/bind.h"
@@ skipping 12 matching lines @@
 // playout delay (when allowed). They were calculated using
 // a combination of cast_benchmark runs and manual testing.
 //
 // This is how many round trips we think we need on the network.
 const int kRoundTripsNeeded = 4;
 // This is an estimate of all the the constant time needed independent of
 // network quality (e.g., additional time that accounts for encode and decode
 // time).
 const int kConstantTimeMs = 75;
 
+// Extract capture begin/end timestamps from |video_frame|'s metadata and log
+// it.
+void LogVideoCaptureTimestamps(const CastEnvironment& cast_environment,
+                               const media::VideoFrame& video_frame,
+                               RtpTimestamp rtp_timestamp) {
+  base::TimeTicks capture_begin_time;
+  base::TimeTicks capture_end_time;
+  double capture_begin_time_internal = 0;
+  double capture_end_time_internal = 0;
+  if (video_frame.metadata().GetDouble("captureBeginTimeTicks",
+                                       &capture_begin_time_internal) &&
+      video_frame.metadata().GetDouble("captureEndTimeTicks",
+                                       &capture_end_time_internal)) {
+    // See comments in media/capture/content_video_capture_device_core.cc
+    // for why casting between double and int64 is reasonable.
+    capture_begin_time = base::TimeTicks::FromInternalValue(
+        static_cast<int64>(capture_begin_time_internal));
+    capture_end_time = base::TimeTicks::FromInternalValue(
+        static_cast<int64>(capture_end_time_internal));
+  } else {
+    // The frame capture timestamps were not provided by the video capture
+    // source.  Simply log the events as happening right now.
+    capture_begin_time = capture_end_time =
+        cast_environment.Clock()->NowTicks();
+  }
+  cast_environment.Logging()->InsertFrameEvent(
+      capture_begin_time, FRAME_CAPTURE_BEGIN, VIDEO_EVENT, rtp_timestamp,
+      kFrameIdUnknown);
+  cast_environment.Logging()->InsertFrameEvent(
+      capture_end_time, FRAME_CAPTURE_END, VIDEO_EVENT, rtp_timestamp,
+      kFrameIdUnknown);
+}
+
 }  // namespace
 
 // Note, we use a fixed bitrate value when external video encoder is used.
 // Some hardware encoder shows bad behavior if we set the bitrate too
 // frequently, e.g. quality drop, not abiding by target bitrate, etc.
 // See details: crbug.com/392086.
 VideoSender::VideoSender(
     scoped_refptr<CastEnvironment> cast_environment,
     const VideoSenderConfig& video_config,
     const StatusChangeCallback& status_change_cb,
@@ skipping 58 matching lines @@
     const base::TimeTicks& reference_time) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   if (!video_encoder_) {
     NOTREACHED();
     return;
   }
 
   const RtpTimestamp rtp_timestamp =
       TimeDeltaToRtpDelta(video_frame->timestamp(), kVideoFrequency);
-  const base::TimeTicks insertion_time = cast_environment_->Clock()->NowTicks();
-  // TODO(miu): Plumb in capture timestamps.  For now, make it look like capture
-  // took zero time by setting the BEGIN and END event to the same timestamp.
-  cast_environment_->Logging()->InsertFrameEvent(
-      insertion_time, FRAME_CAPTURE_BEGIN, VIDEO_EVENT, rtp_timestamp,
-      kFrameIdUnknown);
-  cast_environment_->Logging()->InsertFrameEvent(
-      insertion_time, FRAME_CAPTURE_END, VIDEO_EVENT, rtp_timestamp,
-      kFrameIdUnknown);
+  LogVideoCaptureTimestamps(*cast_environment_, *video_frame, rtp_timestamp);
 
   // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
   TRACE_EVENT_INSTANT2(
       "cast_perf_test", "InsertRawVideoFrame",
       TRACE_EVENT_SCOPE_THREAD,
       "timestamp", reference_time.ToInternalValue(),
       "rtp_timestamp", rtp_timestamp);
 
   // Drop the frame if either its RTP or reference timestamp is not an increase
   // over the last frame's.  This protects: 1) the duration calculations that
@@ skipping 95 matching lines @@
   DCHECK_GE(frames_in_encoder_, 0);
 
   duration_in_encoder_ =
       last_enqueued_frame_reference_time_ - encoded_frame->reference_time;
 
   SendEncodedFrame(encoder_bitrate, encoded_frame.Pass());
 }
 
 }  // namespace cast
 }  // namespace media