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 38 matching lines @@
 
 AudioRendererSinkCacheImpl::~AudioRendererSinkCacheImpl() {
   // We just release all the cached sinks here.
 }
 
 media::OutputDeviceInfo AudioRendererSinkCacheImpl::GetSinkInfo(
     int source_render_frame_id,
     int session_id,
     const std::string& device_id,
     const url::Origin& security_origin) {
   CacheEntry cache_entry = {source_render_frame_id,

[Guido Urdaneta, 2016/07/05 15:10:39]

Should this have a thread check to make sure there are no races?

[Guido Urdaneta, 2016/07/05 15:16:20]

Forget about this. I didn't see the lock.

[o1ka, 2016/07/05 15:16:38]

It's all protected by |cache_lock_| :)

                             std::string() /* device_id */, security_origin,
                             nullptr /* sink */, false /* not used */};
 
   if (media::AudioDeviceDescription::UseSessionIdToSelectDevice(session_id,
                                                                 device_id)) {
     // We are provided with session id instead of device id. Session id is
     // unique, so we can't find any matching sink. Creating a new one.
     cache_entry.sink = create_sink_cb_.Run(source_render_frame_id, session_id,
                                            device_id, security_origin);
     cache_entry.device_id = cache_entry.sink->GetOutputDeviceInfo().device_id();
 
     DVLOG(1) << "GetSinkInfo: address: " << cache_entry.sink.get()
              << " - 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 /* unused_only */) == cache_.end());

[Guido Urdaneta, 2016/07/05 15:10:39]

the /* unused_only */ comment does not add any information to me.

+    } else {
+      // Looking up a cached non-default device.
+      auto cache_iter =
+          FindCacheEntry_Locked(source_render_frame_id, device_id,
+                                security_origin, false /* unused_only */);
 
-      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.
+    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;
 
@@ skipping 21 matching lines @@
 
   // 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