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

content/browser/renderer_host/media/audio_input_sync_writer.h

 // 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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_INPUT_SYNC_WRITER_H_
 #define CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_INPUT_SYNC_WRITER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 32 matching lines @@
                        size_t shared_memory_size,
                        int shared_memory_segment_count,
                        const media::AudioParameters& params);
 
   ~AudioInputSyncWriter() override;
 
   // media::AudioInputController::SyncWriter implementation.
   void Write(const media::AudioBus* data,
              double volume,
              bool key_pressed,
-             uint32_t hardware_delay_bytes) override;
+             base::TimeDelta delay,
+             base::TimeTicks delay_timestamp) override;
   void Close() override;
 
   bool Init();
   bool PrepareForeignSocket(base::ProcessHandle process_handle,
                             base::SyncSocket::TransitDescriptor* descriptor);
 
  protected:
   // Socket for transmitting audio data.
   std::unique_ptr<base::CancelableSyncSocket> socket_;
 
@@ skipping 12 matching lines @@
 
   // Virtual function for native logging to be able to override in tests.
   virtual void AddToNativeLog(const std::string& message);
 
   // Push |data| and metadata to |audio_buffer_fifo_|. Returns true if
   // successful. Logs error and returns false if the fifo already reached the
   // maximum size.
   bool PushDataToFifo(const media::AudioBus* data,
                       double volume,
                       bool key_pressed,
-                      uint32_t hardware_delay_bytes);
+                      base::TimeDelta delay,
+                      base::TimeTicks delay_timestamp);
 
   // Writes as much data as possible from the fifo (|overflow_buses_|) to the
   // shared memory ring buffer. Returns true if all operations were successful,
   // otherwise false.
   bool WriteDataFromFifoToSharedMemory();
 
   // Write audio parameters to current segment in shared memory.
   void WriteParametersToCurrentSegment(double volume,
                                        bool key_pressed,
-                                       uint32_t hardware_delay_bytes);
+                                       base::TimeDelta delay,
+                                       base::TimeTicks delay_timestamp);
 
   // Signals over the socket that data has been written to the current segment.
   // Updates counters and returns true if successful. Logs error and returns
   // false if failure.
   bool SignalDataWrittenAndUpdateCounters();
 
   uint8_t* shared_memory_;
   uint32_t shared_memory_segment_size_;
   uint32_t shared_memory_segment_count_;
   uint32_t current_segment_id_;
@@ skipping 45 matching lines @@
   ScopedVector<media::AudioBus> audio_buses_;
 
   // Fifo for audio that is used in case there isn't room in the shared memory.
   // This can for example happen under load when the consumer side is starved.
   // It should ideally be rare, but we need to guarantee that the data arrives
   // since audio processing such as echo cancelling requires that to perform
   // properly.
   ScopedVector<media::AudioBus> overflow_buses_;
   struct OverflowParams {
     double volume;
-    uint32_t hardware_delay_bytes;
+    base::TimeDelta delay;
+    base::TimeTicks delay_timestamp;
     bool key_pressed;
   };
   std::deque<OverflowParams> overflow_params_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(AudioInputSyncWriter);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_AUDIO_INPUT_SYNC_WRITER_H_