Remove "high"-latency audio code path

content/renderer/pepper_plugin_delegate_impl.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 "content/renderer/pepper_plugin_delegate_impl.h"
 
 #include <cmath>
 #include <queue>
 
 #include "base/bind.h"
@@ skipping 178 matching lines @@
   virtual bool StopPlayback() OVERRIDE;
   virtual void ShutDown() OVERRIDE;
 
  private:
   // I/O thread backends to above functions.
   void InitializeOnIOThread(const AudioParameters& params);
   void StartPlaybackOnIOThread();
   void StopPlaybackOnIOThread();
   void ShutDownOnIOThread();
 
-  virtual void OnRequestPacket(AudioBuffersState buffers_state) OVERRIDE {
-    LOG(FATAL) << "Should never get OnRequestPacket in PlatformAudioImpl";
-  }
-
   virtual void OnStateChanged(AudioStreamState state) OVERRIDE {}
 
-  virtual void OnCreated(base::SharedMemoryHandle handle,
-                         uint32 length) OVERRIDE {
-    LOG(FATAL) << "Should never get OnCreated in PlatformAudioImpl";
-  }
-
-  virtual void OnLowLatencyCreated(base::SharedMemoryHandle handle,
-                                   base::SyncSocket::Handle socket_handle,
-                                   uint32 length) OVERRIDE;
-
-  virtual void OnVolume(double volume) OVERRIDE {}
+  virtual void OnStreamCreated(base::SharedMemoryHandle handle,
+                               base::SyncSocket::Handle socket_handle,
+                               uint32 length) OVERRIDE;
 
   // The client to notify when the stream is created. THIS MUST ONLY BE
   // ACCESSED ON THE MAIN THREAD.
   webkit::ppapi::PluginDelegate::PlatformAudioCommonClient* client_;
 
   // MessageFilter used to send/receive IPC. THIS MUST ONLY BE ACCESSED ON THE
   // I/O thread except to send messages and get the message loop.
   scoped_refptr<AudioMessageFilter> filter_;
 
   // Our ID on the MessageFilter. THIS MUST ONLY BE ACCESSED ON THE I/O THREAD
@@ skipping 52 matching lines @@
   // Called on the main thread to stop all audio callbacks. We must only change
   // the client on the main thread, and the delegates from the I/O thread.
   client_ = NULL;
   ChildProcess::current()->io_message_loop()->PostTask(
       FROM_HERE,
       base::Bind(&PlatformAudioImpl::ShutDownOnIOThread, this));
 }
 
 void PlatformAudioImpl::InitializeOnIOThread(const AudioParameters& params) {
   stream_id_ = filter_->AddDelegate(this);
-  filter_->Send(new AudioHostMsg_CreateStream(stream_id_, params, true));
+  filter_->Send(new AudioHostMsg_CreateStream(stream_id_, params));
 }
 
 void PlatformAudioImpl::StartPlaybackOnIOThread() {
   if (stream_id_)
     filter_->Send(new AudioHostMsg_PlayStream(stream_id_));
 }
 
 void PlatformAudioImpl::StopPlaybackOnIOThread() {
   if (stream_id_)
     filter_->Send(new AudioHostMsg_PauseStream(stream_id_));
 }
 
 void PlatformAudioImpl::ShutDownOnIOThread() {
   // Make sure we don't call shutdown more than once.
   if (!stream_id_)
     return;
 
   filter_->Send(new AudioHostMsg_CloseStream(stream_id_));
   filter_->RemoveDelegate(stream_id_);
   stream_id_ = 0;
 
   Release();  // Release for the delegate, balances out the reference taken in
               // PepperPluginDelegateImpl::CreateAudio.
 }
 
-void PlatformAudioImpl::OnLowLatencyCreated(
+void PlatformAudioImpl::OnStreamCreated(
     base::SharedMemoryHandle handle, base::SyncSocket::Handle socket_handle,
     uint32 length) {
 #if defined(OS_WIN)
   DCHECK(handle);
   DCHECK(socket_handle);
 #else
   DCHECK_NE(-1, handle.fd);
   DCHECK_NE(-1, socket_handle);
 #endif
   DCHECK(length);
 
   if (base::MessageLoopProxy::current() == main_message_loop_proxy_) {
     // Must dereference the client only on the main thread. Shutdown may have
     // occurred while the request was in-flight, so we need to NULL check.
     if (client_)
       client_->StreamCreated(handle, length, socket_handle);
   } else {
     main_message_loop_proxy_->PostTask(FROM_HERE,
-        base::Bind(&PlatformAudioImpl::OnLowLatencyCreated, this, handle,
+        base::Bind(&PlatformAudioImpl::OnStreamCreated, this, handle,
                    socket_handle, length));
   }
 }
 
 class PlatformAudioInputImpl
     : public webkit::ppapi::PluginDelegate::PlatformAudioInput,
       public AudioInputMessageFilter::Delegate,
       public base::RefCountedThreadSafe<PlatformAudioInputImpl> {
  public:
   PlatformAudioInputImpl()
@@ skipping 1765 matching lines @@
 void PepperPluginDelegateImpl::UnSetAndDeleteLockTargetAdapter(
     webkit::ppapi::PluginInstance* instance) {
   LockTargetMap::iterator it = mouse_lock_instances_.find(instance);
   if (it != mouse_lock_instances_.end()) {
     MouseLockDispatcher::LockTarget* target = it->second;
     render_view_->mouse_lock_dispatcher()->OnLockTargetDestroyed(target);
     delete target;
     mouse_lock_instances_.erase(it);
   }
 }