Disable enumeration caching for output devices.

content/browser/renderer_host/media/media_stream_manager.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/browser/renderer_host/media/media_stream_manager.h"
 
 #include <cctype>
 #include <list>
 #include <vector>
 
@@ skipping 212 matching lines @@
 #endif
 }
 
 bool CalledOnIOThread() {
   // Check if this function call is on the IO thread, except for unittests where
   // an IO thread might not have been created.
   return BrowserThread::CurrentlyOn(BrowserThread::IO) ||
          !BrowserThread::IsMessageLoopValid(BrowserThread::IO);
 }
 
-void DummyEnumerationCallback(const AudioOutputDeviceEnumeration& e) {}
-
 }  // namespace
 
 
 // MediaStreamManager::DeviceRequest represents a request to either enumerate
 // available devices or open one or more devices.
 // TODO(perkj): MediaStreamManager still needs refactoring. I propose we create
 // several subclasses of DeviceRequest and move some of the responsibility of
 // the MediaStreamManager to the subclasses to get rid of the way too many if
 // statements in MediaStreamManager.
 class MediaStreamManager::DeviceRequest {
@@ skipping 710 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (monitoring_started_)
     return;
 
   if (!base::SystemMonitor::Get())
     return;
 
   monitoring_started_ = true;
   base::SystemMonitor::Get()->AddDevicesChangedObserver(this);
 
-  // Enable caching for audio output device enumerations and do an enumeration
-  // to populate the cache.
-  audio_output_device_enumerator_->SetCachePolicy(
-      AudioOutputDeviceEnumerator::CACHE_POLICY_MANUAL_INVALIDATION);
-  audio_output_device_enumerator_->Enumerate(
-      base::Bind(&DummyEnumerationCallback));
-
   // Enumerate both the audio and video input devices to cache the device lists
   // and send them to media observer.
   ++active_enumeration_ref_count_[MEDIA_DEVICE_AUDIO_CAPTURE];
   audio_input_device_manager_->EnumerateDevices(MEDIA_DEVICE_AUDIO_CAPTURE);
   ++active_enumeration_ref_count_[MEDIA_DEVICE_VIDEO_CAPTURE];
   video_capture_manager_->EnumerateDevices(MEDIA_DEVICE_VIDEO_CAPTURE);
 
 #if defined(OS_MACOSX)
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
@@ skipping 1081 matching lines @@
 void MediaStreamManager::OnDevicesChanged(
     base::SystemMonitor::DeviceType device_type) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // NOTE: This method is only called in response to physical audio/video device
   // changes (from the operating system).
 
   MediaStreamType stream_type;
   if (device_type == base::SystemMonitor::DEVTYPE_AUDIO_CAPTURE) {
     stream_type = MEDIA_DEVICE_AUDIO_CAPTURE;
-    audio_output_device_enumerator_->InvalidateCache();
   } else if (device_type == base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE) {
     stream_type = MEDIA_DEVICE_VIDEO_CAPTURE;
   } else {
     return;  // Uninteresting device change.
   }
 
   // Always do enumeration even though some enumeration is in progress, because
   // those enumeration commands could be sent before these devices change.
   ++active_enumeration_ref_count_[stream_type];
   GetDeviceManager(stream_type)->EnumerateDevices(stream_type);
@@ skipping 79 matching lines @@
     const std::string& device_guid,
     const std::string& raw_unique_id) {
   DCHECK(security_origin.is_valid());
   DCHECK(!raw_unique_id.empty());
   std::string guid_from_raw_device_id =
       GetHMACForMediaDeviceID(sc, security_origin, raw_unique_id);
   return guid_from_raw_device_id == device_guid;
 }
 
 }  // namespace content