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

content/browser/renderer_host/media/audio_input_sync_writer_unittest.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 "content/browser/renderer_host/media/audio_input_sync_writer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 179 matching lines @@
  private:
   TestBrowserThreadBundle thread_bundle_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioInputSyncWriterTest);
 };
 
 TEST_F(AudioInputSyncWriterTest, SingleWriteAndRead) {
   EXPECT_CALL(*writer_.get(), AddToNativeLog(_))
       .Times(GetTotalNumberOfExpectedLogCalls(0));
 
-  writer_->Write(audio_bus_.get(), 0, false, 0);
+  writer_->Write(audio_bus_.get(), 0, false, base::TimeDelta(),
+                 base::TimeTicks::Now());
   EXPECT_TRUE(TestSocketAndFifoExpectations(1, 0, 0));
 
   socket_->Read(1);
   EXPECT_TRUE(TestSocketAndFifoExpectations(0, 1 * sizeof(uint32_t), 0));
 }
 
 TEST_F(AudioInputSyncWriterTest, MultipleWritesAndReads) {
   EXPECT_CALL(*writer_.get(), AddToNativeLog(_))
       .Times(GetTotalNumberOfExpectedLogCalls(0));
 
   for (int i = 1; i <= 2 * kSegments; ++i) {
-    writer_->Write(audio_bus_.get(), 0, false, 0);
+    writer_->Write(audio_bus_.get(), 0, false, base::TimeDelta(),
+                   base::TimeTicks::Now());
     EXPECT_TRUE(TestSocketAndFifoExpectations(1, 0, 0));
     socket_->Read(1);
     EXPECT_TRUE(TestSocketAndFifoExpectations(0, 1 * sizeof(uint32_t), 0));
   }
 }
 
 TEST_F(AudioInputSyncWriterTest, MultipleWritesNoReads) {
   EXPECT_CALL(*writer_.get(), AddToNativeLog(_))
       .Times(GetTotalNumberOfExpectedLogCalls(1));
 
   // Fill the ring buffer.
   for (int i = 1; i <= kSegments; ++i) {
-    writer_->Write(audio_bus_.get(), 0, false, 0);
+    writer_->Write(audio_bus_.get(), 0, false, base::TimeDelta(),
+                   base::TimeTicks::Now());
     EXPECT_TRUE(TestSocketAndFifoExpectations(i, 0, 0));
   }
 
   // Now the ring buffer is full, do more writes. We should start filling the
   // fifo and should get one extra log call for that.
   for (size_t i = 1; i <= kSegments; ++i) {
-    writer_->Write(audio_bus_.get(), 0, false, 0);
+    writer_->Write(audio_bus_.get(), 0, false, base::TimeDelta(),
+                   base::TimeTicks::Now());
     EXPECT_TRUE(TestSocketAndFifoExpectations(kSegments, 0, i));
   }
 }
 
 TEST_F(AudioInputSyncWriterTest, FillAndEmptyRingBuffer) {
   EXPECT_CALL(*writer_.get(), AddToNativeLog(_))
       .Times(GetTotalNumberOfExpectedLogCalls(2));
 
   // Fill the ring buffer.
   for (int i = 1; i <= kSegments; ++i) {
-    writer_->Write(audio_bus_.get(), 0, false, 0);
+    writer_->Write(audio_bus_.get(), 0, false, base::TimeDelta(),
+                   base::TimeTicks::Now());
   }
   EXPECT_TRUE(TestSocketAndFifoExpectations(kSegments, 0, 0));
 
   // Empty half of the ring buffer.
   const int buffers_to_read = kSegments / 2;
   socket_->Read(buffers_to_read);
   EXPECT_TRUE(TestSocketAndFifoExpectations(kSegments - buffers_to_read,
                                             buffers_to_read * sizeof(uint32_t),
                                             0));
 
   // Fill up again. The first write should do receive until that queue is
   // empty.
   for (int i = kSegments - buffers_to_read + 1; i <= kSegments; ++i) {
-    writer_->Write(audio_bus_.get(), 0, false, 0);
+    writer_->Write(audio_bus_.get(), 0, false, base::TimeDelta(),
+                   base::TimeTicks::Now());
     EXPECT_TRUE(TestSocketAndFifoExpectations(i, 0, 0));
   }
 
   // Another write, should put the data in the fifo, and render an extra log
   // call.
-  writer_->Write(audio_bus_.get(), 0, false, 0);
+  writer_->Write(audio_bus_.get(), 0, false, base::TimeDelta(),
+                 base::TimeTicks::Now());
   EXPECT_TRUE(TestSocketAndFifoExpectations(kSegments, 0, 1));
 
   // Empty the ring buffer.
   socket_->Read(kSegments);
   EXPECT_TRUE(
       TestSocketAndFifoExpectations(0, kSegments * sizeof(uint32_t), 1));
 
   // Another write, should do receive until that queue is empty and write both
   // the data in the fifo and the new data, and render a log call.
-  writer_->Write(audio_bus_.get(), 0, false, 0);
+  writer_->Write(audio_bus_.get(), 0, false, base::TimeDelta(),
+                 base::TimeTicks::Now());
   EXPECT_TRUE(TestSocketAndFifoExpectations(2, 0, 0));
 
   // Read the two data blocks.
   socket_->Read(2);
   EXPECT_TRUE(TestSocketAndFifoExpectations(0, 2 * sizeof(uint32_t), 0));
 }
 
 TEST_F(AudioInputSyncWriterTest, FillRingBufferAndFifo) {
   EXPECT_CALL(*writer_.get(), AddToNativeLog(_))
       .Times(GetTotalNumberOfExpectedLogCalls(2));
 
   // Fill the ring buffer.
   for (int i = 1; i <= kSegments; ++i) {
-    writer_->Write(audio_bus_.get(), 0, false, 0);
+    writer_->Write(audio_bus_.get(), 0, false, base::TimeDelta(),
+                   base::TimeTicks::Now());
   }
   EXPECT_TRUE(TestSocketAndFifoExpectations(kSegments, 0, 0));
 
   // Fill the fifo. Should render one log call for starting filling it.
   const size_t max_fifo_size = AudioInputSyncWriter::kMaxOverflowBusesSize;
   for (size_t i = 1; i <= max_fifo_size; ++i) {
-    writer_->Write(audio_bus_.get(), 0, false, 0);
+    writer_->Write(audio_bus_.get(), 0, false, base::TimeDelta(),
+                   base::TimeTicks::Now());
   }
   EXPECT_TRUE(TestSocketAndFifoExpectations(kSegments, 0, max_fifo_size));
 
   // Another write, data should be dropped and render one log call.
-  writer_->Write(audio_bus_.get(), 0, false, 0);
+  writer_->Write(audio_bus_.get(), 0, false, base::TimeDelta(),
+                 base::TimeTicks::Now());
   EXPECT_TRUE(TestSocketAndFifoExpectations(kSegments, 0, max_fifo_size));
 }
 
 TEST_F(AudioInputSyncWriterTest, MultipleFillAndEmptyRingBufferAndPartOfFifo) {
   EXPECT_CALL(*writer_.get(), AddToNativeLog(_))
       .Times(GetTotalNumberOfExpectedLogCalls(4));
 
   // Fill the ring buffer.
   for (int i = 1; i <= kSegments; ++i) {
-    writer_->Write(audio_bus_.get(), 0, false, 0);
+    writer_->Write(audio_bus_.get(), 0, false, base::TimeDelta(),
+                   base::TimeTicks::Now());
   }
   EXPECT_TRUE(TestSocketAndFifoExpectations(kSegments, 0, 0));
 
   // Write more data, should be put in the fifo and render one log call for
   // starting filling it.
   for (size_t i = 1; i <= 2 * kSegments; ++i) {
-    writer_->Write(audio_bus_.get(), 0, false, 0);
+    writer_->Write(audio_bus_.get(), 0, false, base::TimeDelta(),
+                   base::TimeTicks::Now());
   }
   EXPECT_TRUE(TestSocketAndFifoExpectations(kSegments, 0, 2 * kSegments));
 
   // Empty the ring buffer.
   socket_->Read(kSegments);
   EXPECT_TRUE(TestSocketAndFifoExpectations(0, kSegments * sizeof(uint32_t),
                                             2 * kSegments));
 
   // Another write should fill up the ring buffer with data from the fifo and
   // put this data into the fifo.
-  writer_->Write(audio_bus_.get(), 0, false, 0);
+  writer_->Write(audio_bus_.get(), 0, false, base::TimeDelta(),
+                 base::TimeTicks::Now());
   EXPECT_TRUE(TestSocketAndFifoExpectations(kSegments, 0, kSegments + 1));
 
   // Empty the ring buffer again.
   socket_->Read(kSegments);
   EXPECT_TRUE(TestSocketAndFifoExpectations(0, kSegments * sizeof(uint32_t),
                                             kSegments + 1));
 
   // Another write should fill up the ring buffer with data from the fifo and
   // put this data into the fifo.
-  writer_->Write(audio_bus_.get(), 0, false, 0);
+  writer_->Write(audio_bus_.get(), 0, false, base::TimeDelta(),
+                 base::TimeTicks::Now());
   EXPECT_TRUE(TestSocketAndFifoExpectations(kSegments, 0, 2));
 
   // Empty the ring buffer again.
   socket_->Read(kSegments);
   EXPECT_TRUE(
       TestSocketAndFifoExpectations(0, kSegments * sizeof(uint32_t), 2));
 
   // Another write should put the remaining data in the fifo in the ring buffer
   // together with this data. Should render a log call for emptying the fifo.
-  writer_->Write(audio_bus_.get(), 0, false, 0);
+  writer_->Write(audio_bus_.get(), 0, false, base::TimeDelta(),
+                 base::TimeTicks::Now());
   EXPECT_TRUE(TestSocketAndFifoExpectations(3, 0, 0));
 
   // Read the remaining data.
   socket_->Read(3);
   EXPECT_TRUE(TestSocketAndFifoExpectations(0, 3 * sizeof(uint32_t), 0));
 
   // Fill the ring buffer and part of the fifo. Should render one log call for
   // starting filling it.
   for (int i = 1; i <= kSegments + 2; ++i) {
-    writer_->Write(audio_bus_.get(), 0, false, 0);
+    writer_->Write(audio_bus_.get(), 0, false, base::TimeDelta(),
+                   base::TimeTicks::Now());
   }
   EXPECT_TRUE(TestSocketAndFifoExpectations(kSegments, 0, 2));
 
   // Empty both. Should render a log call for emptying the fifo.
   socket_->Read(kSegments);
-  writer_->Write(audio_bus_.get(), 0, false, 0);
+  writer_->Write(audio_bus_.get(), 0, false, base::TimeDelta(),
+                 base::TimeTicks::Now());
   socket_->Read(3);
   EXPECT_TRUE(TestSocketAndFifoExpectations(0, 3 * sizeof(uint32_t), 0));
 }
 
 }  // namespace content