Revert of Make more media APIs aware of |delay| and |delay_timestamp|

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>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/sync_socket.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "content/public/test/test_browser_thread_bundle.h"
-#include "media/audio/audio_device_thread.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/channel_layout.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using base::TimeDelta;
 using media::AudioBus;
 using media::AudioParameters;
@@ skipping 11 matching lines @@
 const int frames = sampling_frequency_hz / 100;  // 10 ms
 const int bits_per_sample = 16;
 
 // Faked ring buffer. Must be aligned.
 #define DATA_ALIGNMENT 16
 static_assert(AudioBus::kChannelAlignment == DATA_ALIGNMENT,
               "Data alignment not same as AudioBus");
 ALIGNAS(DATA_ALIGNMENT)
 uint8_t data[kSegments * (sizeof(media::AudioInputBufferParameters) +
                           frames * channels * sizeof(float))];
+
 }  // namespace
 
 // Mocked out sockets used for Send/ReceiveWithTimeout. Counts the number of
 // outstanding reads, i.e. the diff between send and receive calls.
 class MockCancelableSyncSocket : public base::CancelableSyncSocket {
  public:
   MockCancelableSyncSocket(int buffer_size)
       : in_failure_mode_(false),
         writes_(0),
         reads_(0),
         receives_(0),
         buffer_size_(buffer_size),
         read_buffer_index_(0) {}
 
   size_t Send(const void* buffer, size_t length) override {
-    EXPECT_EQ(length, sizeof(media::AudioDeviceThread::Packet));
+    EXPECT_EQ(length, sizeof(uint32_t));
 
     ++writes_;
     EXPECT_LE(NumberOfBuffersFilled(), buffer_size_);
     return length;
   }
 
   size_t Receive(void* buffer, size_t length) override {
     EXPECT_EQ(0u, length % sizeof(uint32_t));
 
     if (in_failure_mode_)
@@ skipping 283 matching lines @@
   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);
   socket_->Read(3);
   EXPECT_TRUE(TestSocketAndFifoExpectations(0, 3 * sizeof(uint32_t), 0));
 }
 
 }  // namespace content