Notify hotwording extension of microphone state change.

chrome/browser/search/hotword_service.cc

 // Copyright 2013 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 "chrome/browser/search/hotword_service.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/i18n/case_conversion.h"
@@ skipping 305 matching lines @@
 };
 #endif
 
 void HotwordService::HotwordWebstoreInstaller::Shutdown() {
   AbortInstall();
 }
 
 HotwordService::HotwordService(Profile* profile)
     : profile_(profile),
       extension_registry_observer_(this),
+      microphone_available_(false),
+      audio_device_state_updated_(false),
       client_(NULL),
       error_message_(0),
       reinstall_pending_(false),
       training_(false),
       weak_factory_(this) {
   extension_registry_observer_.Add(extensions::ExtensionRegistry::Get(profile));
 
   // Disable the old extension so it doesn't interfere with the new stuff.
   ExtensionService* extension_service = GetExtensionService(profile_);
   if (extension_service) {
@@ skipping 43 matching lines @@
     }
   }
 
 #if defined(OS_CHROMEOS)
   if (user_manager::UserManager::IsInitialized()) {
     session_observer_.reset(new HotwordUserSessionStateObserver(this));
     user_manager::UserManager::Get()->AddSessionStateObserver(
         session_observer_.get());
   }
 #endif
+
+  // Register with the device observer list to update the microphone
+  // availability.
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(&HotwordService::InitializeMicrophoneObserver,
+                 base::Unretained(this)));
 }
 
 HotwordService::~HotwordService() {
 #if defined(OS_CHROMEOS)
   if (user_manager::UserManager::IsInitialized() && session_observer_) {
     user_manager::UserManager::Get()->RemoveSessionStateObserver(
         session_observer_.get());
   }
 #endif
 }
@@ skipping 50 matching lines @@
     return;
 
   InstallHotwordExtensionFromWebstore(kMaxInstallRetries);
   SetPreviousLanguagePref();
 }
 
 std::string HotwordService::ReinstalledExtensionId() {
   return extension_misc::kHotwordSharedModuleId;
 }
 
+void HotwordService::InitializeMicrophoneObserver() {
+  MediaCaptureDevicesDispatcher::GetInstance()->AddObserver(this);
+}
+
 void HotwordService::InstalledFromWebstoreCallback(
     int num_tries,
     bool success,
     const std::string& error,
     extensions::webstore_install::Result result) {
   if (result != extensions::webstore_install::SUCCESS && num_tries) {
     // Try again on failure.
     content::BrowserThread::PostDelayedTask(
         content::BrowserThread::UI,
         FROM_HERE,
@@ skipping 129 matching lines @@
     content::WebPluginInfo info;
     PluginPrefs* plugin_prefs = PluginPrefs::GetForProfile(profile_).get();
     if (content::PluginService::GetInstance()->GetPluginInfoByPath(path, &info))
       nacl_enabled = plugin_prefs->IsPluginEnabled(info);
   }
   if (!nacl_enabled)
     error_message_ = IDS_HOTWORD_NACL_DISABLED_ERROR_MESSAGE;
 
   RecordErrorMetrics(error_message_);
 
-  // Determine if the proper audio capabilities exist.
-  // The first time this is called, it probably won't return in time, but that's
-  // why it won't be included in the error calculation (i.e., the call to
-  // IsAudioDeviceStateUpdated()). However, this use case is rare and typically
-  // the devices will be initialized by the time a user goes to settings.
-  bool audio_device_state_updated =
-      HotwordServiceFactory::IsAudioDeviceStateUpdated();
+  // Determine if the proper audio capabilities exist. The first time this is
+  // called, it probably won't return in time, but that's why it won't be
+  // included in the error calculation. However, this use case is rare and
+  // typically the devices will be initialized by the time a user goes to
+  // settings.
   HotwordServiceFactory::GetInstance()->UpdateMicrophoneState();
-  if (audio_device_state_updated) {
+  if (audio_device_state_updated_) {
     bool audio_capture_allowed =
         profile_->GetPrefs()->GetBoolean(prefs::kAudioCaptureAllowed);
-    if (!audio_capture_allowed ||
-        !HotwordServiceFactory::IsMicrophoneAvailable())
+    if (!audio_capture_allowed || !microphone_available_)
       error_message_ = IDS_HOTWORD_MICROPHONE_ERROR_MESSAGE;
   }
 
   return (error_message_ == 0) && IsHotwordAllowed();
 }
 
 bool HotwordService::IsHotwordAllowed() {
   std::string group = base::FieldTrialList::FindFullName(
       hotword_internal::kHotwordFieldTrialName);
   // Allow hotwording by default, and only disable if the field trial has been
@@ skipping 134 matching lines @@
 void HotwordService::DisableHotwordPreferences() {
   if (IsSometimesOnEnabled()) {
     profile_->GetPrefs()->SetBoolean(prefs::kHotwordSearchEnabled, false);
   }
   if (IsAlwaysOnEnabled()) {
     profile_->GetPrefs()->SetBoolean(prefs::kHotwordAlwaysOnSearchEnabled,
                                      false);
   }
 }
 
+void HotwordService::OnUpdateAudioDevices(
+    const content::MediaStreamDevices& devices) {
+  bool microphone_was_available = microphone_available_;
+  microphone_available_ = !devices.empty();
+  audio_device_state_updated_ = true;
+  HotwordPrivateEventService* event_service =
+      BrowserContextKeyedAPIFactory<HotwordPrivateEventService>::Get(profile_);
+  if (event_service && microphone_was_available != microphone_available_)
+    event_service->OnMicrophoneStateChanged(microphone_available_);
+}
+
 void HotwordService::OnHotwordAlwaysOnSearchEnabledChanged(
     const std::string& pref_name) {
   // If the pref for always on has been changed in some way, that means that
   // the user is aware of always on (either from settings or another source)
   // so they don't need to be shown the notification.
   profile_->GetPrefs()->SetBoolean(prefs::kHotwordAlwaysOnNotificationSeen,
                                    true);
   pref_registrar_.Remove(prefs::kHotwordAlwaysOnSearchEnabled);
 }
 
@@ skipping 62 matching lines @@
   // Only support multiple profiles and profile switching in ChromeOS.
   if (user_manager::UserManager::IsInitialized()) {
     user_manager::User* user =
         user_manager::UserManager::Get()->GetActiveUser();
     if (user && user->is_profile_created())
       return profile_ == ProfileManager::GetActiveUserProfile();
   }
 #endif
   return true;
 }