Add a parameter to CreateAudioStream to choose between standard and low-latency mode.

chrome/browser/renderer_host/audio_renderer_host.cc

 // Copyright (c) 2010 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.
 //
 // TODO(hclam): Several changes need to be made to this code:
 // 1. We should host AudioRendererHost on a dedicated audio thread. Doing
 //    so we don't have to worry about blocking method calls such as
 //    play / stop an audio stream.
 // 2. Move locked data structures into a separate structure that sanity
 //    checks access by different threads that use it.
@@ skipping 77 matching lines @@
     AudioRendererHost* host,
     int process_id,
     int route_id,
     int stream_id,
     base::ProcessHandle process_handle,
     AudioManager::Format format,
     int channels,
     int sample_rate,
     char bits_per_sample,
     uint32 decoded_packet_size,
-    uint32 buffer_capacity) {
+    uint32 buffer_capacity,
+    bool low_latency) {
   // Perform come preliminary checks on the parameters.
   // Make sure the renderer didn't ask for too much memory.
   if (buffer_capacity > kMaxBufferCapacity ||
       decoded_packet_size > kMaxDecodedPacketSize)
     return NULL;
 
   // Make sure the packet size and buffer capacity parameters are valid.
   if (buffer_capacity < decoded_packet_size)
     return NULL;
 
@@ skipping 37 matching lines @@
     // Note that the low latency mode is not yet ready and the if part of this
     // method is never executed. TODO(cpu): Enable this mode.
 
     if (source->shared_memory_.Create(L"",
                                       false,
                                       false,
                                       decoded_packet_size) &&
         source->shared_memory_.Map(decoded_packet_size) &&
         source->shared_memory_.ShareToProcess(process_handle,
                                               &foreign_memory_handle)) {
-      // TODO(cpu): better define what triggers the low latency mode.
-      if (decoded_packet_size > kLowLatencyPacketThreshold) {
-        // Regular latency mode.
-        host->Send(new ViewMsg_NotifyAudioStreamCreated(
-            route_id, stream_id, foreign_memory_handle, decoded_packet_size));
-
-        // Also request the first packet to kick start the pre-rolling.
-        source->StartBuffering();
-        return source;
-      } else {
+      if (low_latency) {
         // Low latency mode. We use SyncSocket to signal.
         base::SyncSocket* sockets[2] = {0};
         if (base::SyncSocket::CreatePair(sockets)) {
           source->shared_socket_.reset(sockets[0]);
 #if defined(OS_WIN)
           HANDLE foreign_socket_handle = 0;
           ::DuplicateHandle(GetCurrentProcess(), sockets[1]->handle(),
                             process_handle, &foreign_socket_handle,
                             0, FALSE, DUPLICATE_SAME_ACCESS);
           bool valid = foreign_socket_handle != 0;
 #else
           base::FileDescriptor foreign_socket_handle(sockets[1]->handle(),
                                                      false);
           bool valid = foreign_socket_handle.fd != -1;
 #endif
 
           if (valid) {
             host->Send(new ViewMsg_NotifyLowLatencyAudioStreamCreated(
                 route_id, stream_id, foreign_memory_handle,
                 foreign_socket_handle, decoded_packet_size));
             return source;
           }
         }
+      } else {
+        // Regular latency mode.
+        host->Send(new ViewMsg_NotifyAudioStreamCreated(
+            route_id, stream_id, foreign_memory_handle, decoded_packet_size));
+
+        // Also request the first packet to kick start the pre-rolling.
+        source->StartBuffering();
+        return source;
       }
     }
     // Failure. Close and free acquired resources.
     source->Close();
     delete source;
   }
 
   host->SendErrorMessage(route_id, stream_id);
   return NULL;
 }
@@ skipping 256 matching lines @@
     case ViewHostMsg_SetAudioVolume::ID:
       return true;
     default:
       break;
     }
     return false;
 }
 
 void AudioRendererHost::OnCreateStream(
     const IPC::Message& msg, int stream_id,
-    const ViewHostMsg_Audio_CreateStream_Params& params) {
+    const ViewHostMsg_Audio_CreateStream_Params& params, bool low_latency) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   DCHECK(Lookup(msg.routing_id(), stream_id) == NULL);
 
   IPCAudioSource* source = IPCAudioSource::CreateIPCAudioSource(
       this,
       process_id_,
       msg.routing_id(),
       stream_id,
       process_handle_,
       params.format,
       params.channels,
       params.sample_rate,
       params.bits_per_sample,
       params.packet_size,
-      params.buffer_capacity);
+      params.buffer_capacity,
+      low_latency);
 
   // If we have created the source successfully, adds it to the map.
   if (source) {
     sources_.insert(
         std::make_pair(
             SourceID(source->route_id(), source->stream_id()), source));
   } else {
     SendErrorMessage(msg.routing_id(), stream_id);
   }
 }
@@ skipping 125 matching lines @@
 
 void AudioRendererHost::DestroySource(IPCAudioSource* source) {
   if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
     OnDestroySource(source);
   } else {
     ChromeThread::PostTask(
         ChromeThread::IO, FROM_HERE,
         NewRunnableMethod(this, &AudioRendererHost::OnDestroySource, source));
   }
 }