chrome/browser/ui/app_list/app_list_view_delegate.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/app_list/app_list_view_delegate.h"
   6
   7 #include <vector>
   8
   9 #include "apps/custom_launcher_page_contents.h"
  10 #include "base/callback.h"
  11 #include "base/command_line.h"
  12 #include "base/files/file_path.h"
  13 #include "base/metrics/user_metrics.h"
  14 #include "base/profiler/scoped_tracker.h"
  15 #include "base/stl_util.h"
  16 #include "chrome/browser/apps/scoped_keep_alive.h"
  17 #include "chrome/browser/browser_process.h"
  18 #include "chrome/browser/chrome_notification_types.h"
  19 #include "chrome/browser/profiles/profile_info_cache.h"
  20 #include "chrome/browser/profiles/profile_manager.h"
  21 #include "chrome/browser/search/hotword_service.h"
  22 #include "chrome/browser/search/hotword_service_factory.h"
  23 #include "chrome/browser/search_engines/template_url_service_factory.h"
  24 #include "chrome/browser/ui/app_list/app_list_controller_delegate.h"
  25 #include "chrome/browser/ui/app_list/app_list_service.h"
  26 #include "chrome/browser/ui/app_list/app_list_syncable_service.h"
  27 #include "chrome/browser/ui/app_list/app_list_syncable_service_factory.h"
  28 #include "chrome/browser/ui/app_list/launcher_page_event_dispatcher.h"
  29 #include "chrome/browser/ui/app_list/search/search_controller_factory.h"
  30 #include "chrome/browser/ui/app_list/search/search_resource_manager.h"
  31 #include "chrome/browser/ui/app_list/start_page_service.h"
  32 #include "chrome/browser/ui/apps/chrome_app_delegate.h"
  33 #include "chrome/browser/ui/browser_finder.h"
  34 #include "chrome/browser/ui/chrome_pages.h"
  35 #include "chrome/browser/ui/host_desktop.h"
  36 #include "chrome/browser/ui/scoped_tabbed_browser_displayer.h"
  37 #include "chrome/browser/web_applications/web_app.h"
  38 #include "chrome/common/chrome_switches.h"
  39 #include "chrome/common/extensions/extension_constants.h"
  40 #include "chrome/common/url_constants.h"
  41 #include "components/search_engines/template_url_prepopulate_data.h"
  42 #include "components/signin/core/browser/signin_manager.h"
  43 #include "content/public/browser/browser_thread.h"
  44 #include "content/public/browser/notification_service.h"
  45 #include "content/public/browser/page_navigator.h"
  46 #include "content/public/browser/render_view_host.h"
  47 #include "content/public/browser/render_widget_host_view.h"
  48 #include "content/public/browser/speech_recognition_session_preamble.h"
  49 #include "content/public/browser/user_metrics.h"
  50 #include "content/public/browser/web_contents.h"
  51 #include "extensions/browser/extension_registry.h"
  52 #include "extensions/common/constants.h"
  53 #include "extensions/common/extension_set.h"
  54 #include "extensions/common/manifest_constants.h"
  55 #include "extensions/common/manifest_handlers/launcher_page_info.h"
  56 #include "grit/theme_resources.h"
  57 #include "ui/app_list/app_list_switches.h"
  58 #include "ui/app_list/app_list_view_delegate_observer.h"
  59 #include "ui/app_list/search_box_model.h"
  60 #include "ui/app_list/search_controller.h"
  61 #include "ui/app_list/speech_ui_model.h"
  62 #include "ui/base/resource/resource_bundle.h"
  63 #include "ui/views/controls/webview/webview.h"
  64
  65 #if defined(TOOLKIT_VIEWS)
  66 #include "ui/views/controls/webview/webview.h"
  67 #endif
  68
  69 #if defined(USE_AURA)
  70 #include "ui/keyboard/keyboard_util.h"
  71 #endif
  72
  73 #if defined(USE_ASH)
  74 #include "chrome/browser/ui/ash/app_list/app_sync_ui_state_watcher.h"
  75 #endif
  76
  77 #if defined(OS_WIN)
  78 #include "chrome/browser/web_applications/web_app_win.h"
  79 #endif
  80
  81
  82 namespace chrome {
  83 const char kAppLauncherCategoryTag[] = "AppLauncher";
  84 }  // namespace chrome
  85
  86 namespace {
  87
  88 const int kAutoLaunchDefaultTimeoutMilliSec = 50;
  89
  90 #if defined(OS_WIN)
  91 void CreateShortcutInWebAppDir(
  92     const base::FilePath& app_data_dir,
  93     base::Callback<void(const base::FilePath&)> callback,
  94     const web_app::ShortcutInfo& info) {
  95   content::BrowserThread::PostTaskAndReplyWithResult(
  96       content::BrowserThread::FILE,
  97       FROM_HERE,
  98       base::Bind(web_app::CreateShortcutInWebAppDir, app_data_dir, info),
  99       callback);
 100 }
 101 #endif
 102
 103 void PopulateUsers(const ProfileInfoCache& profile_info,
 104                    const base::FilePath& active_profile_path,
 105                    app_list::AppListViewDelegate::Users* users) {
 106   users->clear();
 107   const size_t count = profile_info.GetNumberOfProfiles();
 108   for (size_t i = 0; i < count; ++i) {
 109     app_list::AppListViewDelegate::User user;
 110     user.name = profile_info.GetNameOfProfileAtIndex(i);
 111     user.email = profile_info.GetUserNameOfProfileAtIndex(i);
 112     user.profile_path = profile_info.GetPathOfProfileAtIndex(i);
 113     user.active = active_profile_path == user.profile_path;
 114     users->push_back(user);
 115   }
 116 }
 117
 118 // Gets a list of URLs of the custom launcher pages to show in the launcher.
 119 // Returns a URL for each installed launcher page. If --custom-launcher-page is
 120 // specified and valid, also includes that URL.
 121 void GetCustomLauncherPageUrls(content::BrowserContext* browser_context,
 122                                std::vector<GURL>* urls) {
 123   // First, check the command line.
 124   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 125   if (app_list::switches::IsExperimentalAppListEnabled() &&
 126       command_line->HasSwitch(app_list::switches::kCustomLauncherPage)) {
 127     GURL custom_launcher_page_url(command_line->GetSwitchValueASCII(
 128         app_list::switches::kCustomLauncherPage));
 129
 130     if (custom_launcher_page_url.SchemeIs(extensions::kExtensionScheme)) {
 131       urls->push_back(custom_launcher_page_url);
 132     } else {
 133       LOG(ERROR) << "Invalid custom launcher page URL: "
 134                  << custom_launcher_page_url.possibly_invalid_spec();
 135     }
 136   }
 137
 138   // Search the list of installed extensions for ones with 'launcher_page'.
 139   extensions::ExtensionRegistry* extension_registry =
 140       extensions::ExtensionRegistry::Get(browser_context);
 141   const extensions::ExtensionSet& enabled_extensions =
 142       extension_registry->enabled_extensions();
 143   for (extensions::ExtensionSet::const_iterator it = enabled_extensions.begin();
 144        it != enabled_extensions.end();
 145        ++it) {
 146     const extensions::Extension* extension = it->get();
 147     extensions::LauncherPageInfo* info =
 148         extensions::LauncherPageHandler::GetInfo(extension);
 149     if (!info)
 150       continue;
 151
 152     urls->push_back(extension->GetResourceURL(info->page));
 153   }
 154 }
 155
 156 }  // namespace
 157
 158 AppListViewDelegate::AppListViewDelegate(AppListControllerDelegate* controller)
 159     : controller_(controller),
 160       profile_(NULL),
 161       model_(NULL),
 162       is_voice_query_(false),
 163       template_url_service_observer_(this),
 164       scoped_observer_(this) {
 165   // TODO(vadimt): Remove ScopedTracker below once crbug.com/431326 is fixed.
 166   tracked_objects::ScopedTracker tracking_profile(
 167       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 168           "431326 AppListViewDelegate::AppListViewDelegate"));
 169
 170   CHECK(controller_);
 171   // The SigninManagerFactor and the SigninManagers are observed to keep the
 172   // profile switcher menu up to date, with the correct list of profiles and the
 173   // correct email address (or none for signed out users) for each.
 174   SigninManagerFactory::GetInstance()->AddObserver(this);
 175
 176   // Start observing all already-created SigninManagers.
 177   ProfileManager* profile_manager = g_browser_process->profile_manager();
 178   std::vector<Profile*> profiles = profile_manager->GetLoadedProfiles();
 179
 180   // TODO(vadimt): Remove ScopedTracker below once crbug.com/431326 is fixed.
 181   tracked_objects::ScopedTracker tracking_profile1(
 182       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 183           "431326 AppListViewDelegate::AppListViewDelegate1"));
 184
 185   for (std::vector<Profile*>::iterator i = profiles.begin();
 186        i != profiles.end();
 187        ++i) {
 188     SigninManagerBase* manager =
 189         SigninManagerFactory::GetForProfileIfExists(*i);
 190     if (manager) {
 191       DCHECK(!scoped_observer_.IsObserving(manager));
 192       scoped_observer_.Add(manager);
 193     }
 194   }
 195
 196   // TODO(vadimt): Remove ScopedTracker below once crbug.com/431326 is fixed.
 197   tracked_objects::ScopedTracker tracking_profile2(
 198       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 199           "431326 AppListViewDelegate::AppListViewDelegate2"));
 200
 201   profile_manager->GetProfileInfoCache().AddObserver(this);
 202   speech_ui_.reset(new app_list::SpeechUIModel);
 203
 204   // TODO(vadimt): Remove ScopedTracker below once crbug.com/431326 is fixed.
 205   tracked_objects::ScopedTracker tracking_profile3(
 206       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 207           "431326 AppListViewDelegate::AppListViewDelegate3"));
 208
 209 #if defined(GOOGLE_CHROME_BUILD)
 210   gfx::ImageSkia image =
 211       *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
 212           IDR_APP_LIST_GOOGLE_LOGO_VOICE_SEARCH);
 213
 214   // TODO(vadimt): Remove ScopedTracker below once crbug.com/431326 is
 215   // fixed.
 216   tracked_objects::ScopedTracker tracking_profile31(
 217       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 218           "431326 AppListViewDelegate::AppListViewDelegate31"));
 219
 220   speech_ui_->set_logo(image);
 221 #endif
 222
 223   // TODO(vadimt): Remove ScopedTracker below once crbug.com/431326 is fixed.
 224   tracked_objects::ScopedTracker tracking_profile32(
 225       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 226           "431326 AppListViewDelegate::AppListViewDelegate32"));
 227
 228   registrar_.Add(this,
 229                  chrome::NOTIFICATION_APP_TERMINATING,
 230                  content::NotificationService::AllSources());
 231 }
 232
 233 AppListViewDelegate::~AppListViewDelegate() {
 234   // Note that the destructor is not always called. E.g. on Mac, this is owned
 235   // by a leaky singleton. Essential shutdown work must be done by observing
 236   // chrome::NOTIFICATION_APP_TERMINATING.
 237   SetProfile(NULL);
 238   g_browser_process->profile_manager()->GetProfileInfoCache().RemoveObserver(
 239       this);
 240
 241   SigninManagerFactory* factory = SigninManagerFactory::GetInstance();
 242   if (factory)
 243     factory->RemoveObserver(this);
 244 }
 245
 246 void AppListViewDelegate::SetProfile(Profile* new_profile) {
 247   // TODO(vadimt): Remove ScopedTracker below once crbug.com/431326 is fixed.
 248   tracked_objects::ScopedTracker tracking_profile(
 249       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 250           "431326 AppListViewDelegate::SetProfile"));
 251
 252   if (profile_ == new_profile)
 253     return;
 254
 255   if (profile_) {
 256     // TODO(vadimt): Remove ScopedTracker below once crbug.com/431326 is fixed.
 257     tracked_objects::ScopedTracker tracking_profile1(
 258         FROM_HERE_WITH_EXPLICIT_FUNCTION(
 259             "431326 AppListViewDelegate::SetProfile1"));
 260
 261     // Note: |search_resource_manager_| has a reference to |speech_ui_| so must
 262     // be destroyed first.
 263     search_resource_manager_.reset();
 264     search_controller_.reset();
 265     launcher_page_event_dispatcher_.reset();
 266     custom_page_contents_.clear();
 267     app_list::StartPageService* start_page_service =
 268         app_list::StartPageService::Get(profile_);
 269     if (start_page_service)
 270       start_page_service->RemoveObserver(this);
 271 #if defined(USE_ASH)
 272     app_sync_ui_state_watcher_.reset();
 273 #endif
 274     model_ = NULL;
 275   }
 276
 277   profile_ = new_profile;
 278   if (!profile_) {
 279     // TODO(vadimt): Remove ScopedTracker below once crbug.com/431326 is fixed.
 280     tracked_objects::ScopedTracker tracking_profile2(
 281         FROM_HERE_WITH_EXPLICIT_FUNCTION(
 282             "431326 AppListViewDelegate::SetProfile2"));
 283
 284     speech_ui_->SetSpeechRecognitionState(app_list::SPEECH_RECOGNITION_OFF);
 285     return;
 286   }
 287
 288   // TODO(vadimt): Remove ScopedTracker below once crbug.com/431326 is fixed.
 289   tracked_objects::ScopedTracker tracking_profile3(
 290       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 291           "431326 AppListViewDelegate::SetProfile3"));
 292   template_url_service_observer_.RemoveAll();
 293   if (app_list::switches::IsExperimentalAppListEnabled()) {
 294     TemplateURLService* template_url_service =
 295         TemplateURLServiceFactory::GetForProfile(profile_);
 296     template_url_service_observer_.Add(template_url_service);
 297   }
 298
 299   model_ =
 300       app_list::AppListSyncableServiceFactory::GetForProfile(profile_)->model();
 301
 302 #if defined(USE_ASH)
 303   app_sync_ui_state_watcher_.reset(new AppSyncUIStateWatcher(profile_, model_));
 304 #endif
 305
 306   SetUpSearchUI();
 307   SetUpProfileSwitcher();
 308   SetUpCustomLauncherPages();
 309   OnTemplateURLServiceChanged();
 310
 311   // TODO(vadimt): Remove ScopedTracker below once crbug.com/431326 is fixed.
 312   tracked_objects::ScopedTracker tracking_profile4(
 313       FROM_HERE_WITH_EXPLICIT_FUNCTION(
 314           "431326 AppListViewDelegate::SetProfile4"));
 315
 316   // Clear search query.
 317   model_->search_box()->SetText(base::string16());
 318 }
 319
 320 void AppListViewDelegate::SetUpSearchUI() {
 321   app_list::StartPageService* start_page_service =
 322       app_list::StartPageService::Get(profile_);
 323   if (start_page_service)
 324     start_page_service->AddObserver(this);
 325
 326   speech_ui_->SetSpeechRecognitionState(start_page_service
 327                                             ? start_page_service->state()
 328                                             : app_list::SPEECH_RECOGNITION_OFF);
 329
 330   search_resource_manager_.reset(new app_list::SearchResourceManager(
 331       profile_,
 332       model_->search_box(),
 333       speech_ui_.get()));
 334
 335   search_controller_ = CreateSearchController(profile_, model_, controller_);
 336 }
 337
 338 void AppListViewDelegate::SetUpProfileSwitcher() {
 339   // If a profile change is observed when there is no app list, there is nothing
 340   // to update until SetProfile() calls this function again.
 341   if (!profile_)
 342     return;
 343
 344   // Don't populate the app list users if we are on the ash desktop.
 345   chrome::HostDesktopType desktop = chrome::GetHostDesktopTypeForNativeWindow(
 346       controller_->GetAppListWindow());
 347   if (desktop == chrome::HOST_DESKTOP_TYPE_ASH)
 348     return;
 349
 350   // Populate the app list users.
 351   PopulateUsers(g_browser_process->profile_manager()->GetProfileInfoCache(),
 352                 profile_->GetPath(),
 353                 &users_);
 354
 355   FOR_EACH_OBSERVER(
 356       app_list::AppListViewDelegateObserver, observers_, OnProfilesChanged());
 357 }
 358
 359 void AppListViewDelegate::SetUpCustomLauncherPages() {
 360   std::vector<GURL> custom_launcher_page_urls;
 361   GetCustomLauncherPageUrls(profile_, &custom_launcher_page_urls);
 362   if (custom_launcher_page_urls.empty())
 363     return;
 364
 365   for (std::vector<GURL>::const_iterator it = custom_launcher_page_urls.begin();
 366        it != custom_launcher_page_urls.end();
 367        ++it) {
 368     std::string extension_id = it->host();
 369     apps::CustomLauncherPageContents* page_contents =
 370         new apps::CustomLauncherPageContents(
 371             scoped_ptr<extensions::AppDelegate>(
 372                 new ChromeAppDelegate(scoped_ptr<ScopedKeepAlive>())),
 373             extension_id);
 374     page_contents->Initialize(profile_, *it);
 375     custom_page_contents_.push_back(page_contents);
 376   }
 377
 378   std::string first_launcher_page_app_id = custom_launcher_page_urls[0].host();
 379   const extensions::Extension* extension =
 380       extensions::ExtensionRegistry::Get(profile_)
 381           ->GetExtensionById(first_launcher_page_app_id,
 382                              extensions::ExtensionRegistry::EVERYTHING);
 383   model_->set_custom_launcher_page_name(extension->name());
 384   // Only the first custom launcher page gets events dispatched to it.
 385   launcher_page_event_dispatcher_.reset(
 386       new app_list::LauncherPageEventDispatcher(profile_,
 387                                                 first_launcher_page_app_id));
 388 }
 389
 390 void AppListViewDelegate::OnHotwordStateChanged(bool started) {
 391   if (started) {
 392     if (speech_ui_->state() == app_list::SPEECH_RECOGNITION_READY) {
 393       OnSpeechRecognitionStateChanged(
 394           app_list::SPEECH_RECOGNITION_HOTWORD_LISTENING);
 395     }
 396   } else {
 397     if (speech_ui_->state() == app_list::SPEECH_RECOGNITION_HOTWORD_LISTENING)
 398       OnSpeechRecognitionStateChanged(app_list::SPEECH_RECOGNITION_READY);
 399   }
 400 }
 401
 402 void AppListViewDelegate::OnHotwordRecognized(
 403     const scoped_refptr<content::SpeechRecognitionSessionPreamble>& preamble) {
 404   DCHECK_EQ(app_list::SPEECH_RECOGNITION_HOTWORD_LISTENING,
 405             speech_ui_->state());
 406   ToggleSpeechRecognitionForHotword(preamble);
 407 }
 408
 409 void AppListViewDelegate::SigninManagerCreated(SigninManagerBase* manager) {
 410   scoped_observer_.Add(manager);
 411 }
 412
 413 void AppListViewDelegate::SigninManagerShutdown(SigninManagerBase* manager) {
 414   if (scoped_observer_.IsObserving(manager))
 415     scoped_observer_.Remove(manager);
 416 }
 417
 418 void AppListViewDelegate::GoogleSigninFailed(
 419     const GoogleServiceAuthError& error) {
 420   SetUpProfileSwitcher();
 421 }
 422
 423 void AppListViewDelegate::GoogleSigninSucceeded(const std::string& account_id,
 424                                                 const std::string& username,
 425                                                 const std::string& password) {
 426   SetUpProfileSwitcher();
 427 }
 428
 429 void AppListViewDelegate::GoogleSignedOut(const std::string& account_id,
 430                                           const std::string& username) {
 431   SetUpProfileSwitcher();
 432 }
 433
 434 void AppListViewDelegate::OnProfileAdded(const base::FilePath& profile_path) {
 435   SetUpProfileSwitcher();
 436 }
 437
 438 void AppListViewDelegate::OnProfileWasRemoved(
 439     const base::FilePath& profile_path,
 440     const base::string16& profile_name) {
 441   SetUpProfileSwitcher();
 442 }
 443
 444 void AppListViewDelegate::OnProfileNameChanged(
 445     const base::FilePath& profile_path,
 446     const base::string16& old_profile_name) {
 447   SetUpProfileSwitcher();
 448 }
 449
 450 bool AppListViewDelegate::ForceNativeDesktop() const {
 451   return controller_->ForceNativeDesktop();
 452 }
 453
 454 void AppListViewDelegate::SetProfileByPath(const base::FilePath& profile_path) {
 455   DCHECK(model_);
 456   // The profile must be loaded before this is called.
 457   SetProfile(
 458       g_browser_process->profile_manager()->GetProfileByPath(profile_path));
 459 }
 460
 461 app_list::AppListModel* AppListViewDelegate::GetModel() {
 462   return model_;
 463 }
 464
 465 app_list::SpeechUIModel* AppListViewDelegate::GetSpeechUI() {
 466   return speech_ui_.get();
 467 }
 468
 469 void AppListViewDelegate::GetShortcutPathForApp(
 470     const std::string& app_id,
 471     const base::Callback<void(const base::FilePath&)>& callback) {
 472 #if defined(OS_WIN)
 473   const extensions::Extension* extension =
 474       extensions::ExtensionRegistry::Get(profile_)->GetExtensionById(
 475           app_id, extensions::ExtensionRegistry::EVERYTHING);
 476   if (!extension) {
 477     callback.Run(base::FilePath());
 478     return;
 479   }
 480
 481   base::FilePath app_data_dir(
 482       web_app::GetWebAppDataDirectory(profile_->GetPath(),
 483                                       extension->id(),
 484                                       GURL()));
 485
 486   web_app::GetShortcutInfoForApp(
 487       extension,
 488       profile_,
 489       base::Bind(CreateShortcutInWebAppDir, app_data_dir, callback));
 490 #else
 491   callback.Run(base::FilePath());
 492 #endif
 493 }
 494
 495 void AppListViewDelegate::StartSearch() {
 496   if (search_controller_) {
 497     search_controller_->Start(is_voice_query_);
 498     controller_->OnSearchStarted();
 499   }
 500 }
 501
 502 void AppListViewDelegate::StopSearch() {
 503   if (search_controller_)
 504     search_controller_->Stop();
 505 }
 506
 507 void AppListViewDelegate::OpenSearchResult(
 508     app_list::SearchResult* result,
 509     bool auto_launch,
 510     int event_flags) {
 511   if (auto_launch)
 512     base::RecordAction(base::UserMetricsAction("AppList_AutoLaunched"));
 513   search_controller_->OpenResult(result, event_flags);
 514   is_voice_query_ = false;
 515 }
 516
 517 void AppListViewDelegate::InvokeSearchResultAction(
 518     app_list::SearchResult* result,
 519     int action_index,
 520     int event_flags) {
 521   search_controller_->InvokeResultAction(result, action_index, event_flags);
 522 }
 523
 524 base::TimeDelta AppListViewDelegate::GetAutoLaunchTimeout() {
 525   return auto_launch_timeout_;
 526 }
 527
 528 void AppListViewDelegate::AutoLaunchCanceled() {
 529   if (is_voice_query_) {
 530     base::RecordAction(base::UserMetricsAction("AppList_AutoLaunchCanceled"));
 531     // Cancelling the auto launch means we are no longer in a voice query.
 532     is_voice_query_ = false;
 533   }
 534   auto_launch_timeout_ = base::TimeDelta();
 535 }
 536
 537 void AppListViewDelegate::ViewInitialized() {
 538   app_list::StartPageService* service =
 539       app_list::StartPageService::Get(profile_);
 540   if (service) {
 541     service->AppListShown();
 542     if (service->HotwordEnabled()) {
 543       HotwordService* hotword_service =
 544           HotwordServiceFactory::GetForProfile(profile_);
 545       if (hotword_service)
 546         hotword_service->RequestHotwordSession(this);
 547     }
 548     OnHotwordStateChanged(service->HotwordEnabled());
 549   }
 550 }
 551
 552 void AppListViewDelegate::Dismiss()  {
 553   controller_->DismissView();
 554 }
 555
 556 void AppListViewDelegate::ViewClosing() {
 557   controller_->ViewClosing();
 558
 559   if (!profile_)
 560     return;
 561
 562   app_list::StartPageService* service =
 563       app_list::StartPageService::Get(profile_);
 564   if (service) {
 565     service->AppListHidden();
 566     if (service->HotwordEnabled()) {
 567       HotwordService* hotword_service =
 568           HotwordServiceFactory::GetForProfile(profile_);
 569       if (hotword_service) {
 570         hotword_service->StopHotwordSession(this);
 571
 572         // If we're in always-on mode, we always want to restart hotwording
 573         // after closing the launcher window. So, in always-on mode, hotwording
 574         // is stopped, and then started again right away. Note that hotwording
 575         // may already be stopped. The call to StopHotwordSession() above both
 576         // explicitly stops hotwording, if it's running, and clears the
 577         // association between the hotword service and |this|.  When starting up
 578         // hotwording, pass nullptr as the client so that hotword triggers cause
 579         // the launcher to open.
 580         // TODO(amistry): This only works on ChromeOS since Chrome hides the
 581         // launcher instead of destroying it. Make this work on Chrome.
 582         if (hotword_service->IsAlwaysOnEnabled())
 583           hotword_service->RequestHotwordSession(nullptr);
 584       }
 585     }
 586   }
 587 }
 588
 589 gfx::ImageSkia AppListViewDelegate::GetWindowIcon() {
 590   return controller_->GetWindowIcon();
 591 }
 592
 593 void AppListViewDelegate::OpenSettings() {
 594   const extensions::Extension* extension =
 595       extensions::ExtensionRegistry::Get(profile_)->GetExtensionById(
 596           extension_misc::kSettingsAppId,
 597           extensions::ExtensionRegistry::EVERYTHING);
 598   DCHECK(extension);
 599   controller_->ActivateApp(profile_,
 600                            extension,
 601                            AppListControllerDelegate::LAUNCH_FROM_UNKNOWN,
 602                            0);
 603 }
 604
 605 void AppListViewDelegate::OpenHelp() {
 606   chrome::HostDesktopType desktop = chrome::GetHostDesktopTypeForNativeWindow(
 607       controller_->GetAppListWindow());
 608   chrome::ScopedTabbedBrowserDisplayer displayer(profile_, desktop);
 609   content::OpenURLParams params(GURL(chrome::kAppLauncherHelpURL),
 610                                 content::Referrer(),
 611                                 NEW_FOREGROUND_TAB,
 612                                 ui::PAGE_TRANSITION_LINK,
 613                                 false);
 614   displayer.browser()->OpenURL(params);
 615 }
 616
 617 void AppListViewDelegate::OpenFeedback() {
 618   chrome::HostDesktopType desktop = chrome::GetHostDesktopTypeForNativeWindow(
 619       controller_->GetAppListWindow());
 620   Browser* browser = chrome::FindTabbedBrowser(profile_, false, desktop);
 621   chrome::ShowFeedbackPage(browser, std::string(),
 622                            chrome::kAppLauncherCategoryTag);
 623 }
 624
 625 void AppListViewDelegate::ToggleSpeechRecognition() {
 626   ToggleSpeechRecognitionForHotword(nullptr);
 627 }
 628
 629 void AppListViewDelegate::ToggleSpeechRecognitionForHotword(
 630     const scoped_refptr<content::SpeechRecognitionSessionPreamble>& preamble) {
 631   app_list::StartPageService* service =
 632       app_list::StartPageService::Get(profile_);
 633   if (service)
 634     service->ToggleSpeechRecognition(preamble);
 635
 636   // With the new hotword extension, stop the hotword session. With the launcher
 637   // and NTP, this is unnecessary since the hotwording is implicitly stopped.
 638   // However, for always on, hotword triggering launches the launcher which
 639   // starts a session and hence starts the hotword detector. This results in the
 640   // hotword detector and the speech-to-text engine running in parallel, which
 641   // will conflict with each other (i.e. saying 'Ok Google' twice in a row
 642   // should cause a search to happen for 'Ok Google', not two hotword triggers).
 643   // To get around this, always stop the session when switching to speech
 644   // recognition.
 645   if (HotwordService::IsExperimentalHotwordingEnabled() &&
 646       service && service->HotwordEnabled()) {
 647     HotwordService* hotword_service =
 648         HotwordServiceFactory::GetForProfile(profile_);
 649     if (hotword_service)
 650       hotword_service->StopHotwordSession(this);
 651   }
 652 }
 653
 654 void AppListViewDelegate::ShowForProfileByPath(
 655     const base::FilePath& profile_path) {
 656   controller_->ShowForProfileByPath(profile_path);
 657 }
 658
 659 void AppListViewDelegate::OnSpeechResult(const base::string16& result,
 660                                          bool is_final) {
 661   speech_ui_->SetSpeechResult(result, is_final);
 662   if (is_final) {
 663     auto_launch_timeout_ = base::TimeDelta::FromMilliseconds(
 664         kAutoLaunchDefaultTimeoutMilliSec);
 665     is_voice_query_ = true;
 666     model_->search_box()->SetText(result);
 667   }
 668 }
 669
 670 void AppListViewDelegate::OnSpeechSoundLevelChanged(int16 level) {
 671   speech_ui_->UpdateSoundLevel(level);
 672 }
 673
 674 void AppListViewDelegate::OnSpeechRecognitionStateChanged(
 675     app_list::SpeechRecognitionState new_state) {
 676   speech_ui_->SetSpeechRecognitionState(new_state);
 677
 678   app_list::StartPageService* service =
 679       app_list::StartPageService::Get(profile_);
 680   // With the new hotword extension, we need to re-request hotwording after
 681   // speech recognition has stopped. Do not request hotwording after the app
 682   // list has already closed.
 683   if (new_state == app_list::SPEECH_RECOGNITION_READY &&
 684       HotwordService::IsExperimentalHotwordingEnabled() &&
 685       service && service->HotwordEnabled() &&
 686       controller_->GetAppListWindow()) {
 687     HotwordService* hotword_service =
 688         HotwordServiceFactory::GetForProfile(profile_);
 689     if (hotword_service) {
 690       hotword_service->RequestHotwordSession(this);
 691     }
 692   }
 693 }
 694
 695 #if defined(TOOLKIT_VIEWS)
 696 views::View* AppListViewDelegate::CreateStartPageWebView(
 697     const gfx::Size& size) {
 698   app_list::StartPageService* service =
 699       app_list::StartPageService::Get(profile_);
 700   if (!service)
 701     return NULL;
 702
 703   service->LoadContentsIfNeeded();
 704
 705   content::WebContents* web_contents = service->GetStartPageContents();
 706   if (!web_contents)
 707     return NULL;
 708
 709   DCHECK_EQ(profile_, web_contents->GetBrowserContext());
 710   views::WebView* web_view = new views::WebView(
 711       web_contents->GetBrowserContext());
 712   web_view->SetPreferredSize(size);
 713   web_view->SetResizeBackgroundColor(SK_ColorTRANSPARENT);
 714   web_view->SetWebContents(web_contents);
 715   return web_view;
 716 }
 717
 718 std::vector<views::View*> AppListViewDelegate::CreateCustomPageWebViews(
 719     const gfx::Size& size) {
 720   std::vector<views::View*> web_views;
 721
 722   for (ScopedVector<apps::CustomLauncherPageContents>::const_iterator it =
 723            custom_page_contents_.begin();
 724        it != custom_page_contents_.end();
 725        ++it) {
 726     content::WebContents* web_contents = (*it)->web_contents();
 727
 728     // The web contents should belong to the current profile.
 729     DCHECK_EQ(profile_, web_contents->GetBrowserContext());
 730
 731     // Make the webview transparent.
 732     web_contents->GetRenderViewHost()->GetView()->SetBackgroundColor(
 733         SK_ColorTRANSPARENT);
 734
 735     views::WebView* web_view =
 736         new views::WebView(web_contents->GetBrowserContext());
 737     web_view->SetPreferredSize(size);
 738     web_view->SetResizeBackgroundColor(SK_ColorTRANSPARENT);
 739     web_view->SetWebContents(web_contents);
 740     web_views.push_back(web_view);
 741   }
 742
 743   return web_views;
 744 }
 745
 746 void AppListViewDelegate::CustomLauncherPageAnimationChanged(double progress) {
 747   if (launcher_page_event_dispatcher_)
 748     launcher_page_event_dispatcher_->ProgressChanged(progress);
 749 }
 750
 751 void AppListViewDelegate::CustomLauncherPagePopSubpage() {
 752   if (launcher_page_event_dispatcher_)
 753     launcher_page_event_dispatcher_->PopSubpage();
 754 }
 755 #endif
 756
 757 bool AppListViewDelegate::IsSpeechRecognitionEnabled() {
 758   app_list::StartPageService* service =
 759       app_list::StartPageService::Get(profile_);
 760   return service && service->GetSpeechRecognitionContents();
 761 }
 762
 763 const app_list::AppListViewDelegate::Users&
 764 AppListViewDelegate::GetUsers() const {
 765   return users_;
 766 }
 767
 768 bool AppListViewDelegate::ShouldCenterWindow() const {
 769   // Some ChromeOS devices (those that support TouchView mode) turn this flag on
 770   // by default, which ensures that the app list is consistently centered on
 771   // those devices. This avoids having the app list change shape and position as
 772   // the user enters and exits TouchView mode.
 773   if (app_list::switches::IsCenteredAppListEnabled())
 774     return true;
 775
 776   // keyboard depends upon Aura.
 777 #if defined(USE_AURA)
 778   // If the virtual keyboard is enabled, use the new app list position. The old
 779   // position is too tall, and doesn't fit in the left-over screen space.
 780   if (keyboard::IsKeyboardEnabled())
 781     return true;
 782 #endif
 783
 784   return false;
 785 }
 786
 787 void AppListViewDelegate::AddObserver(
 788     app_list::AppListViewDelegateObserver* observer) {
 789   observers_.AddObserver(observer);
 790 }
 791
 792 void AppListViewDelegate::RemoveObserver(
 793     app_list::AppListViewDelegateObserver* observer) {
 794   observers_.RemoveObserver(observer);
 795 }
 796
 797 void AppListViewDelegate::OnTemplateURLServiceChanged() {
 798   if (!app_list::switches::IsExperimentalAppListEnabled())
 799     return;
 800
 801   TemplateURLService* template_url_service =
 802       TemplateURLServiceFactory::GetForProfile(profile_);
 803   const TemplateURL* default_provider =
 804       template_url_service->GetDefaultSearchProvider();
 805   bool is_google =
 806       TemplateURLPrepopulateData::GetEngineType(
 807           *default_provider, template_url_service->search_terms_data()) ==
 808       SEARCH_ENGINE_GOOGLE;
 809
 810   model_->SetSearchEngineIsGoogle(is_google);
 811
 812   app_list::StartPageService* start_page_service =
 813       app_list::StartPageService::Get(profile_);
 814   if (start_page_service)
 815     start_page_service->set_search_engine_is_google(is_google);
 816 }
 817
 818 void AppListViewDelegate::Observe(int type,
 819                                   const content::NotificationSource& source,
 820                                   const content::NotificationDetails& details) {
 821   switch (type) {
 822     case chrome::NOTIFICATION_APP_TERMINATING:
 823       FOR_EACH_OBSERVER(
 824           app_list::AppListViewDelegateObserver, observers_, OnShutdown());
 825
 826       SetProfile(NULL);  // Ensures launcher page web contents are torn down.
 827
 828       // SigninManagerFactory is not a leaky singleton (unlike this class), and
 829       // its destructor will check that it has no remaining observers.
 830       scoped_observer_.RemoveAll();
 831       SigninManagerFactory::GetInstance()->RemoveObserver(this);
 832       break;
 833     default:
 834       NOTREACHED();
 835   }
 836 }