| // 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/extensions/extension_test_notification_observer.h" |
| |
| #include "chrome/browser/extensions/extension_process_manager.h" |
| #include "chrome/browser/extensions/extension_service.h" |
| #include "chrome/browser/extensions/extension_system.h" |
| #include "chrome/browser/profiles/profile_manager.h" |
| #include "chrome/browser/ui/browser.h" |
| #include "chrome/browser/ui/browser_window.h" |
| #include "chrome/common/extensions/extension.h" |
| #include "content/public/browser/notification_registrar.h" |
| #include "content/public/browser/notification_service.h" |
| #include "content/public/browser/render_view_host.h" |
| #include "content/public/test/test_utils.h" |
| |
| using extensions::Extension; |
| |
| namespace { |
| |
| bool HasExtensionPageActionCountReachedTarget(LocationBarTesting* location_bar, |
| int target_page_action_count) { |
| VLOG(1) << "Number of page actions: " << location_bar->PageActionCount(); |
| return location_bar->PageActionCount() == target_page_action_count; |
| } |
| |
| bool HasExtensionPageActionVisibilityReachedTarget( |
| LocationBarTesting* location_bar, |
| int target_visible_page_action_count) { |
| VLOG(1) << "Number of visible page actions: " |
| << location_bar->PageActionVisibleCount(); |
| return location_bar->PageActionVisibleCount() == |
| target_visible_page_action_count; |
| } |
| |
| } // namespace |
| |
| ExtensionTestNotificationObserver::ExtensionTestNotificationObserver( |
| Browser* browser) |
| : browser_(browser), |
| profile_(NULL), |
| extension_installs_observed_(0), |
| extension_load_errors_observed_(0), |
| crx_installers_done_observed_(0) { |
| } |
| |
| ExtensionTestNotificationObserver::~ExtensionTestNotificationObserver() {} |
| |
| Profile* ExtensionTestNotificationObserver::GetProfile() { |
| if (!profile_) { |
| if (browser_) |
| profile_ = browser_->profile(); |
| else |
| profile_ = ProfileManager::GetDefaultProfile(); |
| } |
| return profile_; |
| } |
| |
| void ExtensionTestNotificationObserver::WaitForNotification( |
| int notification_type) { |
| // TODO(bauerb): Using a WindowedNotificationObserver like this can break |
| // easily, if the notification we're waiting for is sent before this method. |
| // Change it so that the WindowedNotificationObserver is constructed earlier. |
| content::NotificationRegistrar registrar; |
| registrar.Add( |
| this, notification_type, content::NotificationService::AllSources()); |
| content::WindowedNotificationObserver( |
| notification_type, content::NotificationService::AllSources()).Wait(); |
| } |
| |
| bool ExtensionTestNotificationObserver::WaitForPageActionCountChangeTo( |
| int count) { |
| LocationBarTesting* location_bar = |
| browser_->window()->GetLocationBar()->GetLocationBarForTesting(); |
| if (!HasExtensionPageActionCountReachedTarget(location_bar, count)) { |
| content::WindowedNotificationObserver( |
| chrome::NOTIFICATION_EXTENSION_PAGE_ACTION_COUNT_CHANGED, |
| base::Bind( |
| &HasExtensionPageActionCountReachedTarget, location_bar, count)) |
| .Wait(); |
| } |
| return HasExtensionPageActionCountReachedTarget(location_bar, count); |
| } |
| |
| bool ExtensionTestNotificationObserver::WaitForPageActionVisibilityChangeTo( |
| int count) { |
| LocationBarTesting* location_bar = |
| browser_->window()->GetLocationBar()->GetLocationBarForTesting(); |
| if (!HasExtensionPageActionVisibilityReachedTarget(location_bar, count)) { |
| content::WindowedNotificationObserver( |
| chrome::NOTIFICATION_EXTENSION_PAGE_ACTION_VISIBILITY_CHANGED, |
| base::Bind(&HasExtensionPageActionVisibilityReachedTarget, |
| location_bar, |
| count)).Wait(); |
| } |
| return HasExtensionPageActionVisibilityReachedTarget(location_bar, count); |
| } |
| |
| bool ExtensionTestNotificationObserver::WaitForExtensionViewsToLoad() { |
| ExtensionProcessManager* manager = |
| extensions::ExtensionSystem::Get(GetProfile())->process_manager(); |
| ExtensionProcessManager::ViewSet all_views = manager->GetAllViews(); |
| for (ExtensionProcessManager::ViewSet::const_iterator iter = |
| all_views.begin(); |
| iter != all_views.end();) { |
| if (!(*iter)->IsLoading()) { |
| ++iter; |
| } else { |
| // Wait for all the extension render view hosts that exist to finish |
| // loading. |
| content::WindowedNotificationObserver observer( |
| content::NOTIFICATION_LOAD_STOP, |
| content::NotificationService::AllSources()); |
| observer.AddNotificationType( |
| content::NOTIFICATION_WEB_CONTENTS_DESTROYED, |
| content::NotificationService::AllSources()); |
| observer.Wait(); |
| |
| // Test activity may have modified the set of extension processes during |
| // message processing, so re-start the iteration to catch added/removed |
| // processes. |
| all_views = manager->GetAllViews(); |
| iter = all_views.begin(); |
| } |
| } |
| return true; |
| } |
| |
| bool ExtensionTestNotificationObserver::WaitForExtensionInstall() { |
| int before = extension_installs_observed_; |
| WaitForNotification(chrome::NOTIFICATION_EXTENSION_INSTALLED); |
| return extension_installs_observed_ == (before + 1); |
| } |
| |
| bool ExtensionTestNotificationObserver::WaitForExtensionInstallError() { |
| int before = extension_installs_observed_; |
| content::WindowedNotificationObserver( |
| chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR, |
| content::NotificationService::AllSources()).Wait(); |
| return extension_installs_observed_ == before; |
| } |
| |
| void ExtensionTestNotificationObserver::WaitForExtensionLoad() { |
| WaitForNotification(chrome::NOTIFICATION_EXTENSION_LOADED); |
| } |
| |
| void ExtensionTestNotificationObserver::WaitForExtensionAndViewLoad() { |
| this->WaitForExtensionLoad(); |
| WaitForExtensionViewsToLoad(); |
| } |
| |
| bool ExtensionTestNotificationObserver::WaitForExtensionLoadError() { |
| int before = extension_load_errors_observed_; |
| WaitForNotification(chrome::NOTIFICATION_EXTENSION_LOAD_ERROR); |
| return extension_load_errors_observed_ != before; |
| } |
| |
| bool ExtensionTestNotificationObserver::WaitForExtensionCrash( |
| const std::string& extension_id) { |
| ExtensionService* service = extensions::ExtensionSystem::Get( |
| GetProfile())->extension_service(); |
| |
| if (!service->GetExtensionById(extension_id, true)) { |
| // The extension is already unloaded, presumably due to a crash. |
| return true; |
| } |
| content::WindowedNotificationObserver( |
| chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED, |
| content::NotificationService::AllSources()).Wait(); |
| return (service->GetExtensionById(extension_id, true) == NULL); |
| } |
| |
| bool ExtensionTestNotificationObserver::WaitForCrxInstallerDone() { |
| int before = crx_installers_done_observed_; |
| WaitForNotification(chrome::NOTIFICATION_CRX_INSTALLER_DONE); |
| return crx_installers_done_observed_ == (before + 1); |
| } |
| |
| void ExtensionTestNotificationObserver::Watch( |
| int type, |
| const content::NotificationSource& source) { |
| CHECK(!observer_); |
| observer_.reset(new content::WindowedNotificationObserver(type, source)); |
| registrar_.Add(this, type, source); |
| } |
| |
| void ExtensionTestNotificationObserver::Wait() { |
| observer_->Wait(); |
| |
| registrar_.RemoveAll(); |
| observer_.reset(); |
| } |
| |
| void ExtensionTestNotificationObserver::Observe( |
| int type, |
| const content::NotificationSource& source, |
| const content::NotificationDetails& details) { |
| switch (type) { |
| case chrome::NOTIFICATION_EXTENSION_LOADED: |
| last_loaded_extension_id_ = |
| content::Details<const Extension>(details).ptr()->id(); |
| VLOG(1) << "Got EXTENSION_LOADED notification."; |
| break; |
| |
| case chrome::NOTIFICATION_CRX_INSTALLER_DONE: |
| VLOG(1) << "Got CRX_INSTALLER_DONE notification."; |
| { |
| const Extension* extension = |
| content::Details<const Extension>(details).ptr(); |
| if (extension) |
| last_loaded_extension_id_ = extension->id(); |
| else |
| last_loaded_extension_id_.clear(); |
| } |
| ++crx_installers_done_observed_; |
| break; |
| |
| case chrome::NOTIFICATION_EXTENSION_INSTALLED: |
| VLOG(1) << "Got EXTENSION_INSTALLED notification."; |
| ++extension_installs_observed_; |
| break; |
| |
| case chrome::NOTIFICATION_EXTENSION_LOAD_ERROR: |
| VLOG(1) << "Got EXTENSION_LOAD_ERROR notification."; |
| ++extension_load_errors_observed_; |
| break; |
| |
| default: |
| NOTREACHED(); |
| break; |
| } |
| } |