Decouple capture timestamp and reference time

media/capture/video/mac/video_capture_device_mac.mm

 // Copyright (c) 2012 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/capture/video/mac/video_capture_device_mac.h"
 
 #include <IOKit/IOCFPlugIn.h>
 #include <IOKit/usb/IOUSBLib.h>
 #include <IOKit/usb/USBSpec.h>
 #include <stddef.h>
@@ skipping 298 matching lines @@
   std::string id_product = unique_id_.substr(pid_location, kVidPidSize);
 
   return id_vendor + ":" + id_product;
 }
 
 VideoCaptureDeviceMac::VideoCaptureDeviceMac(const Name& device_name)
     : device_name_(device_name),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       state_(kNotInitialized),
       capture_device_(nil),
-      first_timestamp_(media::kNoTimestamp()),
       weak_factory_(this) {
 }
 
 VideoCaptureDeviceMac::~VideoCaptureDeviceMac() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 }
 
 void VideoCaptureDeviceMac::AllocateAndStart(
     const VideoCaptureParams& params,
     std::unique_ptr<VideoCaptureDevice::Client> client) {
@@ skipping 86 matching lines @@
                                          base::TimeDelta timestamp) {
   // This method is safe to call from a device capture thread, i.e. any thread
   // controlled by AVFoundation.
   if (capture_format_.frame_size != frame_format.frame_size) {
     ReceiveError(FROM_HERE,
                  "Captured resolution " + frame_format.frame_size.ToString() +
                      ", and expected " + capture_format_.frame_size.ToString());
     return;
   }
 
-  base::TimeTicks aligned_timestamp;
-  if (timestamp == media::kNoTimestamp()) {
-    aligned_timestamp = base::TimeTicks::Now();
-  } else {
-    if (first_timestamp_ == media::kNoTimestamp()) {
-      first_timestamp_ = timestamp;
-      first_aligned_timestamp_ = base::TimeTicks::Now();
-    }
-    aligned_timestamp = first_aligned_timestamp_ + timestamp - first_timestamp_;
-  }
   client_->OnIncomingCapturedData(video_frame, video_frame_length, frame_format,
-                                  0, aligned_timestamp);
+                                  0, base::TimeTicks::Now(), timestamp);
 }
 
 void VideoCaptureDeviceMac::ReceiveError(
     const tracked_objects::Location& from_here,
     const std::string& reason) {
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoCaptureDeviceMac::SetErrorState,
                             weak_factory_.GetWeakPtr(), from_here, reason));
 }
 
@@ skipping 15 matching lines @@
   if (![capture_device_ setCaptureHeight:capture_format_.frame_size.height()
                                    width:capture_format_.frame_size.width()
                                frameRate:capture_format_.frame_rate]) {
     ReceiveError(FROM_HERE, "Could not configure capture device.");
     return false;
   }
   return true;
 }
 
 }  // namespace media