diff options
Diffstat (limited to 'chrome/browser/automation/automation_provider.h')
| -rw-r--r-- | chrome/browser/automation/automation_provider.h | 379 |
1 files changed, 379 insertions, 0 deletions
diff --git a/chrome/browser/automation/automation_provider.h b/chrome/browser/automation/automation_provider.h new file mode 100644 index 0000000..249bc7e --- /dev/null +++ b/chrome/browser/automation/automation_provider.h @@ -0,0 +1,379 @@ +// Copyright 2008, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// This implements a browser-side endpoint for UI automation activity. +// The client-side endpoint is implemented by AutomationProxy. +// The entire lifetime of this object should be contained within that of +// the BrowserProcess, and in particular the NotificationService that's +// hung off of it. + +#ifndef CHROME_BROWSER_AUTOMATION_AUTOMATION_PROVIDER_H__ +#define CHROME_BROWSER_AUTOMATION_AUTOMATION_PROVIDER_H__ + +#include <map> +#include <string> +#include <vector> + +#include "chrome/browser/automation/automation_browser_tracker.h" +#include "chrome/browser/automation/automation_constrained_window_tracker.h" +#include "chrome/browser/automation/automation_tab_tracker.h" +#include "chrome/browser/automation/automation_window_tracker.h" +#include "chrome/browser/automation/automation_autocomplete_edit_tracker.h" +#include "chrome/browser/browser_list.h" +#include "chrome/browser/history/history.h" +#include "chrome/common/ipc_channel.h" +#include "chrome/common/ipc_message.h" +#include "chrome/common/notification_service.h" + +class LoginHandler; +class NavigationControllerRestoredObserver; + +class AutomationProvider : public base::RefCounted<AutomationProvider>, + public IPC::Channel::Listener, + public IPC::Message::Sender { + public: + AutomationProvider(Profile* profile); + virtual ~AutomationProvider(); + + // Establishes a connection to an automation client, if present. + // An AutomationProxy should be established (probably in a different process) + // before calling this. + void ConnectToChannel(const std::wstring& channel_id); + + // Sets the number of tabs that we expect; when this number of tabs has + // loaded, an AutomationMsg_InitialLoadsComplete message is sent. + void SetExpectedTabCount(size_t expected_tabs); + + // Add a listener for navigation status notification. Currently only + // navigation completion is observed; when the navigation completes, the + // completed_response object is sent; if the server requires authentication, + // we instead send the auth_needed_response object. A pointer to the added + // navigation observer is returned. This object should NOT be deleted and + // should be released by calling the corresponding + // RemoveNavigationStatusListener method. + NotificationObserver* AddNavigationStatusListener( + NavigationController* tab, IPC::Message* completed_response, + IPC::Message* auth_needed_response); + void RemoveNavigationStatusListener(NotificationObserver* obs); + + // Add an observer for the TabStrip. Currently only Tab append is observed. A + // navigation listener is created on successful notification of tab append. A + // pointer to the added navigation observer is returned. This object should + // NOT be deleted and should be released by calling the corresponding + // RemoveTabStripObserver method. + NotificationObserver* AddTabStripObserver(Browser* parent, + int32 routing_id); + void RemoveTabStripObserver(NotificationObserver* obs); + + // Get the index of a particular NavigationController object + // in the given parent window. This method uses + // TabStrip::GetIndexForNavigationController to get the index. + int GetIndexForNavigationController(const NavigationController* controller, + const Browser* parent) const; + + // Add or remove a non-owning reference to a tab's LoginHandler. This is for + // when a login prompt is shown for HTTP/FTP authentication. + // TODO(mpcomplete): The login handling is a fairly special purpose feature. + // Eventually we'll probably want ways to interact with the ChromeView of the + // login window in a generic manner, such that it can be used for anything, + // not just logins. + void AddLoginHandler(NavigationController* tab, LoginHandler* handler); + void RemoveLoginHandler(NavigationController* tab); + + // IPC implementations + virtual bool Send(IPC::Message* msg); + virtual void OnMessageReceived(const IPC::Message& msg); + virtual void OnChannelError(); + + // Received response from inspector controller + void ReceivedInspectElementResponse(int num_resources); + + private: + // IPC Message callbacks. + void CloseBrowser(const IPC::Message& message, int handle); + void ActivateTab(const IPC::Message& message, int handle, int at_index); + void AppendTab(const IPC::Message& message, int handle, const GURL& url); + void CloseTab(const IPC::Message& message, + int tab_handle, + bool wait_until_closed); + + void GetActiveTabIndex(const IPC::Message& message, int handle); + void GetCookies(const IPC::Message& message, const GURL& url, int handle); + void SetCookie(const IPC::Message& message, + const GURL& url, + const std::string value, + int handle); + void GetBrowserWindowCount(const IPC::Message& message); + void GetBrowserWindow(const IPC::Message& message, int index); + void GetLastActiveBrowserWindow(const IPC::Message& message); + void GetActiveWindow(const IPC::Message& message); + void GetWindowHWND(const IPC::Message& message, int handle); + void WindowGetViewBounds(const IPC::Message& message, + int handle, + int view_id, + bool screen_coordinates); + void WindowSimulateDrag(const IPC::Message& message, + int handle, + std::vector<POINT> drag_path, + int flags); + void WindowSimulateClick(const IPC::Message& message, + int handle, + POINT click, + int flags); + void WindowSimulateKeyPress(const IPC::Message& message, + int handle, + wchar_t key, + int flags); + void SetWindowVisible(const IPC::Message& message, int handle, bool visible); + void IsWindowActive(const IPC::Message& message, int handle); + void ActivateWindow(const IPC::Message& message, int handle); + + void GetTabCount(const IPC::Message& message, int handle); + void GetTab(const IPC::Message& message, int win_handle, int tab_index); + void GetTabHWND(const IPC::Message& message, int handle); + void GetTabProcessID(const IPC::Message& message, int handle); + void GetTabTitle(const IPC::Message& message, int handle); + void GetTabURL(const IPC::Message& message, int handle); + void HandleUnused(const IPC::Message& message, int handle); + void NavigateToURL(const IPC::Message& message, int handle, const GURL& url); + void NavigationAsync(const IPC::Message& message, + int handle, + const GURL& url); + void GoBack(const IPC::Message& message, int handle); + void GoForward(const IPC::Message& message, int handle); + void Reload(const IPC::Message& message, int handle); + void SetAuth(const IPC::Message& message, int tab_handle, + const std::wstring& username, const std::wstring& password); + void CancelAuth(const IPC::Message& message, int tab_handle); + void NeedsAuth(const IPC::Message& message, int tab_handle); + void GetRedirectsFrom(const IPC::Message& message, + int tab_handle, + const GURL& source_url); + void ExecuteJavascript(const IPC::Message& message, + int handle, + const std::wstring& frame_xpath, + const std::wstring& script); + void GetShelfVisibility(const IPC::Message& message, int handle); + void SetFilteredInet(const IPC::Message& message, bool enabled); + + void ScheduleMouseEvent(ChromeViews::View* view, + ChromeViews::Event::EventType type, + POINT point, + int flags); + void GetFocusedViewID(const IPC::Message& message, int handle); + + // Helper function to find the browser window that contains a given + // NavigationController and activate that tab. + // Returns the Browser if found. + Browser* FindAndActivateTab(NavigationController* contents); + + // Apply an accelerator with id (like IDC_BACK, IDC_FORWARD ...) + // to the Browser with given handle. + void ApplyAccelerator(int handle, int id); + + void GetConstrainedWindowCount(const IPC::Message& message, + int handle); + void GetConstrainedWindow(const IPC::Message& message, int handle, int index); + + void GetConstrainedTitle(const IPC::Message& message, int handle); + + void GetConstrainedWindowBounds(const IPC::Message& message, + int handle); + + // Responds to the FindInPage request, retrieves the search query parameters, + // launches an observer to listen for results and issues a StartFind request. + void HandleFindInPageRequest(const IPC::Message& message, + int handle, + const std::wstring& find_request, + int forward, + int match_case); + + // Responds to InspectElement request + void HandleInspectElementRequest(const IPC::Message& message, + int handle, + int x, + int y); + + void GetDownloadDirectory(const IPC::Message& message, int handle); + + // Retrieves a Browser from a Window and vice-versa. + void GetWindowForBrowser(const IPC::Message& message, int window_handle); + void GetBrowserForWindow(const IPC::Message& message, int browser_handle); + + void GetAutocompleteEditForBrowser(const IPC::Message& message, + int browser_handle); + + void OpenNewBrowserWindow(int show_command); + + void ShowInterstitialPage(const IPC::Message& message, + int tab_handle, + const std::string& html_text); + void HideInterstitialPage(const IPC::Message& message, int tab_handle); + + void CreateExternalTab(const IPC::Message& message); + void NavigateInExternalTab(const IPC::Message& message, int handle, + const GURL& url); + // The container of an externally hosted tab calls this to reflect any + // accelerator keys that it did not process. This gives the tab a chance + // to handle the keys + void ProcessUnhandledAccelerator(const IPC::Message& message, int handle, + const MSG& msg); + + // See comment in AutomationMsg_WaitForTabToBeRestored. + void WaitForTabToBeRestored(const IPC::Message& message, int tab_handle); + + // This sets the keyboard accelerators to be used by an externally + // hosted tab. This call is not valid on a regular tab hosted within + // Chrome. + void SetAcceleratorsForTab(const IPC::Message& message, int handle, + HACCEL accel_table, int accel_entry_count); + + // Gets the security state for the tab associated to the specified |handle|. + void GetSecurityState(const IPC::Message& message, int handle); + + // Gets the page type for the tab associated to the specified |handle|. + void GetPageType(const IPC::Message& message, int handle); + + // Simulates an action on the SSL blocking page at the tab specified by + // |handle|. If |proceed| is true, it is equivalent to the user pressing the + // 'Proceed' button, if false the 'Get me out of there button'. + // Not that this fails if the tab is not displaying a SSL blocking page. + void ActionOnSSLBlockingPage(const IPC::Message& message, + int handle, + bool proceed); + + // Brings the browser window to the front and activates it. + void BringBrowserToFront(const IPC::Message& message, int browser_handle); + + // Checks to see if a command on the browser's CommandController is enabled. + void IsPageMenuCommandEnabled(const IPC::Message& message, + int browser_handle, + int message_num); + + // Prints the current tab immediately. + void PrintNow(const IPC::Message& message, int tab_handle); + + // Save the current web page. + void SavePage(const IPC::Message& message, + int tab_handle, + const std::wstring& file_name, + const std::wstring& dir_path, + int type); + + // Retrieves the visible text from the autocomplete edit. + void GetAutocompleteEditText(const IPC::Message& message, + int autocomplete_edit_handle); + + // Sets the visible text from the autocomplete edit. + void SetAutocompleteEditText(const IPC::Message& message, + int autocomplete_edit_handle, + const std::wstring& text); + + // Retrieves if a query to an autocomplete provider is in progress. + void AutocompleteEditIsQueryInProgress(const IPC::Message& message, + int autocomplete_edit_handle); + + // Retrieves the individual autocomplete matches displayed by the popup. + void AutocompleteEditGetMatches(const IPC::Message& message, + int autocomplete_edit_handle); + + // Callback for history redirect queries. + virtual void OnRedirectQueryComplete( + HistoryService::Handle request_handle, + GURL from_url, + bool success, + HistoryService::RedirectList* redirects); + + typedef ObserverList<NotificationObserver> NotificationObserverList; + typedef std::map<NavigationController*, LoginHandler*> LoginHandlerMap; + + bool connected_; + scoped_ptr<IPC::Channel> channel_; + scoped_ptr<NotificationObserver> initial_load_observer_; + scoped_ptr<NotificationObserver> new_tab_ui_load_observer_; + scoped_ptr<NotificationObserver> find_in_page_observer_; + scoped_ptr<NotificationObserver> dom_operation_observer_; + scoped_ptr<NotificationObserver> dom_inspector_observer_; + scoped_ptr<AutomationTabTracker> tab_tracker_; + scoped_ptr<AutomationConstrainedWindowTracker> cwindow_tracker_; + scoped_ptr<AutomationWindowTracker> window_tracker_; + scoped_ptr<AutomationBrowserTracker> browser_tracker_; + scoped_ptr<AutomationAutocompleteEditTracker> autocomplete_edit_tracker_; + scoped_ptr<NavigationControllerRestoredObserver> restore_tracker_; + LoginHandlerMap login_handler_map_; + NotificationObserverList notification_observer_list_; + + // Handle for an in-process redirect query. We expect only one redirect query + // at a time (we should have only one caller, and it will block while waiting + // for the results) so there is only one handle. When non-0, indicates a + // query in progress. The routing ID will be set when the query is valid so + // we know where to send the response. + HistoryService::Handle redirect_query_; + int redirect_query_routing_id_; + + // routing id for inspect element request so that we can send back the + // response later + int inspect_element_routing_id_; + + // Consumer for asynchronous history queries. + CancelableRequestConsumer consumer_; + + Profile* profile_; + + DISALLOW_EVIL_CONSTRUCTORS(AutomationProvider); +}; + +// When life started, the AutomationProvider class was a singleton and was meant +// only for UI tests. It had specific behavior (like for example, when the channel +// was shut down. it closed all open Browsers). The new AutomationProvider serves +// other purposes than just UI testing. This class is meant to provide the OLD +// functionality for backward compatibility +class TestingAutomationProvider : public AutomationProvider, + public BrowserList::Observer, + public NotificationObserver { + public: + explicit TestingAutomationProvider(Profile* profile); + virtual ~TestingAutomationProvider(); + + // BrowserList::Observer implementation + // Called immediately after a browser is added to the list + virtual void OnBrowserAdded(const Browser* browser) { + } + // Called immediately before a browser is removed from the list + virtual void OnBrowserRemoving(const Browser* browser); + + // IPC implementations + virtual void OnChannelError(); + + private: + virtual void Observe(NotificationType type, + const NotificationSource& source, + const NotificationDetails& details); +}; +#endif // CHROME_BROWSER_AUTOMATION_AUTOMATION_PROVIDER_H__ |