Switch browser side audio capture path to use base time primitives.

media/audio/audio_input_controller.cc

 // 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/audio/audio_input_controller.h"
 
 #include <inttypes.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 97 matching lines @@
       : controller_(controller),
         weak_controller_(controller->weak_ptr_factory_.GetWeakPtr()) {}
   ~AudioCallback() override {}
 
   bool received_callback() const { return received_callback_; }
   bool error_during_callback() const { return error_during_callback_; }
 
  private:
   void OnData(AudioInputStream* stream,
               const AudioBus* source,
-              uint32_t hardware_delay_bytes,
+              base::TimeDelta delay,
+              base::TimeTicks delay_timestamp,
               double volume) override {
     TRACE_EVENT0("audio", "AC::OnData");
 
     received_callback_ = true;
 
-    DeliverDataToSyncWriter(source, hardware_delay_bytes, volume);
+    DeliverDataToSyncWriter(source, delay, delay_timestamp, volume);
     PerformOptionalDebugRecording(source);
   }
 
   void OnError(AudioInputStream* stream) override {
     error_during_callback_ = true;
     controller_->task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&AudioInputController::DoReportError, weak_controller_));
   }
 
@@ skipping 13 matching lines @@
     // audio streams.
     std::unique_ptr<AudioBus> source_copy =
         AudioBus::Create(source->channels(), source->frames());
     source->CopyTo(source_copy.get());
     controller_->task_runner_->PostTask(
         FROM_HERE, base::Bind(&AudioInputController::WriteInputDataForDebugging,
                               weak_controller_, base::Passed(&source_copy)));
   }
 
   void DeliverDataToSyncWriter(const AudioBus* source,
-                               uint32_t hardware_delay_bytes,
+                               base::TimeDelta delay,
+                               base::TimeTicks delay_timestamp,
                                double volume) {
     bool key_pressed = controller_->CheckForKeyboardInput();
-    controller_->sync_writer_->Write(source, volume, key_pressed,
-                                     hardware_delay_bytes);
+    controller_->sync_writer_->Write(source, volume, key_pressed, delay,
+                                     delay_timestamp);

[o1ka, 2017/02/10 13:28:50]

Should we probably adjust delay and delay_timestamp at the process border?

[DaleCurtis, 2017/02/11 01:43:13]

delay should always be provided relative to delay_timestamp, so we shouldn't
need to do any adjustment to delay_timestamp, if there's buffering taking place
it should change |delay| though. For now I'm trying not to change anything
behaviorally though, just s/hardware_delay_bytes/delay/.

 
     // The way the two classes interact here, could be done in a nicer way.
     // As is, we call the AIC here to check the audio power, return  and then
     // post a task to the AIC based on what the AIC said.
     // The reason for this is to keep all PostTask calls from the hw callback
     // thread to the AIC, that use a weak pointer, in the same class.
     float average_power_dbfs;
     int mic_volume_percent;
     if (controller_->CheckAudioPower(source, volume, &average_power_dbfs,
                                      &mic_volume_percent)) {
@@ skipping 507 matching lines @@
     case AudioParameters::Format::AUDIO_PCM_LOW_LATENCY:
       return AudioInputController::StreamType::LOW_LATENCY;
     default:
       // Currently, the remaining supported type is fake. Reconsider if other
       // formats become supported.
       return AudioInputController::StreamType::FAKE;
   }
 }
 
 }  // namespace media