// Copyright (c) 2011 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.
#ifndef CHROME_BROWSER_AUTOMATION_AUTOMATION_PROVIDER_OBSERVERS_H_
#define CHROME_BROWSER_AUTOMATION_AUTOMATION_PROVIDER_OBSERVERS_H_
#pragma once
#include <deque>
#include <map>
#include <set>
#include <string>
#include <vector>
#include "base/compiler_specific.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "chrome/browser/automation/automation_provider_json.h"
#include "chrome/browser/automation/automation_tab_helper.h"
#include "chrome/browser/bookmarks/bookmark_model_observer.h"
#include "chrome/browser/browsing_data_remover.h"
#if defined(OS_CHROMEOS)
#include "chrome/browser/chromeos/cros/network_library.h"
#endif // defined(OS_CHROMEOS)
#include "chrome/browser/download/download_item.h"
#include "chrome/browser/download/download_manager.h"
#include "chrome/browser/history/history.h"
#include "chrome/browser/history/history_types.h"
#include "chrome/browser/importer/importer_data_types.h"
#include "chrome/browser/importer/importer_progress_observer.h"
#include "chrome/browser/password_manager/password_store_consumer.h"
#include "chrome/browser/search_engines/template_url_model_observer.h"
#include "chrome/browser/tabs/tab_strip_model.h"
#include "chrome/common/automation_constants.h"
#include "chrome/common/extensions/extension_constants.h"
#include "content/browser/cancelable_request.h"
#include "content/common/notification_observer.h"
#include "content/common/notification_registrar.h"
#include "content/common/notification_type.h"
#include "ui/gfx/size.h"
class AutocompleteEditModel;
class AutomationProvider;
class BalloonCollection;
class Browser;
class Extension;
class ExtensionProcessManager;
class NavigationController;
class RenderViewHost;
class SavePackage;
class TabContents;
class TranslateInfoBarDelegate;
namespace history {
class TopSites;
}
namespace IPC {
class Message;
}
class InitialLoadObserver : public NotificationObserver {
public:
InitialLoadObserver(size_t tab_count, AutomationProvider* automation);
virtual ~InitialLoadObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
// Caller owns the return value and is responsible for deleting it.
// Example return value:
// {'tabs': [{'start_time_ms': 1, 'stop_time_ms': 2.5},
// {'start_time_ms': 0.5, 'stop_time_ms': 3}]}
// stop_time_ms values may be null if WaitForInitialLoads has not finished.
// Only includes entries for the |tab_count| tabs we are monitoring.
// There is no defined ordering of the return value.
DictionaryValue* GetTimingInformation() const;
private:
class TabTime;
typedef std::map<uintptr_t, TabTime> TabTimeMap;
typedef std::set<uintptr_t> TabSet;
void ConditionMet();
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
size_t outstanding_tab_count_;
base::TimeTicks init_time_;
TabTimeMap loading_tabs_;
TabSet finished_tabs_;
DISALLOW_COPY_AND_ASSIGN(InitialLoadObserver);
};
#if defined(OS_CHROMEOS)
// Watches for NetworkManager events. Because NetworkLibrary loads
// asynchronously, this is used to make sure it is done before tests are run.
class NetworkManagerInitObserver
: public chromeos::NetworkLibrary::NetworkManagerObserver {
public:
explicit NetworkManagerInitObserver(AutomationProvider* automation);
virtual ~NetworkManagerInitObserver();
virtual bool Init();
virtual void OnNetworkManagerChanged(chromeos::NetworkLibrary* obj);
private:
base::WeakPtr<AutomationProvider> automation_;
DISALLOW_COPY_AND_ASSIGN(NetworkManagerInitObserver);
};
#endif // defined(OS_CHROMEOS)
// Watches for NewTabUI page loads for performance timing purposes.
class NewTabUILoadObserver : public NotificationObserver {
public:
explicit NewTabUILoadObserver(AutomationProvider* automation);
virtual ~NewTabUILoadObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
DISALLOW_COPY_AND_ASSIGN(NewTabUILoadObserver);
};
class NavigationControllerRestoredObserver : public NotificationObserver {
public:
NavigationControllerRestoredObserver(AutomationProvider* automation,
NavigationController* controller,
IPC::Message* reply_message);
virtual ~NavigationControllerRestoredObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
bool FinishedRestoring();
void SendDone();
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
NavigationController* controller_;
scoped_ptr<IPC::Message> reply_message_;
DISALLOW_COPY_AND_ASSIGN(NavigationControllerRestoredObserver);
};
class NavigationNotificationObserver : public NotificationObserver {
public:
NavigationNotificationObserver(NavigationController* controller,
AutomationProvider* automation,
IPC::Message* reply_message,
int number_of_navigations,
bool include_current_navigation,
bool use_json_interface);
virtual ~NavigationNotificationObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
void ConditionMet(AutomationMsg_NavigationResponseValues navigation_result);
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
NavigationController* controller_;
int navigations_remaining_;
bool navigation_started_;
bool use_json_interface_;
DISALLOW_COPY_AND_ASSIGN(NavigationNotificationObserver);
};
class TabStripNotificationObserver : public NotificationObserver {
public:
TabStripNotificationObserver(NotificationType notification,
AutomationProvider* automation);
virtual ~TabStripNotificationObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
virtual void ObserveTab(NavigationController* controller) = 0;
protected:
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
NotificationType notification_;
};
class TabAppendedNotificationObserver : public TabStripNotificationObserver {
public:
TabAppendedNotificationObserver(Browser* parent,
AutomationProvider* automation,
IPC::Message* reply_message);
virtual ~TabAppendedNotificationObserver();
virtual void ObserveTab(NavigationController* controller);
protected:
Browser* parent_;
scoped_ptr<IPC::Message> reply_message_;
private:
DISALLOW_COPY_AND_ASSIGN(TabAppendedNotificationObserver);
};
class TabClosedNotificationObserver : public TabStripNotificationObserver {
public:
TabClosedNotificationObserver(AutomationProvider* automation,
bool wait_until_closed,
IPC::Message* reply_message);
virtual ~TabClosedNotificationObserver();
virtual void ObserveTab(NavigationController* controller);
void set_for_browser_command(bool for_browser_command);
protected:
scoped_ptr<IPC::Message> reply_message_;
bool for_browser_command_;
private:
DISALLOW_COPY_AND_ASSIGN(TabClosedNotificationObserver);
};
// Notifies when the tab count reaches the target number.
class TabCountChangeObserver : public TabStripModelObserver {
public:
TabCountChangeObserver(AutomationProvider* automation,
Browser* browser,
IPC::Message* reply_message,
int target_tab_count);
// Implementation of TabStripModelObserver.
virtual void TabInsertedAt(TabContentsWrapper* contents,
int index,
bool foreground);
virtual void TabDetachedAt(TabContentsWrapper* contents, int index);
virtual void TabStripModelDeleted();
private:
virtual ~TabCountChangeObserver();
// Checks if the current tab count matches our target, and if so,
// sends the reply message and deletes self.
void CheckTabCount();
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
TabStripModel* tab_strip_model_;
const int target_tab_count_;
DISALLOW_COPY_AND_ASSIGN(TabCountChangeObserver);
};
// Observes when an extension has finished installing or possible install
// errors. This does not guarantee that the extension is ready for use.
class ExtensionInstallNotificationObserver : public NotificationObserver {
public:
ExtensionInstallNotificationObserver(AutomationProvider* automation,
int id,
IPC::Message* reply_message);
virtual ~ExtensionInstallNotificationObserver();
// Implementation of NotificationObserver.
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
// Send |response| back to the provider's client.
void SendResponse(AutomationMsg_ExtensionResponseValues response);
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
int id_;
scoped_ptr<IPC::Message> reply_message_;
DISALLOW_COPY_AND_ASSIGN(ExtensionInstallNotificationObserver);
};
// Observes when an extension has been uninstalled.
class ExtensionUninstallObserver : public NotificationObserver {
public:
ExtensionUninstallObserver(AutomationProvider* automation,
IPC::Message* reply_message,
const std::string& id);
virtual ~ExtensionUninstallObserver();
// Implementation of NotificationObserver.
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
std::string id_;
DISALLOW_COPY_AND_ASSIGN(ExtensionUninstallObserver);
};
// Observes when an extension has finished loading and is ready for use. Also
// checks for possible install errors.
class ExtensionReadyNotificationObserver : public NotificationObserver {
public:
ExtensionReadyNotificationObserver(ExtensionProcessManager* manager,
AutomationProvider* automation,
int id,
IPC::Message* reply_message);
virtual ~ExtensionReadyNotificationObserver();
// Implementation of NotificationObserver.
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
NotificationRegistrar registrar_;
ExtensionProcessManager* manager_;
base::WeakPtr<AutomationProvider> automation_;
int id_;
scoped_ptr<IPC::Message> reply_message_;
const Extension* extension_;
DISALLOW_COPY_AND_ASSIGN(ExtensionReadyNotificationObserver);
};
class ExtensionUnloadNotificationObserver : public NotificationObserver {
public:
ExtensionUnloadNotificationObserver();
virtual ~ExtensionUnloadNotificationObserver();
// Implementation of NotificationObserver.
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
bool did_receive_unload_notification() {
return did_receive_unload_notification_;
}
private:
NotificationRegistrar registrar_;
bool did_receive_unload_notification_;
DISALLOW_COPY_AND_ASSIGN(ExtensionUnloadNotificationObserver);
};
// Observes when the extensions have been fully updated. The ExtensionUpdater
// service provides notifications for each extension that gets updated, but
// it does not wait for the updated extensions to be installed or loaded. This
// observer waits until all updated extensions have actually been loaded.
class ExtensionsUpdatedObserver : public NotificationObserver {
public:
ExtensionsUpdatedObserver(ExtensionProcessManager* manager,
AutomationProvider* automation,
IPC::Message* reply_message);
virtual ~ExtensionsUpdatedObserver();
// Implementation of NotificationObserver.
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
NotificationRegistrar registrar_;
ExtensionProcessManager* manager_;
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
std::set<std::string> in_progress_updates_;
bool updater_finished_;
DISALLOW_COPY_AND_ASSIGN(ExtensionsUpdatedObserver);
};
class ExtensionTestResultNotificationObserver : public NotificationObserver {
public:
explicit ExtensionTestResultNotificationObserver(
AutomationProvider* automation);
virtual ~ExtensionTestResultNotificationObserver();
// Implementation of NotificationObserver.
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
// Sends a test result back to the provider's client, if there is a pending
// provider message and there is a result in the queue.
void MaybeSendResult();
private:
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
// Two queues containing the test results. Although typically only
// one result will be in each queue, there are cases where a queue is
// needed.
// For example, perhaps two events occur asynchronously and their
// order of completion is not guaranteed. If the test wants to make sure
// both finish before continuing, a queue is needed. The test would then
// need to wait twice.
std::deque<bool> results_;
std::deque<std::string> messages_;
DISALLOW_COPY_AND_ASSIGN(ExtensionTestResultNotificationObserver);
};
// Observes when a new browser has been opened and a tab within it has stopped
// loading.
class BrowserOpenedNotificationObserver : public NotificationObserver {
public:
BrowserOpenedNotificationObserver(AutomationProvider* automation,
IPC::Message* reply_message);
virtual ~BrowserOpenedNotificationObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
void set_for_browser_command(bool for_browser_command);
private:
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
int new_window_id_;
bool for_browser_command_;
DISALLOW_COPY_AND_ASSIGN(BrowserOpenedNotificationObserver);
};
class BrowserClosedNotificationObserver : public NotificationObserver {
public:
BrowserClosedNotificationObserver(Browser* browser,
AutomationProvider* automation,
IPC::Message* reply_message);
virtual ~BrowserClosedNotificationObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
void set_for_browser_command(bool for_browser_command);
private:
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
bool for_browser_command_;
DISALLOW_COPY_AND_ASSIGN(BrowserClosedNotificationObserver);
};
class BrowserCountChangeNotificationObserver : public NotificationObserver {
public:
BrowserCountChangeNotificationObserver(int target_count,
AutomationProvider* automation,
IPC::Message* reply_message);
virtual ~BrowserCountChangeNotificationObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
int target_count_;
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
DISALLOW_COPY_AND_ASSIGN(BrowserCountChangeNotificationObserver);
};
class AppModalDialogShownObserver : public NotificationObserver {
public:
AppModalDialogShownObserver(AutomationProvider* automation,
IPC::Message* reply_message);
virtual ~AppModalDialogShownObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
DISALLOW_COPY_AND_ASSIGN(AppModalDialogShownObserver);
};
class ExecuteBrowserCommandObserver : public NotificationObserver {
public:
virtual ~ExecuteBrowserCommandObserver();
static bool CreateAndRegisterObserver(AutomationProvider* automation,
Browser* browser,
int command,
IPC::Message* reply_message);
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
ExecuteBrowserCommandObserver(AutomationProvider* automation,
IPC::Message* reply_message);
bool Register(int command);
bool GetNotificationType(int command, NotificationType::Type* type);
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
NotificationType::Type notification_type_;
scoped_ptr<IPC::Message> reply_message_;
DISALLOW_COPY_AND_ASSIGN(ExecuteBrowserCommandObserver);
};
class FindInPageNotificationObserver : public NotificationObserver {
public:
FindInPageNotificationObserver(AutomationProvider* automation,
TabContents* parent_tab,
bool reply_with_json,
IPC::Message* reply_message);
virtual ~FindInPageNotificationObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
// The Find mechanism is over asynchronous IPC, so a search is kicked off and
// we wait for notification to find out what the results are. As the user is
// typing, new search requests can be issued and the Request ID helps us make
// sense of whether this is the current request or an old one. The unit tests,
// however, which uses this constant issues only one search at a time, so we
// don't need a rolling id to identify each search. But, we still need to
// specify one, so we just use a fixed one - its value does not matter.
static const int kFindInPageRequestId;
private:
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
// We will at some point (before final update) be notified of the ordinal and
// we need to preserve it so we can send it later.
int active_match_ordinal_;
// Send reply using json automation interface.
bool reply_with_json_;
scoped_ptr<IPC::Message> reply_message_;
DISALLOW_COPY_AND_ASSIGN(FindInPageNotificationObserver);
};
class DomOperationObserver : public NotificationObserver {
public:
DomOperationObserver();
virtual ~DomOperationObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
virtual void OnDomOperationCompleted(const std::string& json) = 0;
private:
NotificationRegistrar registrar_;
DISALLOW_COPY_AND_ASSIGN(DomOperationObserver);
};
// Sends a message back to the automation client with the results of the DOM
// operation.
class DomOperationMessageSender : public DomOperationObserver {
public:
explicit DomOperationMessageSender(AutomationProvider* automation,
IPC::Message* relpy_message,
bool use_json_interface);
virtual ~DomOperationMessageSender();
virtual void OnDomOperationCompleted(const std::string& json);
private:
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
bool use_json_interface_;
DISALLOW_COPY_AND_ASSIGN(DomOperationMessageSender);
};
class DocumentPrintedNotificationObserver : public NotificationObserver {
public:
DocumentPrintedNotificationObserver(AutomationProvider* automation,
IPC::Message* reply_message);
virtual ~DocumentPrintedNotificationObserver();
virtual void Observe(NotificationType type, const NotificationSource& source,
const NotificationDetails& details);
private:
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
bool success_;
scoped_ptr<IPC::Message> reply_message_;
DISALLOW_COPY_AND_ASSIGN(DocumentPrintedNotificationObserver);
};
// Collects METRIC_EVENT_DURATION notifications and keep track of the times.
class MetricEventDurationObserver : public NotificationObserver {
public:
MetricEventDurationObserver();
virtual ~MetricEventDurationObserver();
// Get the duration of an event. Returns -1 if we haven't seen the event.
int GetEventDurationMs(const std::string& event_name);
// NotificationObserver interface.
virtual void Observe(NotificationType type, const NotificationSource& source,
const NotificationDetails& details);
private:
NotificationRegistrar registrar_;
typedef std::map<std::string, int> EventDurationMap;
EventDurationMap durations_;
DISALLOW_COPY_AND_ASSIGN(MetricEventDurationObserver);
};
class PageTranslatedObserver : public NotificationObserver {
public:
PageTranslatedObserver(AutomationProvider* automation,
IPC::Message* reply_message,
TabContents* tab_contents);
virtual ~PageTranslatedObserver();
// NotificationObserver interface.
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
DISALLOW_COPY_AND_ASSIGN(PageTranslatedObserver);
};
class TabLanguageDeterminedObserver : public NotificationObserver {
public:
TabLanguageDeterminedObserver(AutomationProvider* automation,
IPC::Message* reply_message,
TabContents* tab_contents,
TranslateInfoBarDelegate* translate_bar);
virtual ~TabLanguageDeterminedObserver();
// NotificationObserver interface.
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
TabContents* tab_contents_;
TranslateInfoBarDelegate* translate_bar_;
DISALLOW_COPY_AND_ASSIGN(TabLanguageDeterminedObserver);
};
class InfoBarCountObserver : public NotificationObserver {
public:
InfoBarCountObserver(AutomationProvider* automation,
IPC::Message* reply_message,
TabContents* tab_contents,
size_t target_count);
virtual ~InfoBarCountObserver();
// NotificationObserver interface.
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
// Checks whether the infobar count matches our target, and if so
// sends the reply message and deletes itself.
void CheckCount();
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
TabContents* tab_contents_;
const size_t target_count_;
DISALLOW_COPY_AND_ASSIGN(InfoBarCountObserver);
};
#if defined(OS_CHROMEOS)
// Collects LOGIN_USER_CHANGED notifications and returns
// whether authentication succeeded to the automation provider.
class LoginManagerObserver : public NotificationObserver {
public:
LoginManagerObserver(AutomationProvider* automation,
IPC::Message* reply_message);
virtual ~LoginManagerObserver();
// NotificationObserver interface.
virtual void Observe(NotificationType type, const NotificationSource& source,
const NotificationDetails& details);
private:
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
DISALLOW_COPY_AND_ASSIGN(LoginManagerObserver);
};
// Collects SCREEN_LOCK_STATE_CHANGED notifications and returns
// whether authentication succeeded to the automation provider.
class ScreenLockUnlockObserver : public NotificationObserver {
public:
// Set lock_screen to true to observe lock screen events,
// false for unlock screen events.
ScreenLockUnlockObserver(AutomationProvider* automation,
IPC::Message* reply_message,
bool lock_screen);
virtual ~ScreenLockUnlockObserver();
// NotificationObserver interface.
virtual void Observe(NotificationType type, const NotificationSource& source,
const NotificationDetails& details);
private:
NotificationRegistrar registrar_;
AutomationProvider* automation_;
IPC::Message* reply_message_;
bool lock_screen_;
DISALLOW_COPY_AND_ASSIGN(ScreenLockUnlockObserver);
};
class NetworkScanObserver
: public chromeos::NetworkLibrary::NetworkManagerObserver {
public:
NetworkScanObserver(AutomationProvider* automation,
IPC::Message* reply_message);
virtual ~NetworkScanObserver();
// NetworkLibrary::NetworkManagerObserver implementation.
virtual void OnNetworkManagerChanged(chromeos::NetworkLibrary* obj);
private:
AutomationProvider* automation_;
IPC::Message* reply_message_;
DISALLOW_COPY_AND_ASSIGN(NetworkScanObserver);
};
// Waits for a connection success or failure for the specified
// network and returns the status to the automation provider.
class NetworkConnectObserver
: public chromeos::NetworkLibrary::NetworkManagerObserver {
public:
NetworkConnectObserver(AutomationProvider* automation,
IPC::Message* reply_message);
virtual ~NetworkConnectObserver();
virtual const chromeos::WifiNetwork* GetWifiNetwork(
chromeos::NetworkLibrary* network_library) = 0;
// NetworkLibrary::NetworkManagerObserver implementation.
virtual void OnNetworkManagerChanged(chromeos::NetworkLibrary* obj);
private:
AutomationProvider* automation_;
IPC::Message* reply_message_;
DISALLOW_COPY_AND_ASSIGN(NetworkConnectObserver);
};
// Waits for a connection success or failure for the specified
// network and returns the status to the automation provider.
class ServicePathConnectObserver : public NetworkConnectObserver {
public:
ServicePathConnectObserver(AutomationProvider* automation,
IPC::Message* reply_message,
const std::string& service_path);
virtual const chromeos::WifiNetwork* GetWifiNetwork(
chromeos::NetworkLibrary* network_library);
private:
std::string service_path_;
DISALLOW_COPY_AND_ASSIGN(ServicePathConnectObserver);
};
// Waits for a connection success or failure for the specified
// network and returns the status to the automation provider.
class SSIDConnectObserver : public NetworkConnectObserver {
public:
SSIDConnectObserver(AutomationProvider* automation,
IPC::Message* reply_message,
const std::string& ssid);
virtual const chromeos::WifiNetwork* GetWifiNetwork(
chromeos::NetworkLibrary* network_library);
private:
std::string ssid_;
DISALLOW_COPY_AND_ASSIGN(SSIDConnectObserver);
};
#endif // defined(OS_CHROMEOS)
// Waits for the bookmark model to load.
class AutomationProviderBookmarkModelObserver : BookmarkModelObserver {
public:
AutomationProviderBookmarkModelObserver(AutomationProvider* provider,
IPC::Message* reply_message,
BookmarkModel* model);
virtual ~AutomationProviderBookmarkModelObserver();
virtual void Loaded(BookmarkModel* model);
virtual void BookmarkModelBeingDeleted(BookmarkModel* model);
virtual void BookmarkNodeMoved(BookmarkModel* model,
const BookmarkNode* old_parent,
int old_index,
const BookmarkNode* new_parent,
int new_index) {}
virtual void BookmarkNodeAdded(BookmarkModel* model,
const BookmarkNode* parent,
int index) {}
virtual void BookmarkNodeRemoved(BookmarkModel* model,
const BookmarkNode* parent,
int old_index,
const BookmarkNode* node) {}
virtual void BookmarkNodeChanged(BookmarkModel* model,
const BookmarkNode* node) {}
virtual void BookmarkNodeFaviconLoaded(BookmarkModel* model,
const BookmarkNode* node) {}
virtual void BookmarkNodeChildrenReordered(BookmarkModel* model,
const BookmarkNode* node) {}
private:
// Reply to the automation message with the given success value,
// then delete myself (which removes myself from the bookmark model
// observer list).
void ReplyAndDelete(bool success);
base::WeakPtr<AutomationProvider> automation_provider_;
scoped_ptr<IPC::Message> reply_message_;
BookmarkModel* model_;
DISALLOW_COPY_AND_ASSIGN(AutomationProviderBookmarkModelObserver);
};
// Allows the automation provider to wait for all downloads to finish.
// If any download is interrupted, it will cancel all the other downloads at
// the next |OnDownloadUpdated|, and send an error when all are done.
class AutomationProviderDownloadItemObserver : public DownloadItem::Observer {
public:
AutomationProviderDownloadItemObserver(
AutomationProvider* provider,
IPC::Message* reply_message,
int downloads);
virtual ~AutomationProviderDownloadItemObserver();
virtual void OnDownloadUpdated(DownloadItem* download);
virtual void OnDownloadOpened(DownloadItem* download);
private:
void RemoveAndCleanupOnLastEntry(DownloadItem* download);
base::WeakPtr<AutomationProvider> provider_;
scoped_ptr<IPC::Message> reply_message_;
int downloads_;
bool interrupted_;
DISALLOW_COPY_AND_ASSIGN(AutomationProviderDownloadItemObserver);
};
// Allows the automation provider to wait until the download has been updated
// or opened.
class AutomationProviderDownloadUpdatedObserver
: public DownloadItem::Observer {
public:
AutomationProviderDownloadUpdatedObserver(
AutomationProvider* provider,
IPC::Message* reply_message,
bool wait_for_open);
virtual ~AutomationProviderDownloadUpdatedObserver();
virtual void OnDownloadUpdated(DownloadItem* download);
virtual void OnDownloadOpened(DownloadItem* download);
private:
base::WeakPtr<AutomationProvider> provider_;
scoped_ptr<IPC::Message> reply_message_;
bool wait_for_open_;
DISALLOW_COPY_AND_ASSIGN(AutomationProviderDownloadUpdatedObserver);
};
// Allows the automation provider to wait until the download model has changed
// (because a new download has been added or removed).
class AutomationProviderDownloadModelChangedObserver
: public DownloadManager::Observer {
public:
AutomationProviderDownloadModelChangedObserver(
AutomationProvider* provider,
IPC::Message* reply_message,
DownloadManager* download_manager);
virtual ~AutomationProviderDownloadModelChangedObserver();
virtual void ModelChanged();
private:
base::WeakPtr<AutomationProvider> provider_;
scoped_ptr<IPC::Message> reply_message_;
DownloadManager* download_manager_;
DISALLOW_COPY_AND_ASSIGN(AutomationProviderDownloadModelChangedObserver);
};
// Allows automation provider to wait until TemplateURLModel has loaded
// before looking up/returning search engine info.
class AutomationProviderSearchEngineObserver
: public TemplateURLModelObserver {
public:
AutomationProviderSearchEngineObserver(
AutomationProvider* provider,
IPC::Message* reply_message);
virtual ~AutomationProviderSearchEngineObserver();
virtual void OnTemplateURLModelChanged();
private:
base::WeakPtr<AutomationProvider> provider_;
scoped_ptr<IPC::Message> reply_message_;
DISALLOW_COPY_AND_ASSIGN(AutomationProviderSearchEngineObserver);
};
// Allows the automation provider to wait for history queries to finish.
class AutomationProviderHistoryObserver {
public:
AutomationProviderHistoryObserver(
AutomationProvider* provider,
IPC::Message* reply_message);
virtual ~AutomationProviderHistoryObserver();
void HistoryQueryComplete(HistoryService::Handle request_handle,
history::QueryResults* results);
private:
base::WeakPtr<AutomationProvider> provider_;
scoped_ptr<IPC::Message> reply_message_;
};
// Allows the automation provider to wait for import queries to finish.
class AutomationProviderImportSettingsObserver
: public importer::ImporterProgressObserver {
public:
AutomationProviderImportSettingsObserver(
AutomationProvider* provider,
IPC::Message* reply_message);
virtual ~AutomationProviderImportSettingsObserver();
// importer::ImporterProgressObserver:
virtual void ImportStarted() OVERRIDE;
virtual void ImportItemStarted(importer::ImportItem item) OVERRIDE;
virtual void ImportItemEnded(importer::ImportItem item) OVERRIDE;
virtual void ImportEnded() OVERRIDE;
private:
base::WeakPtr<AutomationProvider> provider_;
scoped_ptr<IPC::Message> reply_message_;
};
// Allows automation provider to wait for getting passwords to finish.
class AutomationProviderGetPasswordsObserver : public PasswordStoreConsumer {
public:
AutomationProviderGetPasswordsObserver(
AutomationProvider* provider,
IPC::Message* reply_message);
virtual ~AutomationProviderGetPasswordsObserver();
virtual void OnPasswordStoreRequestDone(
CancelableRequestProvider::Handle handle,
const std::vector<webkit_glue::PasswordForm*>& result);
private:
base::WeakPtr<AutomationProvider> provider_;
scoped_ptr<IPC::Message> reply_message_;
};
// Allows the automation provider to wait for clearing browser data to finish.
class AutomationProviderBrowsingDataObserver
: public BrowsingDataRemover::Observer {
public:
AutomationProviderBrowsingDataObserver(
AutomationProvider* provider,
IPC::Message* reply_message);
virtual ~AutomationProviderBrowsingDataObserver();
virtual void OnBrowsingDataRemoverDone();
private:
base::WeakPtr<AutomationProvider> provider_;
scoped_ptr<IPC::Message> reply_message_;
};
// Allows automation provider to wait until page load after selecting an item
// in the omnibox popup.
class OmniboxAcceptNotificationObserver : public NotificationObserver {
public:
OmniboxAcceptNotificationObserver(NavigationController* controller,
AutomationProvider* automation,
IPC::Message* reply_message);
virtual ~OmniboxAcceptNotificationObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
NavigationController* controller_;
DISALLOW_COPY_AND_ASSIGN(OmniboxAcceptNotificationObserver);
};
// Allows the automation provider to wait for a save package notification.
class SavePackageNotificationObserver : public NotificationObserver {
public:
SavePackageNotificationObserver(SavePackage* save_package,
AutomationProvider* automation,
IPC::Message* reply_message);
virtual ~SavePackageNotificationObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
DISALLOW_COPY_AND_ASSIGN(SavePackageNotificationObserver);
};
// This class manages taking a snapshot of a page. This requires waiting on
// asynchronous callbacks and notifications.
class PageSnapshotTaker : public DomOperationObserver {
public:
PageSnapshotTaker(AutomationProvider* automation,
IPC::Message* reply_message,
RenderViewHost* render_view,
const FilePath& path);
virtual ~PageSnapshotTaker();
// Start the process of taking a snapshot of the entire page.
void Start();
private:
// Overriden from DomOperationObserver.
virtual void OnDomOperationCompleted(const std::string& json);
// Called by the ThumbnailGenerator when the requested snapshot has been
// generated.
void OnSnapshotTaken(const SkBitmap& bitmap);
// Helper method to send arbitrary javascript to the renderer for evaluation.
void ExecuteScript(const std::wstring& javascript);
// Helper method to send a response back to the client. Deletes this.
void SendMessage(bool success);
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
RenderViewHost* render_view_;
FilePath image_path_;
bool received_width_;
gfx::Size entire_page_size_;
DISALLOW_COPY_AND_ASSIGN(PageSnapshotTaker);
};
class NTPInfoObserver : public NotificationObserver {
public:
NTPInfoObserver(AutomationProvider* automation,
IPC::Message* reply_message,
CancelableRequestConsumer* consumer);
virtual ~NTPInfoObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
void OnTopSitesLoaded();
void OnTopSitesReceived(const history::MostVisitedURLList& visited_list);
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
CancelableRequestConsumer* consumer_;
CancelableRequestProvider::Handle request_;
scoped_ptr<DictionaryValue> ntp_info_;
history::TopSites* top_sites_;
NotificationRegistrar registrar_;
DISALLOW_COPY_AND_ASSIGN(NTPInfoObserver);
};
// Observes when an app has been launched, as indicated by a notification that
// a content load in some tab has stopped.
class AppLaunchObserver : public NotificationObserver {
public:
AppLaunchObserver(NavigationController* controller,
AutomationProvider* automation,
IPC::Message* reply_message,
extension_misc::LaunchContainer launch_container);
virtual ~AppLaunchObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
NavigationController* controller_;
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
NotificationRegistrar registrar_;
extension_misc::LaunchContainer launch_container_;
int new_window_id_;
DISALLOW_COPY_AND_ASSIGN(AppLaunchObserver);
};
// Allows automation provider to wait until the autocomplete edit
// has received focus
class AutocompleteEditFocusedObserver : public NotificationObserver {
public:
AutocompleteEditFocusedObserver(AutomationProvider* automation,
AutocompleteEditModel* autocomplete_edit,
IPC::Message* reply_message);
virtual ~AutocompleteEditFocusedObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
AutocompleteEditModel* autocomplete_edit_model_;
DISALLOW_COPY_AND_ASSIGN(AutocompleteEditFocusedObserver);
};
// Allows the automation provider to wait until all the notification
// processes are ready.
class GetActiveNotificationsObserver : public NotificationObserver {
public:
GetActiveNotificationsObserver(AutomationProvider* automation,
IPC::Message* reply_message);
virtual ~GetActiveNotificationsObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
void SendMessage();
AutomationJSONReply reply_;
NotificationRegistrar registrar_;
DISALLOW_COPY_AND_ASSIGN(GetActiveNotificationsObserver);
};
// Allows the automation provider to wait for a given number of
// notification balloons.
class OnNotificationBalloonCountObserver {
public:
OnNotificationBalloonCountObserver(AutomationProvider* provider,
IPC::Message* reply_message,
BalloonCollection* collection,
int count);
void OnBalloonCollectionChanged();
private:
AutomationJSONReply reply_;
BalloonCollection* collection_;
int count_;
DISALLOW_COPY_AND_ASSIGN(OnNotificationBalloonCountObserver);
};
// Allows the automation provider to wait for a RENDERER_PROCESS_CLOSED
// notification.
class RendererProcessClosedObserver : public NotificationObserver {
public:
RendererProcessClosedObserver(AutomationProvider* automation,
IPC::Message* reply_message);
virtual ~RendererProcessClosedObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
DISALLOW_COPY_AND_ASSIGN(RendererProcessClosedObserver);
};
// Allows the automation provider to wait for acknowledgement that a input
// event has been handled.
class InputEventAckNotificationObserver : public NotificationObserver {
public:
InputEventAckNotificationObserver(AutomationProvider* automation,
IPC::Message* reply_message,
int event_type);
virtual ~InputEventAckNotificationObserver();
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details);
private:
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
int event_type_;
DISALLOW_COPY_AND_ASSIGN(InputEventAckNotificationObserver);
};
// Allows the automation provider to wait for all the tabs to finish any
// pending loads. This only waits for tabs that exist at the observer's
// creation. Will send a message on construction if no tabs are loading
// currently.
class AllTabsStoppedLoadingObserver : public TabEventObserver {
public:
AllTabsStoppedLoadingObserver(AutomationProvider* automation,
IPC::Message* reply_message);
virtual ~AllTabsStoppedLoadingObserver();
// TabEventObserver implementation.
virtual void OnFirstPendingLoad(TabContents* tab_contents);
virtual void OnNoMorePendingLoads(TabContents* tab_contents);
private:
typedef std::set<TabContents*> TabSet;
// Checks if there are no pending loads. If none, it will send an automation
// relpy and delete itself.
void CheckIfNoMorePendingLoads();
TabSet pending_tabs_;
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
DISALLOW_COPY_AND_ASSIGN(AllTabsStoppedLoadingObserver);
};
// Observer used to listen for new tab creation to complete.
class NewTabObserver : public NotificationObserver {
public:
NewTabObserver(AutomationProvider* automation, IPC::Message* reply_message);
virtual void Observe(NotificationType type,
const NotificationSource& source,
const NotificationDetails& details) OVERRIDE;
private:
virtual ~NewTabObserver();
NotificationRegistrar registrar_;
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
DISALLOW_COPY_AND_ASSIGN(NewTabObserver);
};
// Posts a task to the PROCESS_LAUNCHER thread, once processed posts a task
// back to the UI thread that notifies the provider we're done.
class WaitForProcessLauncherThreadToGoIdleObserver
: public base::RefCountedThreadSafe<
WaitForProcessLauncherThreadToGoIdleObserver,
BrowserThread::DeleteOnUIThread> {
public:
WaitForProcessLauncherThreadToGoIdleObserver(
AutomationProvider* automation, IPC::Message* reply_message);
private:
friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
friend class DeleteTask<WaitForProcessLauncherThreadToGoIdleObserver>;
virtual ~WaitForProcessLauncherThreadToGoIdleObserver();
// Schedules a task on the PROCESS_LAUNCHER thread to execute
// |RunOnProcessLauncherThread2|. By the time the task is executed the
// PROCESS_LAUNCHER thread should be some what idle.
void RunOnProcessLauncherThread();
// When executed the PROCESS_LAUNCHER thread should have processed any pending
// tasks. Schedules a task on the UI thread that sends the message saying
// we're done.
void RunOnProcessLauncherThread2();
// Sends the |reply_message_| to |automation_| indicating we're done.
void RunOnUIThread();
base::WeakPtr<AutomationProvider> automation_;
scoped_ptr<IPC::Message> reply_message_;
DISALLOW_COPY_AND_ASSIGN(WaitForProcessLauncherThreadToGoIdleObserver);
};
#endif // CHROME_BROWSER_AUTOMATION_AUTOMATION_PROVIDER_OBSERVERS_H_