Remove "high"-latency audio code path

content/renderer/media/audio_message_filter_unittest.cc

Index: content/renderer/media/audio_message_filter_unittest.cc
diff --git a/content/renderer/media/audio_message_filter_unittest.cc b/content/renderer/media/audio_message_filter_unittest.cc
index a8ec475d92b361b98153d8d09be0cd17f5de5d56..5bd4511875efe98ed0558814566ff9d2e068b2d8 100644
--- a/content/renderer/media/audio_message_filter_unittest.cc
+++ b/content/renderer/media/audio_message_filter_unittest.cc
@@ -15,37 +15,25 @@ class MockAudioDelegate : public AudioMessageFilter::Delegate {
     Reset();
   }
 
-  virtual void OnRequestPacket(AudioBuffersState buffers_state) {
-    request_packet_received_ = true;
-    buffers_state_ = buffers_state;
-  }
-
   virtual void OnStateChanged(AudioStreamState state) {
     state_changed_received_ = true;
     state_ = state;
   }
 
-  virtual void OnCreated(base::SharedMemoryHandle handle, uint32 length) {
+  virtual void OnStreamCreated(base::SharedMemoryHandle handle,
+                               base::SyncSocket::Handle,
+                               uint32 length) {
     created_received_ = true;
     handle_ = handle;
     length_ = length;
   }
 
-  virtual void OnLowLatencyCreated(base::SharedMemoryHandle handle,
-                                   base::SyncSocket::Handle,
-                                   uint32 length) {
-  }
-
   virtual void OnVolume(double volume) {
     volume_received_ = true;
     volume_ = volume;
   }
 
   void Reset() {
-    request_packet_received_ = false;
-    buffers_state_ = AudioBuffersState();
-    buffers_state_.timestamp = base::Time();
-
     state_changed_received_ = false;
     state_ = kAudioStreamError;
 
@@ -57,9 +45,6 @@ class MockAudioDelegate : public AudioMessageFilter::Delegate {
     volume_ = 0;
   }
 
-  bool request_packet_received() { return request_packet_received_; }
-  AudioBuffersState buffers_state() { return buffers_state_; }
-
   bool state_changed_received() { return state_changed_received_; }
   AudioStreamState state() { return state_; }
 
@@ -71,9 +56,6 @@ class MockAudioDelegate : public AudioMessageFilter::Delegate {
   double volume() { return volume_; }
 
  private:
-  bool request_packet_received_;
-  AudioBuffersState buffers_state_;
-
   bool state_changed_received_;
   AudioStreamState state_;
 
@@ -97,45 +79,29 @@ TEST(AudioMessageFilterTest, Basic) {
   MockAudioDelegate delegate;
   int stream_id = filter->AddDelegate(&delegate);
 
-  // AudioMsg_RequestPacket
-  const int kSizeInBuffer = 1024;
-  AudioBuffersState buffers_state(kSizeInBuffer, 0);
-
-  EXPECT_FALSE(delegate.request_packet_received());
-  filter->OnMessageReceived(AudioMsg_RequestPacket(stream_id, buffers_state));
-  EXPECT_TRUE(delegate.request_packet_received());
-  EXPECT_EQ(kSizeInBuffer, delegate.buffers_state().pending_bytes);
-  EXPECT_EQ(0, delegate.buffers_state().hardware_delay_bytes);
-  EXPECT_TRUE(buffers_state.timestamp == delegate.buffers_state().timestamp);
-  delegate.Reset();
-
-  // AudioMsg_NotifyStreamStateChanged
-  EXPECT_FALSE(delegate.state_changed_received());
-  filter->OnMessageReceived(
-      AudioMsg_NotifyStreamStateChanged(stream_id, kAudioStreamPlaying));
-  EXPECT_TRUE(delegate.state_changed_received());
-  EXPECT_TRUE(kAudioStreamPlaying == delegate.state());
-  delegate.Reset();
-
   // AudioMsg_NotifyStreamCreated
+#if defined(OS_WIN)
+  base::SyncSocket::Handle socket_handle;
+#else
+  base::FileDescriptor socket_handle;
+#endif
   const uint32 kLength = 1024;
   EXPECT_FALSE(delegate.created_received());
   filter->OnMessageReceived(
-      AudioMsg_NotifyStreamCreated(stream_id,
-                                   base::SharedMemory::NULLHandle(),
-                                   kLength));
+      AudioMsg_NotifyStreamCreated(
+          stream_id, base::SharedMemory::NULLHandle(),
+          socket_handle, kLength));
   EXPECT_TRUE(delegate.created_received());
   EXPECT_FALSE(base::SharedMemory::IsHandleValid(delegate.handle()));
   EXPECT_EQ(kLength, delegate.length());
   delegate.Reset();
 
-  // AudioMsg_NotifyStreamVolume
-  const double kVolume = 1.0;
-  EXPECT_FALSE(delegate.volume_received());
+  // AudioMsg_NotifyStreamStateChanged
+  EXPECT_FALSE(delegate.state_changed_received());
   filter->OnMessageReceived(
-      AudioMsg_NotifyStreamVolume(stream_id, kVolume));
-  EXPECT_TRUE(delegate.volume_received());
-  EXPECT_EQ(kVolume, delegate.volume());
+      AudioMsg_NotifyStreamStateChanged(stream_id, kAudioStreamPlaying));
+  EXPECT_TRUE(delegate.state_changed_received());
+  EXPECT_TRUE(kAudioStreamPlaying == delegate.state());
   delegate.Reset();
 
   message_loop.RunAllPending();
@@ -153,34 +119,34 @@ TEST(AudioMessageFilterTest, Delegates) {
   int stream_id2 = filter->AddDelegate(&delegate2);
 
   // Send an IPC message. Make sure the correct delegate gets called.
-  EXPECT_FALSE(delegate1.request_packet_received());
-  EXPECT_FALSE(delegate2.request_packet_received());
+  EXPECT_FALSE(delegate1.state_changed_received());
+  EXPECT_FALSE(delegate2.state_changed_received());
   filter->OnMessageReceived(
-      AudioMsg_RequestPacket(stream_id1, AudioBuffersState()));
-  EXPECT_TRUE(delegate1.request_packet_received());
-  EXPECT_FALSE(delegate2.request_packet_received());
+      AudioMsg_NotifyStreamStateChanged(stream_id1, kAudioStreamPlaying));
+  EXPECT_TRUE(delegate1.state_changed_received());
+  EXPECT_FALSE(delegate2.state_changed_received());
   delegate1.Reset();
 
-  EXPECT_FALSE(delegate1.request_packet_received());
-  EXPECT_FALSE(delegate2.request_packet_received());
+  EXPECT_FALSE(delegate1.state_changed_received());
+  EXPECT_FALSE(delegate2.state_changed_received());
   filter->OnMessageReceived(
-      AudioMsg_RequestPacket(stream_id2, AudioBuffersState()));
-  EXPECT_FALSE(delegate1.request_packet_received());
-  EXPECT_TRUE(delegate2.request_packet_received());
+      AudioMsg_NotifyStreamStateChanged(stream_id2, kAudioStreamPlaying));
+  EXPECT_FALSE(delegate1.state_changed_received());
+  EXPECT_TRUE(delegate2.state_changed_received());
   delegate2.Reset();
 
   // Remove the delegates. Make sure they won't get called.
   filter->RemoveDelegate(stream_id1);
-  EXPECT_FALSE(delegate1.request_packet_received());
+  EXPECT_FALSE(delegate1.state_changed_received());
   filter->OnMessageReceived(
-      AudioMsg_RequestPacket(stream_id1, AudioBuffersState()));
-  EXPECT_FALSE(delegate1.request_packet_received());
+      AudioMsg_NotifyStreamStateChanged(stream_id1, kAudioStreamPlaying));
+  EXPECT_FALSE(delegate1.state_changed_received());
 
   filter->RemoveDelegate(stream_id2);
-  EXPECT_FALSE(delegate2.request_packet_received());
+  EXPECT_FALSE(delegate2.state_changed_received());
   filter->OnMessageReceived(
-      AudioMsg_RequestPacket(stream_id2, AudioBuffersState()));
-  EXPECT_FALSE(delegate2.request_packet_received());
+      AudioMsg_NotifyStreamStateChanged(stream_id2, kAudioStreamPlaying));
+  EXPECT_FALSE(delegate2.state_changed_received());
 
   message_loop.RunAllPending();
 }