Getting rid of AudioHardwareConfig and its synchronous IPC.

content/renderer/media/audio_renderer_sink_cache_impl.cc

 // Copyright 2016 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 <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/synchronization/lock.h"
@@ skipping 61 matching lines @@
              << " - used session to create new sink.";
 
     // Cache a newly-created sink.
     base::AutoLock auto_lock(cache_lock_);
     cache_.push_back(cache_entry);
 
   } else {
     // Ignore session id.
     base::AutoLock auto_lock(cache_lock_);
 
-    auto cache_iter =
-        FindCacheEntry_Locked(source_render_frame_id, device_id,
-                              security_origin, false /* unused_only */);
+    if (media::AudioDeviceDescription::IsDefaultDevice(device_id)) {
+      if (default_device_info_)
+        return default_device_info_.value();
 
-    if (cache_iter != cache_.end()) {
-      // A matching cached sink is found.
-      DVLOG(1) << "GetSinkInfo: address: " << cache_iter->sink.get()
-               << " - reused a cached sink.";
+      // Otherwise, there is no default device cached.
+      DCHECK(FindCacheEntry_Locked(source_render_frame_id, device_id,
+                                   security_origin, false) == cache_.end());
+    } else {
+      // Looking up a cached non-default device.
+      auto cache_iter = FindCacheEntry_Locked(source_render_frame_id, device_id,
+                                              security_origin, false);
 
-      return cache_iter->sink->GetOutputDeviceInfo();
+      if (cache_iter != cache_.end()) {
+        // A matching cached sink is found.
+        DVLOG(1) << "GetSinkInfo: address: " << cache_iter->sink.get()
+                 << " - reused a cached sink.";
+
+        return cache_iter->sink->GetOutputDeviceInfo();
+      }
     }
 
     // No matching sink found, create a new one.
     cache_entry.device_id = device_id;
     cache_entry.sink = create_sink_cb_.Run(
         source_render_frame_id, 0 /* session_id */, device_id, security_origin);
 
     DVLOG(1) << "GetSinkInfo: address: " << cache_entry.sink.get()
              << " - no matching cached sink found, created a new one.";
 
     // Cache a newly-created sink.
     cache_.push_back(cache_entry);
+
+    // Cache information for default output device.

[DaleCurtis, 2016/07/06 18:53:37]

Do we want to cache this? We'll carry over bugs around plugging in new default
devices when a renderer has been created and audio started. I.e., old parameters
will be used.

[o1ka, 2016/07/13 09:52:41]

removed

+    if (media::AudioDeviceDescription::IsDefaultDevice(device_id))
+      default_device_info_ = cache_entry.sink->GetOutputDeviceInfo();
   }
 
   // Schedule it for deletion.
   DeleteLaterIfUnused(cache_entry.sink.get());
 
   DVLOG(1) << "GetSinkInfo: address: " << cache_entry.sink.get()
            << " created. source_render_frame_id: " << source_render_frame_id
            << " session_id: " << session_id << " device_id: " << device_id
            << " security_origin: " << security_origin;
 
   return cache_entry.sink->GetOutputDeviceInfo();
 }
 
 scoped_refptr<media::AudioRendererSink> AudioRendererSinkCacheImpl::GetSink(
     int source_render_frame_id,
     const std::string& device_id,
     const url::Origin& security_origin) {
   base::AutoLock auto_lock(cache_lock_);
 
   auto cache_iter =
       FindCacheEntry_Locked(source_render_frame_id, device_id, security_origin,
-                            true /* unused_only */);
+                            true /* unused sink only */);
 
   if (cache_iter != cache_.end()) {
     // Found unused sink; mark it as used and return.
     DVLOG(1) << "GetSink: address: " << cache_iter->sink.get()
              << " - found unused cached sink, reusing it.";
 
     cache_iter->used = true;
     return cache_iter->sink;
   }
 
   // No unused sink is found, create one, mark it used, cache it and return.
   CacheEntry cache_entry = {
       source_render_frame_id, device_id, security_origin,
       create_sink_cb_.Run(source_render_frame_id, 0 /* session_id */, device_id,
                           security_origin),
       true /* used */};
 
   cache_.push_back(cache_entry);
 
+  // Update cached information for default output device.
+  if (media::AudioDeviceDescription::IsDefaultDevice(device_id))
+    default_device_info_ = cache_entry.sink->GetOutputDeviceInfo();
+
   DVLOG(1) << "GetSink: address: " << cache_entry.sink.get()
            << " - no unused cached sink found, created a new one."
            << " source_render_frame_id: " << source_render_frame_id
            << " device_id: " << device_id
            << " security_origin: " << security_origin;
   return cache_entry.sink;
 }
 
 void AudioRendererSinkCacheImpl::ReleaseSink(
     const media::AudioRendererSink* sink_ptr) {
@@ skipping 89 matching lines @@
         return val.device_id == device_id &&
                val.security_origin == security_origin;
       });
 };
 
 int AudioRendererSinkCacheImpl::GetCacheSizeForTesting() {
   return cache_.size();
 }
 
 }  // namespace content