Delete the old hotwording integration.

chrome/browser/ui/app_list/start_page_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/ui/app_list/start_page_service.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 263 matching lines @@
 };
 
 // static
 StartPageService* StartPageService::Get(Profile* profile) {
   return StartPageServiceFactory::GetForProfile(profile);
 }
 
 StartPageService::StartPageService(Profile* profile)
     : profile_(profile),
       profile_destroy_observer_(new ProfileDestroyObserver(this)),
-      state_(app_list::SPEECH_RECOGNITION_OFF),
+      state_(app_list::SPEECH_RECOGNITION_READY),
       speech_button_toggled_manually_(false),
       speech_result_obtained_(false),
       webui_finished_loading_(false),
       speech_auth_helper_(new SpeechAuthHelper(profile, &clock_)),
       network_available_(true),
       microphone_available_(true),
       search_engine_is_google_(false),
       weak_factory_(this) {
-  // If experimental hotwording is enabled, then we're always "ready".
-  // Transitioning into the "hotword recognizing" state is handled by the
-  // hotword extension.
-  if (HotwordService::IsExperimentalHotwordingEnabled()) {
-    state_ = app_list::SPEECH_RECOGNITION_READY;
-  }
   if (switches::IsExperimentalAppListEnabled()) {
     TemplateURLService* template_url_service =
         TemplateURLServiceFactory::GetForProfile(profile_);
     const TemplateURL* default_provider =
         template_url_service->GetDefaultSearchProvider();
     search_engine_is_google_ =
         TemplateURLPrepopulateData::GetEngineType(
             *default_provider, template_url_service->search_terms_data()) ==
         SEARCH_ENGINE_GOOGLE;
   }
@@ skipping 53 matching lines @@
 bool StartPageService::ShouldEnableSpeechRecognition() const {
   return microphone_available_ && network_available_;
 }
 
 void StartPageService::AppListShown() {
   if (!contents_) {
     LoadContents();
   } else if (contents_->IsCrashed()) {
     LoadStartPageURL();
   } else if (contents_->GetWebUI()) {
-    // If experimental hotwording is enabled, don't initialize the web speech
-    // API, which is not used with
-    // experimental hotwording.
     contents_->GetWebUI()->CallJavascriptFunction(
-        "appList.startPage.onAppListShown",
-        base::FundamentalValue(HotwordEnabled()),
-        base::FundamentalValue(
-            !HotwordService::IsExperimentalHotwordingEnabled()));
+        "appList.startPage.onAppListShown");
   }
 
 #if defined(OS_CHROMEOS)
   audio_status_.reset(new AudioStatus(this));
 #endif
 }
 
 void StartPageService::AppListHidden() {
-  if (contents_->GetWebUI()) {
-    contents_->GetWebUI()->CallJavascriptFunction(
-        "appList.startPage.onAppListHidden");
-  }
   if (!app_list::switches::IsExperimentalAppListEnabled())
     UnloadContents();
 
-  if (HotwordService::IsExperimentalHotwordingEnabled() &&
-      speech_recognizer_) {
+  if (speech_recognizer_) {
     speech_recognizer_->Stop();
     speech_recognizer_.reset();
 
     // When the SpeechRecognizer is destroyed above, we get stuck in the current
     // speech state instead of being reset into the READY state. Reset the
     // speech state explicitly so that speech works when the launcher is opened
     // again.
     OnSpeechRecognitionStateChanged(SPEECH_RECOGNITION_READY);
   }
 
 #if defined(OS_CHROMEOS)
   audio_status_.reset();
 #endif
 }
 
 void StartPageService::ToggleSpeechRecognition(
     const scoped_refptr<content::SpeechRecognitionSessionPreamble>& preamble) {
   DCHECK(contents_);
   speech_button_toggled_manually_ = true;
 
-  // Speech recognition under V2 hotwording does not depend in any way on the
-  // start page web contents. Do this code path first to make this explicit and
-  // easier to identify what code needs to be deleted when V2 hotwording is
-  // stable.
-  if (HotwordService::IsExperimentalHotwordingEnabled()) {
-    if (!speech_recognizer_) {
-      std::string profile_locale;
+  if (!speech_recognizer_) {
+    std::string profile_locale;
 #if defined(OS_CHROMEOS)
-      profile_locale = profile_->GetPrefs()->GetString(
-          prefs::kApplicationLocale);
+    profile_locale = profile_->GetPrefs()->GetString(
+        prefs::kApplicationLocale);
 #endif
-      if (profile_locale.empty())
-        profile_locale = g_browser_process->GetApplicationLocale();
+    if (profile_locale.empty())
+      profile_locale = g_browser_process->GetApplicationLocale();
 
-      speech_recognizer_.reset(
-          new SpeechRecognizer(weak_factory_.GetWeakPtr(),
-                               profile_->GetRequestContext(),
-                               profile_locale));
-    }
-
-    speech_recognizer_->Start(preamble);
-    return;
+    speech_recognizer_.reset(
+        new SpeechRecognizer(weak_factory_.GetWeakPtr(),
+                             profile_->GetRequestContext(),
+                             profile_locale));
   }
 
-  if (!contents_->GetWebUI())
-    return;
-
-  if (!webui_finished_loading_) {
-    pending_webui_callbacks_.push_back(
-        base::Bind(&StartPageService::ToggleSpeechRecognition,
-                   base::Unretained(this),
-                   preamble));
-    return;
-  }
-
-  contents_->GetWebUI()->CallJavascriptFunction(
-      "appList.startPage.toggleSpeechRecognition");
+  speech_recognizer_->Start(preamble);
 }
 
 bool StartPageService::HotwordEnabled() {
 // Voice input for the launcher is unsupported on non-ChromeOS platforms.
 // TODO(amistry): Make speech input, and hotwording, work on non-ChromeOS.
 #if defined(OS_CHROMEOS)
-  if (HotwordService::IsExperimentalHotwordingEnabled()) {
-    HotwordService* service = HotwordServiceFactory::GetForProfile(profile_);
-    return state_ != SPEECH_RECOGNITION_OFF &&
-        service &&
-        (service->IsSometimesOnEnabled() || service->IsAlwaysOnEnabled()) &&
-        service->IsServiceAvailable();
-  }
-  return HotwordServiceFactory::IsServiceAvailable(profile_) &&
-      profile_->GetPrefs()->GetBoolean(prefs::kHotwordSearchEnabled);
+  HotwordService* service = HotwordServiceFactory::GetForProfile(profile_);
+  return state_ != SPEECH_RECOGNITION_OFF &&
+      service &&
+      (service->IsSometimesOnEnabled() || service->IsAlwaysOnEnabled()) &&
+      service->IsServiceAvailable();
 #else
   return false;
 #endif
 }
 
 content::WebContents* StartPageService::GetStartPageContents() {
   return app_list::switches::IsExperimentalAppListEnabled() ? contents_.get()
                                                             : NULL;
 }
 
@@ skipping 29 matching lines @@
   // Sometimes this can be called even though there are no audio input devices.
   if (audio_status_ && !audio_status_->CanListen())
     new_state = SPEECH_RECOGNITION_OFF;
 #endif
   if (!ShouldEnableSpeechRecognition())
     new_state = SPEECH_RECOGNITION_OFF;
 
   if (state_ == new_state)
     return;
 
-  if (HotwordService::IsExperimentalHotwordingEnabled() &&
-      (new_state == SPEECH_RECOGNITION_READY ||
+  if ((new_state == SPEECH_RECOGNITION_READY ||
        new_state == SPEECH_RECOGNITION_OFF) &&
       speech_recognizer_) {
     speech_recognizer_->Stop();
   }
 
   if (!InSpeechRecognition(state_) && InSpeechRecognition(new_state)) {
     if (!speech_button_toggled_manually_ &&
         state_ == SPEECH_RECOGNITION_HOTWORD_LISTENING) {
       RecordAction(UserMetricsAction("AppList_HotwordRecognized"));
     } else {
       RecordAction(UserMetricsAction("AppList_VoiceSearchStartedManually"));
     }
   } else if (InSpeechRecognition(state_) && !InSpeechRecognition(new_state) &&
              !speech_result_obtained_) {
     RecordAction(UserMetricsAction("AppList_VoiceSearchCanceled"));
   }
   speech_button_toggled_manually_ = false;
   speech_result_obtained_ = false;
   state_ = new_state;
   FOR_EACH_OBSERVER(StartPageObserver,
                     observers_,
                     OnSpeechRecognitionStateChanged(new_state));
 }
 
 void StartPageService::GetSpeechAuthParameters(std::string* auth_scope,
                                                std::string* auth_token) {
-  if (HotwordService::IsExperimentalHotwordingEnabled()) {
-    HotwordService* service = HotwordServiceFactory::GetForProfile(profile_);
-    if (service &&
-        service->IsOptedIntoAudioLogging() &&
-        service->IsAlwaysOnEnabled() &&
-        !speech_auth_helper_->GetToken().empty()) {
-      *auth_scope = speech_auth_helper_->GetScope();
-      *auth_token = speech_auth_helper_->GetToken();
-    }
+  HotwordService* service = HotwordServiceFactory::GetForProfile(profile_);
+  if (service &&
+      service->IsOptedIntoAudioLogging() &&
+      service->IsAlwaysOnEnabled() &&
+      !speech_auth_helper_->GetToken().empty()) {
+    *auth_scope = speech_auth_helper_->GetScope();
+    *auth_token = speech_auth_helper_->GetToken();
   }
 }
 
 void StartPageService::Shutdown() {
   UnloadContents();
 #if defined(OS_CHROMEOS)
   audio_status_.reset();
 #endif
 
   speech_auth_helper_.reset();
@@ skipping 126 matching lines @@
 
   // Check for a new doodle.
   content::BrowserThread::PostDelayedTask(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(&StartPageService::FetchDoodleJson,
                  weak_factory_.GetWeakPtr()),
       recheck_delay);
 }
 
 }  // namespace app_list