Remove more dead app list code.

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 <stddef.h>
 
 #include <string>
 
@@ skipping 42 matching lines @@
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/content_switches.h"
 #include "extensions/browser/extension_system_provider.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/common/extension.h"
 #include "net/base/load_flags.h"
 #include "net/base/network_change_notifier.h"
 #include "net/url_request/url_fetcher.h"
 #include "ui/app_list/app_list_switches.h"
-
-#if defined(OS_CHROMEOS)
 #include "chromeos/audio/cras_audio_handler.h"
-#endif
 
 using base::RecordAction;
 using base::UserMetricsAction;
 
 namespace app_list {
 
 namespace {
 
 // Path to google.com's doodle JSON.
 const char kDoodleJsonPath[] = "async/ddljson";
@@ skipping 126 matching lines @@
            event.type() == blink::WebGestureEvent::GesturePinchEnd;
   }
 
 
  private:
   Profile* profile_;
 
   DISALLOW_COPY_AND_ASSIGN(StartPageWebContentsDelegate);
 };
 
-#if defined(OS_CHROMEOS)
 
 class StartPageService::AudioStatus
     : public chromeos::CrasAudioHandler::AudioObserver {
  public:
   explicit AudioStatus(StartPageService* start_page_service)
       : start_page_service_(start_page_service) {
     chromeos::CrasAudioHandler::Get()->AddAudioObserver(this);
     CheckAndUpdate();
   }
 
@@ skipping 18 matching lines @@
   // chromeos::CrasAudioHandler::AudioObserver:
   void OnInputMuteChanged(bool /* mute_on */) override { CheckAndUpdate(); }
 
   void OnActiveInputNodeChanged() override { CheckAndUpdate(); }
 
   StartPageService* start_page_service_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioStatus);
 };
 
-#endif  // OS_CHROMEOS
-
 class StartPageService::NetworkChangeObserver
     : public net::NetworkChangeNotifier::NetworkChangeObserver {
  public:
   explicit NetworkChangeObserver(StartPageService* start_page_service)
       : start_page_service_(start_page_service) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     // NOTE: This is used to detect network connectivity changes. However, what
     // we really want is internet connectivity changes because voice recognition
     // needs to talk to a web service. However, this information isn't
     // available, so network changes are the best we can do.
@@ skipping 118 matching lines @@
 void StartPageService::AppListShown() {
   if (!contents_) {
     LoadContents();
   } else if (contents_->IsCrashed()) {
     LoadStartPageURL();
   } else if (contents_->GetWebUI()) {
     contents_->GetWebUI()->CallJavascriptFunctionUnsafe(
         "appList.startPage.onAppListShown");
   }
 
-#if defined(OS_CHROMEOS)
   audio_status_.reset(new AudioStatus(this));
-#endif
 }
 
 void StartPageService::AppListHidden() {
   if (speech_recognizer_) {
     StopSpeechRecognition();
   }
 
-#if defined(OS_CHROMEOS)
   audio_status_.reset();
-#endif
 }
 
 void StartPageService::StartSpeechRecognition(
     const scoped_refptr<content::SpeechRecognitionSessionPreamble>& preamble) {
   DCHECK(contents_);
   speech_button_toggled_manually_ = true;
 
   if (!speech_recognizer_) {
     std::string profile_locale;
-#if defined(OS_CHROMEOS)
     profile_locale = profile_->GetPrefs()->GetString(
         prefs::kApplicationLocale);
-#endif
     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);
 }
 
 void StartPageService::StopSpeechRecognition() {
   // A call to Stop() isn't needed since deleting the recognizer implicitly
   // stops.
   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);
 }
 
 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)
   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 contents_.get();
 }
 
 content::WebContents* StartPageService::GetSpeechRecognitionContents() {
   if (app_list::switches::IsVoiceSearchEnabled()) {
     if (!contents_)
       LoadContents();
@@ skipping 12 matching lines @@
     observer.OnSpeechResult(query, is_final);
 }
 
 void StartPageService::OnSpeechSoundLevelChanged(int16_t level) {
   for (auto& observer : observers_)
     observer.OnSpeechSoundLevelChanged(level);
 }
 
 void StartPageService::OnSpeechRecognitionStateChanged(
     SpeechRecognitionState new_state) {
-#if defined(OS_CHROMEOS)
   // 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 (!microphone_available_)
     new_state = SPEECH_RECOGNITION_OFF;
   if (!network_available_)
     new_state = SPEECH_RECOGNITION_NETWORK_ERROR;
 
   if (state_ == new_state)
     return;
 
   if ((new_state == SPEECH_RECOGNITION_READY ||
        new_state == SPEECH_RECOGNITION_OFF ||
@@ skipping 27 matching lines @@
       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();
   network_change_observer_.reset();
 }
 
 void StartPageService::DidFinishNavigation(
     content::NavigationHandle* navigation_handle) {
   if (!navigation_handle->IsInMainFrame() || !navigation_handle->HasCommitted())
     return;
 
   if (navigation_handle->IsErrorPage()) {
@@ skipping 116 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