Open the launcher when hotword is triggered in always-on mode.

chrome/browser/ui/app_list/app_list_view_delegate.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 "chrome/browser/ui/app_list/app_list_view_delegate.h"
 
 #include <vector>
 
 #include "apps/custom_launcher_page_contents.h"
 #include "base/callback.h"
@@ skipping 454 matching lines @@
   if (!profile_)
     return;
 
   app_list::StartPageService* service =
       app_list::StartPageService::Get(profile_);
   if (service) {
     service->AppListHidden();
     if (service->HotwordEnabled()) {
       HotwordService* hotword_service =
           HotwordServiceFactory::GetForProfile(profile_);
-      if (hotword_service)
+      if (hotword_service) {
         hotword_service->StopHotwordSession(this);
+
+        // If we're in always-on mode, we always want to restart hotwording
+        // after closing the launcher window. So, in always-on mode, hotwording
+        // is stopped, and then started again right away. Note that hotwording
+        // may already be stopped. The call to StopHotwordSession() above both
+        // explicitly stops hotwording, if it's running, and clears the
+        // association between the hotword service and |this|.  When starting up
+        // hotwording, pass nullptr as the client so that hotword triggers cause
+        // the launcher to open.
+        // TODO(amistry): This only works on ChromeOS since Chrome hides the
+        // launcher instead of destroying it. Make this work on Chrome.
+        if (hotword_service->IsAlwaysOnEnabled())
+          hotword_service->RequestHotwordSession(nullptr);
+      }
     }
   }
 }
 
 gfx::ImageSkia AppListViewDelegate::GetWindowIcon() {
   return controller_->GetWindowIcon();
 }
 
 void AppListViewDelegate::OpenSettings() {
   const extensions::Extension* extension =
@@ skipping 25 matching lines @@
   Browser* browser = chrome::FindTabbedBrowser(profile_, false, desktop);
   chrome::ShowFeedbackPage(browser, std::string(),
                            chrome::kAppLauncherCategoryTag);
 }
 
 void AppListViewDelegate::ToggleSpeechRecognition() {
   app_list::StartPageService* service =
       app_list::StartPageService::Get(profile_);
   if (service)
     service->ToggleSpeechRecognition();
+
+  // With the new hotword extension, stop the hotword session. With the launcher
+  // and NTP, this is unnecessary since the hotwording is implicitly stopped.
+  // However, for always on, hotword triggering launches the launcher which
+  // starts a session and hence starts the hotword detector. This results in the
+  // hotword detector and the speech-to-text engine running in parallel, which
+  // will conflict with each other (i.e. saying 'Ok Google' twice in a row
+  // should cause a search to happen for 'Ok Google', not two hotword triggers).
+  // To get around this, always stop the session when switching to speech
+  // recognition.
+  if (HotwordService::IsExperimentalHotwordingEnabled() &&
+      service && service->HotwordEnabled()) {
+    HotwordService* hotword_service =
+        HotwordServiceFactory::GetForProfile(profile_);
+    if (hotword_service)
+      hotword_service->StopHotwordSession(this);
+  }
 }
 
 void AppListViewDelegate::ShowForProfileByPath(
     const base::FilePath& profile_path) {
   controller_->ShowForProfileByPath(profile_path);
 }
 
 void AppListViewDelegate::OnSpeechResult(const base::string16& result,
                                          bool is_final) {
   speech_ui_->SetSpeechResult(result, is_final);
   if (is_final) {
     auto_launch_timeout_ = base::TimeDelta::FromMilliseconds(
         kAutoLaunchDefaultTimeoutMilliSec);
     model_->search_box()->SetText(result);
   }
 }
 
 void AppListViewDelegate::OnSpeechSoundLevelChanged(int16 level) {
   speech_ui_->UpdateSoundLevel(level);
 }
 
 void AppListViewDelegate::OnSpeechRecognitionStateChanged(
     app_list::SpeechRecognitionState new_state) {
   speech_ui_->SetSpeechRecognitionState(new_state);
 
   app_list::StartPageService* service =
       app_list::StartPageService::Get(profile_);
   // With the new hotword extension, we need to re-request hotwording after
-  // speech recognition has stopped.
+  // speech recognition has stopped. Do not request hotwording after the app
+  // list has already closed.
   if (new_state == app_list::SPEECH_RECOGNITION_READY &&
       HotwordService::IsExperimentalHotwordingEnabled() &&
-      service && service->HotwordEnabled()) {
+      service && service->HotwordEnabled() &&
+      controller_->GetAppListWindow()) {
     HotwordService* hotword_service =
         HotwordServiceFactory::GetForProfile(profile_);
     if (hotword_service) {
       hotword_service->RequestHotwordSession(this);
     }
   }
 }
 
 #if defined(TOOLKIT_VIEWS)
 views::View* AppListViewDelegate::CreateStartPageWebView(
@@ skipping 98 matching lines @@
 
       // SigninManagerFactory is not a leaky singleton (unlike this class), and
       // its destructor will check that it has no remaining observers.
       scoped_observer_.RemoveAll();
       SigninManagerFactory::GetInstance()->RemoveObserver(this);
       break;
     default:
       NOTREACHED();
   }
 }