// Copyright (c) 2009 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/automation/automation_provider.h" #include #include "app/l10n_util.h" #include "app/message_box_flags.h" #include "base/callback.h" #include "base/file_version_info.h" #include "base/json/json_reader.h" #include "base/keyboard_codes.h" #include "base/message_loop.h" #include "base/path_service.h" #include "base/process_util.h" #include "base/stl_util-inl.h" #include "base/string_util.h" #include "base/thread.h" #include "base/values.h" #include "chrome/app/chrome_dll_resource.h" #include "chrome/browser/app_modal_dialog.h" #include "chrome/browser/app_modal_dialog_queue.h" #include "chrome/browser/automation/automation_extension_function.h" #include "chrome/browser/automation/automation_provider_list.h" #include "chrome/browser/automation/automation_provider_observers.h" #include "chrome/browser/automation/extension_automation_constants.h" #include "chrome/browser/automation/extension_port_container.h" #include "chrome/browser/blocked_popup_container.h" #include "chrome/browser/browser_process.h" #include "chrome/browser/browser_window.h" #include "chrome/browser/chrome_thread.h" #include "chrome/browser/dom_operation_notification_details.h" #include "chrome/browser/debugger/devtools_manager.h" #include "chrome/browser/download/download_manager.h" #include "chrome/browser/download/download_shelf.h" #include "chrome/browser/extensions/crx_installer.h" #include "chrome/browser/extensions/extension_install_ui.h" #include "chrome/browser/extensions/extension_message_service.h" #include "chrome/browser/extensions/user_script_master.h" #include "chrome/browser/find_bar.h" #include "chrome/browser/find_bar_controller.h" #include "chrome/browser/find_notification_details.h" #include "chrome/browser/io_thread.h" #include "chrome/browser/location_bar.h" #include "chrome/browser/login_prompt.h" #include "chrome/browser/net/url_request_context_getter.h" #include "chrome/browser/net/url_request_mock_util.h" #include "chrome/browser/pref_service.h" #include "chrome/browser/profile_manager.h" #include "chrome/browser/renderer_host/render_process_host.h" #include "chrome/browser/renderer_host/render_view_host.h" #include "chrome/browser/ssl/ssl_manager.h" #include "chrome/browser/ssl/ssl_blocking_page.h" #include "chrome/browser/tab_contents/tab_contents.h" #include "chrome/browser/tab_contents/tab_contents_view.h" #include "chrome/common/automation_constants.h" #include "chrome/common/chrome_paths.h" #include "chrome/common/json_value_serializer.h" #include "chrome/common/notification_service.h" #include "chrome/common/platform_util.h" #include "chrome/common/pref_names.h" #include "chrome/common/url_constants.h" #include "chrome/test/automation/automation_messages.h" #include "chrome/test/automation/tab_proxy.h" #include "net/proxy/proxy_service.h" #include "net/proxy/proxy_config_service_fixed.h" #include "net/url_request/url_request_context.h" #include "views/event.h" #if defined(OS_WIN) // TODO(port): Port these headers. #include "chrome/browser/character_encoding.h" #include "chrome/browser/download/save_package.h" #include "chrome/browser/external_tab_container.h" #include "chrome/browser/printing/print_job.h" #endif // defined(OS_WIN) #if !defined(OS_MACOSX) // TODO(port): Port these to the mac. #include "chrome/browser/automation/ui_controls.h" #endif // !defined(OS_MACOSX) using base::Time; class AutomationInterstitialPage : public InterstitialPage { public: AutomationInterstitialPage(TabContents* tab, const GURL& url, const std::string& contents) : InterstitialPage(tab, true, url), contents_(contents) { } virtual std::string GetHTMLContents() { return contents_; } private: std::string contents_; DISALLOW_COPY_AND_ASSIGN(AutomationInterstitialPage); }; #if !defined(OS_MACOSX) class ClickTask : public Task { public: explicit ClickTask(int flags) : flags_(flags) {} virtual ~ClickTask() {} virtual void Run() { ui_controls::MouseButton button = ui_controls::LEFT; if ((flags_ & views::Event::EF_LEFT_BUTTON_DOWN) == views::Event::EF_LEFT_BUTTON_DOWN) { button = ui_controls::LEFT; } else if ((flags_ & views::Event::EF_RIGHT_BUTTON_DOWN) == views::Event::EF_RIGHT_BUTTON_DOWN) { button = ui_controls::RIGHT; } else if ((flags_ & views::Event::EF_MIDDLE_BUTTON_DOWN) == views::Event::EF_MIDDLE_BUTTON_DOWN) { button = ui_controls::MIDDLE; } else { NOTREACHED(); } ui_controls::SendMouseClick(button); } private: int flags_; DISALLOW_COPY_AND_ASSIGN(ClickTask); }; #endif AutomationProvider::AutomationProvider(Profile* profile) : redirect_query_(0), profile_(profile), reply_message_(NULL) { browser_tracker_.reset(new AutomationBrowserTracker(this)); tab_tracker_.reset(new AutomationTabTracker(this)); window_tracker_.reset(new AutomationWindowTracker(this)); autocomplete_edit_tracker_.reset( new AutomationAutocompleteEditTracker(this)); new_tab_ui_load_observer_.reset(new NewTabUILoadObserver(this)); dom_operation_observer_.reset(new DomOperationNotificationObserver(this)); metric_event_duration_observer_.reset(new MetricEventDurationObserver()); g_browser_process->AddRefModule(); } AutomationProvider::~AutomationProvider() { STLDeleteContainerPairSecondPointers(port_containers_.begin(), port_containers_.end()); port_containers_.clear(); // Make sure that any outstanding NotificationObservers also get destroyed. ObserverList::Iterator it(notification_observer_list_); NotificationObserver* observer; while ((observer = it.GetNext()) != NULL) delete observer; if (channel_.get()) { channel_->Close(); } g_browser_process->ReleaseModule(); } void AutomationProvider::ConnectToChannel(const std::string& channel_id) { automation_resource_message_filter_ = new AutomationResourceMessageFilter; channel_.reset( new IPC::SyncChannel(channel_id, IPC::Channel::MODE_CLIENT, this, automation_resource_message_filter_, g_browser_process->io_thread()->message_loop(), true, g_browser_process->shutdown_event())); scoped_ptr file_version_info( FileVersionInfo::CreateFileVersionInfoForCurrentModule()); std::string version_string; if (file_version_info != NULL) { version_string = WideToASCII(file_version_info->file_version()); } // Send a hello message with our current automation protocol version. channel_->Send(new AutomationMsg_Hello(0, version_string.c_str())); } void AutomationProvider::SetExpectedTabCount(size_t expected_tabs) { if (expected_tabs == 0) { Send(new AutomationMsg_InitialLoadsComplete(0)); } else { initial_load_observer_.reset(new InitialLoadObserver(expected_tabs, this)); } } NotificationObserver* AutomationProvider::AddNavigationStatusListener( NavigationController* tab, IPC::Message* reply_message, int number_of_navigations) { NotificationObserver* observer = new NavigationNotificationObserver(tab, this, reply_message, number_of_navigations); notification_observer_list_.AddObserver(observer); return observer; } void AutomationProvider::RemoveNavigationStatusListener( NotificationObserver* obs) { notification_observer_list_.RemoveObserver(obs); } NotificationObserver* AutomationProvider::AddTabStripObserver( Browser* parent, IPC::Message* reply_message) { NotificationObserver* observer = new TabAppendedNotificationObserver(parent, this, reply_message); notification_observer_list_.AddObserver(observer); return observer; } void AutomationProvider::RemoveTabStripObserver(NotificationObserver* obs) { notification_observer_list_.RemoveObserver(obs); } void AutomationProvider::AddLoginHandler(NavigationController* tab, LoginHandler* handler) { login_handler_map_[tab] = handler; } void AutomationProvider::RemoveLoginHandler(NavigationController* tab) { DCHECK(login_handler_map_[tab]); login_handler_map_.erase(tab); } void AutomationProvider::AddPortContainer(ExtensionPortContainer* port) { int port_id = port->port_id(); DCHECK_NE(-1, port_id); DCHECK(port_containers_.find(port_id) == port_containers_.end()); port_containers_[port_id] = port; } void AutomationProvider::RemovePortContainer(ExtensionPortContainer* port) { int port_id = port->port_id(); DCHECK_NE(-1, port_id); PortContainerMap::iterator it = port_containers_.find(port_id); DCHECK(it != port_containers_.end()); if (it != port_containers_.end()) { delete it->second; port_containers_.erase(it); } } ExtensionPortContainer* AutomationProvider::GetPortContainer( int port_id) const { PortContainerMap::const_iterator it = port_containers_.find(port_id); if (it == port_containers_.end()) return NULL; return it->second; } int AutomationProvider::GetIndexForNavigationController( const NavigationController* controller, const Browser* parent) const { DCHECK(parent); return parent->GetIndexOfController(controller); } void AutomationProvider::OnMessageReceived(const IPC::Message& message) { IPC_BEGIN_MESSAGE_MAP(AutomationProvider, message) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_CloseBrowser, CloseBrowser) IPC_MESSAGE_HANDLER(AutomationMsg_CloseBrowserRequestAsync, CloseBrowserAsync) IPC_MESSAGE_HANDLER(AutomationMsg_ActivateTab, ActivateTab) IPC_MESSAGE_HANDLER(AutomationMsg_ActiveTabIndex, GetActiveTabIndex) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_AppendTab, AppendTab) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_CloseTab, CloseTab) IPC_MESSAGE_HANDLER(AutomationMsg_GetCookies, GetCookies) IPC_MESSAGE_HANDLER(AutomationMsg_SetCookie, SetCookie) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_NavigateToURL, NavigateToURL) IPC_MESSAGE_HANDLER_DELAY_REPLY( AutomationMsg_NavigateToURLBlockUntilNavigationsComplete, NavigateToURLBlockUntilNavigationsComplete) IPC_MESSAGE_HANDLER(AutomationMsg_NavigationAsync, NavigationAsync) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_GoBack, GoBack) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_GoForward, GoForward) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_Reload, Reload) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_SetAuth, SetAuth) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_CancelAuth, CancelAuth) IPC_MESSAGE_HANDLER(AutomationMsg_NeedsAuth, NeedsAuth) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_RedirectsFrom, GetRedirectsFrom) IPC_MESSAGE_HANDLER(AutomationMsg_BrowserWindowCount, GetBrowserWindowCount) IPC_MESSAGE_HANDLER(AutomationMsg_NormalBrowserWindowCount, GetNormalBrowserWindowCount) IPC_MESSAGE_HANDLER(AutomationMsg_BrowserWindow, GetBrowserWindow) IPC_MESSAGE_HANDLER(AutomationMsg_GetBrowserLocale, GetBrowserLocale) IPC_MESSAGE_HANDLER(AutomationMsg_LastActiveBrowserWindow, GetLastActiveBrowserWindow) IPC_MESSAGE_HANDLER(AutomationMsg_ActiveWindow, GetActiveWindow) IPC_MESSAGE_HANDLER(AutomationMsg_FindNormalBrowserWindow, FindNormalBrowserWindow) IPC_MESSAGE_HANDLER(AutomationMsg_IsWindowActive, IsWindowActive) IPC_MESSAGE_HANDLER(AutomationMsg_ActivateWindow, ActivateWindow) IPC_MESSAGE_HANDLER(AutomationMsg_IsWindowMaximized, IsWindowMaximized) IPC_MESSAGE_HANDLER(AutomationMsg_WindowExecuteCommandAsync, ExecuteBrowserCommandAsync) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WindowExecuteCommand, ExecuteBrowserCommand) IPC_MESSAGE_HANDLER(AutomationMsg_TerminateSession, TerminateSession) IPC_MESSAGE_HANDLER(AutomationMsg_WindowViewBounds, WindowGetViewBounds) IPC_MESSAGE_HANDLER(AutomationMsg_GetWindowBounds, GetWindowBounds) IPC_MESSAGE_HANDLER(AutomationMsg_SetWindowBounds, SetWindowBounds) IPC_MESSAGE_HANDLER(AutomationMsg_SetWindowVisible, SetWindowVisible) #if !defined(OS_MACOSX) IPC_MESSAGE_HANDLER(AutomationMsg_WindowClick, WindowSimulateClick) IPC_MESSAGE_HANDLER(AutomationMsg_WindowMouseMove, WindowSimulateMouseMove) IPC_MESSAGE_HANDLER(AutomationMsg_WindowKeyPress, WindowSimulateKeyPress) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WindowDrag, WindowSimulateDrag) #endif IPC_MESSAGE_HANDLER(AutomationMsg_TabCount, GetTabCount) IPC_MESSAGE_HANDLER(AutomationMsg_Type, GetType) IPC_MESSAGE_HANDLER(AutomationMsg_Tab, GetTab) #if defined(OS_WIN) IPC_MESSAGE_HANDLER(AutomationMsg_TabHWND, GetTabHWND) #endif // defined(OS_WIN) IPC_MESSAGE_HANDLER(AutomationMsg_TabProcessID, GetTabProcessID) IPC_MESSAGE_HANDLER(AutomationMsg_TabTitle, GetTabTitle) IPC_MESSAGE_HANDLER(AutomationMsg_TabIndex, GetTabIndex) IPC_MESSAGE_HANDLER(AutomationMsg_TabURL, GetTabURL) IPC_MESSAGE_HANDLER(AutomationMsg_ShelfVisibility, GetShelfVisibility) IPC_MESSAGE_HANDLER(AutomationMsg_IsFullscreen, IsFullscreen) IPC_MESSAGE_HANDLER(AutomationMsg_IsFullscreenBubbleVisible, GetFullscreenBubbleVisibility) IPC_MESSAGE_HANDLER(AutomationMsg_HandleUnused, HandleUnused) IPC_MESSAGE_HANDLER(AutomationMsg_ApplyAccelerator, ApplyAccelerator) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_DomOperation, ExecuteJavascript) IPC_MESSAGE_HANDLER(AutomationMsg_ConstrainedWindowCount, GetConstrainedWindowCount) IPC_MESSAGE_HANDLER(AutomationMsg_FindInPage, HandleFindInPageRequest) IPC_MESSAGE_HANDLER(AutomationMsg_GetFocusedViewID, GetFocusedViewID) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_InspectElement, HandleInspectElementRequest) IPC_MESSAGE_HANDLER(AutomationMsg_DownloadDirectory, GetDownloadDirectory) IPC_MESSAGE_HANDLER(AutomationMsg_SetProxyConfig, SetProxyConfig); IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_OpenNewBrowserWindow, OpenNewBrowserWindow) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_OpenNewBrowserWindowOfType, OpenNewBrowserWindowOfType) IPC_MESSAGE_HANDLER(AutomationMsg_WindowForBrowser, GetWindowForBrowser) IPC_MESSAGE_HANDLER(AutomationMsg_AutocompleteEditForBrowser, GetAutocompleteEditForBrowser) IPC_MESSAGE_HANDLER(AutomationMsg_BrowserForWindow, GetBrowserForWindow) #if defined(OS_WIN) IPC_MESSAGE_HANDLER(AutomationMsg_CreateExternalTab, CreateExternalTab) #endif IPC_MESSAGE_HANDLER(AutomationMsg_NavigateInExternalTab, NavigateInExternalTab) IPC_MESSAGE_HANDLER(AutomationMsg_NavigateExternalTabAtIndex, NavigateExternalTabAtIndex) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_ShowInterstitialPage, ShowInterstitialPage) IPC_MESSAGE_HANDLER(AutomationMsg_HideInterstitialPage, HideInterstitialPage) #if defined(OS_WIN) IPC_MESSAGE_HANDLER(AutomationMsg_ProcessUnhandledAccelerator, ProcessUnhandledAccelerator) #endif IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WaitForTabToBeRestored, WaitForTabToBeRestored) IPC_MESSAGE_HANDLER(AutomationMsg_SetInitialFocus, SetInitialFocus) #if defined(OS_WIN) IPC_MESSAGE_HANDLER(AutomationMsg_TabReposition, OnTabReposition) IPC_MESSAGE_HANDLER(AutomationMsg_ForwardContextMenuCommandToChrome, OnForwardContextMenuCommandToChrome) #endif IPC_MESSAGE_HANDLER(AutomationMsg_GetSecurityState, GetSecurityState) IPC_MESSAGE_HANDLER(AutomationMsg_GetPageType, GetPageType) IPC_MESSAGE_HANDLER(AutomationMsg_GetMetricEventDuration, GetMetricEventDuration) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_ActionOnSSLBlockingPage, ActionOnSSLBlockingPage) IPC_MESSAGE_HANDLER(AutomationMsg_BringBrowserToFront, BringBrowserToFront) IPC_MESSAGE_HANDLER(AutomationMsg_IsPageMenuCommandEnabled, IsPageMenuCommandEnabled) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_PrintNow, PrintNow) IPC_MESSAGE_HANDLER(AutomationMsg_PrintAsync, PrintAsync) IPC_MESSAGE_HANDLER(AutomationMsg_SavePage, SavePage) IPC_MESSAGE_HANDLER(AutomationMsg_AutocompleteEditGetText, GetAutocompleteEditText) IPC_MESSAGE_HANDLER(AutomationMsg_AutocompleteEditSetText, SetAutocompleteEditText) IPC_MESSAGE_HANDLER(AutomationMsg_AutocompleteEditIsQueryInProgress, AutocompleteEditIsQueryInProgress) IPC_MESSAGE_HANDLER(AutomationMsg_AutocompleteEditGetMatches, AutocompleteEditGetMatches) IPC_MESSAGE_HANDLER(AutomationMsg_OpenFindInPage, HandleOpenFindInPageRequest) IPC_MESSAGE_HANDLER(AutomationMsg_HandleMessageFromExternalHost, OnMessageFromExternalHost) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_Find, HandleFindRequest) IPC_MESSAGE_HANDLER(AutomationMsg_FindWindowVisibility, GetFindWindowVisibility) IPC_MESSAGE_HANDLER(AutomationMsg_FindWindowLocation, HandleFindWindowLocationRequest) IPC_MESSAGE_HANDLER(AutomationMsg_BookmarkBarVisibility, GetBookmarkBarVisibility) IPC_MESSAGE_HANDLER(AutomationMsg_GetInfoBarCount, GetInfoBarCount) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_ClickInfoBarAccept, ClickInfoBarAccept) IPC_MESSAGE_HANDLER(AutomationMsg_GetLastNavigationTime, GetLastNavigationTime) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_WaitForNavigation, WaitForNavigation) IPC_MESSAGE_HANDLER(AutomationMsg_SetIntPreference, SetIntPreference) IPC_MESSAGE_HANDLER(AutomationMsg_ShowingAppModalDialog, GetShowingAppModalDialog) IPC_MESSAGE_HANDLER(AutomationMsg_ClickAppModalDialogButton, ClickAppModalDialogButton) IPC_MESSAGE_HANDLER(AutomationMsg_SetStringPreference, SetStringPreference) IPC_MESSAGE_HANDLER(AutomationMsg_GetBooleanPreference, GetBooleanPreference) IPC_MESSAGE_HANDLER(AutomationMsg_SetBooleanPreference, SetBooleanPreference) IPC_MESSAGE_HANDLER(AutomationMsg_GetPageCurrentEncoding, GetPageCurrentEncoding) IPC_MESSAGE_HANDLER(AutomationMsg_OverrideEncoding, OverrideEncoding) IPC_MESSAGE_HANDLER(AutomationMsg_SavePackageShouldPromptUser, SavePackageShouldPromptUser) IPC_MESSAGE_HANDLER(AutomationMsg_WindowTitle, GetWindowTitle) #if defined(OS_WIN) // Depends on ExternalTabContainer, so Windows-only IPC_MESSAGE_HANDLER(AutomationMsg_SetEnableExtensionAutomation, SetEnableExtensionAutomation) #endif IPC_MESSAGE_HANDLER(AutomationMsg_SetShelfVisibility, SetShelfVisibility) IPC_MESSAGE_HANDLER(AutomationMsg_BlockedPopupCount, GetBlockedPopupCount) IPC_MESSAGE_HANDLER(AutomationMsg_SelectAll, SelectAll) IPC_MESSAGE_HANDLER(AutomationMsg_Cut, Cut) IPC_MESSAGE_HANDLER(AutomationMsg_Copy, Copy) IPC_MESSAGE_HANDLER(AutomationMsg_Paste, Paste) IPC_MESSAGE_HANDLER(AutomationMsg_ReloadAsync, ReloadAsync) IPC_MESSAGE_HANDLER(AutomationMsg_StopAsync, StopAsync) IPC_MESSAGE_HANDLER_DELAY_REPLY( AutomationMsg_WaitForBrowserWindowCountToBecome, WaitForBrowserWindowCountToBecome) IPC_MESSAGE_HANDLER_DELAY_REPLY( AutomationMsg_WaitForAppModalDialogToBeShown, WaitForAppModalDialogToBeShown) IPC_MESSAGE_HANDLER_DELAY_REPLY( AutomationMsg_GoBackBlockUntilNavigationsComplete, GoBackBlockUntilNavigationsComplete) IPC_MESSAGE_HANDLER_DELAY_REPLY( AutomationMsg_GoForwardBlockUntilNavigationsComplete, GoForwardBlockUntilNavigationsComplete) #if defined(OS_WIN) IPC_MESSAGE_HANDLER(AutomationMsg_ConnectExternalTab, ConnectExternalTab) #endif IPC_MESSAGE_HANDLER(AutomationMsg_SetPageFontSize, OnSetPageFontSize) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_InstallExtension, InstallExtension) IPC_MESSAGE_HANDLER_DELAY_REPLY(AutomationMsg_LoadExpandedExtension, LoadExpandedExtension) IPC_MESSAGE_HANDLER(AutomationMsg_ShutdownSessionService, ShutdownSessionService) IPC_MESSAGE_HANDLER(AutomationMsg_SaveAsAsync, SaveAsAsync) #if defined(OS_WIN) IPC_MESSAGE_HANDLER(AutomationMsg_BrowserMove, OnBrowserMoved) #endif IPC_END_MESSAGE_MAP() } void AutomationProvider::ActivateTab(int handle, int at_index, int* status) { *status = -1; if (browser_tracker_->ContainsHandle(handle) && at_index > -1) { Browser* browser = browser_tracker_->GetResource(handle); if (at_index >= 0 && at_index < browser->tab_count()) { browser->SelectTabContentsAt(at_index, true); *status = 0; } } } void AutomationProvider::AppendTab(int handle, const GURL& url, IPC::Message* reply_message) { int append_tab_response = -1; // -1 is the error code NotificationObserver* observer = NULL; if (browser_tracker_->ContainsHandle(handle)) { Browser* browser = browser_tracker_->GetResource(handle); observer = AddTabStripObserver(browser, reply_message); TabContents* tab_contents = browser->AddTabWithURL(url, GURL(), PageTransition::TYPED, true, -1, false, NULL); if (tab_contents) { append_tab_response = GetIndexForNavigationController(&tab_contents->controller(), browser); } } if (append_tab_response < 0) { // The append tab failed. Remove the TabStripObserver if (observer) { RemoveTabStripObserver(observer); delete observer; } AutomationMsg_AppendTab::WriteReplyParams(reply_message, append_tab_response); Send(reply_message); } } void AutomationProvider::NavigateToURL(int handle, const GURL& url, IPC::Message* reply_message) { NavigateToURLBlockUntilNavigationsComplete(handle, url, 1, reply_message); } void AutomationProvider::NavigateToURLBlockUntilNavigationsComplete( int handle, const GURL& url, int number_of_navigations, IPC::Message* reply_message) { if (tab_tracker_->ContainsHandle(handle)) { NavigationController* tab = tab_tracker_->GetResource(handle); // Simulate what a user would do. Activate the tab and then navigate. // We could allow navigating in a background tab in future. Browser* browser = FindAndActivateTab(tab); if (browser) { AddNavigationStatusListener(tab, reply_message, number_of_navigations); // TODO(darin): avoid conversion to GURL browser->OpenURL(url, GURL(), CURRENT_TAB, PageTransition::TYPED); return; } } AutomationMsg_NavigateToURL::WriteReplyParams( reply_message, AUTOMATION_MSG_NAVIGATION_ERROR); Send(reply_message); } void AutomationProvider::NavigationAsync(int handle, const GURL& url, bool* status) { *status = false; if (tab_tracker_->ContainsHandle(handle)) { NavigationController* tab = tab_tracker_->GetResource(handle); // Simulate what a user would do. Activate the tab and then navigate. // We could allow navigating in a background tab in future. Browser* browser = FindAndActivateTab(tab); if (browser) { // Don't add any listener unless a callback mechanism is desired. // TODO(vibhor): Do this if such a requirement arises in future. browser->OpenURL(url, GURL(), CURRENT_TAB, PageTransition::TYPED); *status = true; } } } void AutomationProvider::GoBack(int handle, IPC::Message* reply_message) { if (tab_tracker_->ContainsHandle(handle)) { NavigationController* tab = tab_tracker_->GetResource(handle); Browser* browser = FindAndActivateTab(tab); if (browser && browser->command_updater()->IsCommandEnabled(IDC_BACK)) { AddNavigationStatusListener(tab, reply_message, 1); browser->GoBack(CURRENT_TAB); return; } } AutomationMsg_GoBack::WriteReplyParams( reply_message, AUTOMATION_MSG_NAVIGATION_ERROR); Send(reply_message); } void AutomationProvider::GoForward(int handle, IPC::Message* reply_message) { if (tab_tracker_->ContainsHandle(handle)) { NavigationController* tab = tab_tracker_->GetResource(handle); Browser* browser = FindAndActivateTab(tab); if (browser && browser->command_updater()->IsCommandEnabled(IDC_FORWARD)) { AddNavigationStatusListener(tab, reply_message, 1); browser->GoForward(CURRENT_TAB); return; } } AutomationMsg_GoForward::WriteReplyParams( reply_message, AUTOMATION_MSG_NAVIGATION_ERROR); Send(reply_message); } void AutomationProvider::Reload(int handle, IPC::Message* reply_message) { if (tab_tracker_->ContainsHandle(handle)) { NavigationController* tab = tab_tracker_->GetResource(handle); Browser* browser = FindAndActivateTab(tab); if (browser && browser->command_updater()->IsCommandEnabled(IDC_RELOAD)) { AddNavigationStatusListener(tab, reply_message, 1); browser->Reload(); return; } } AutomationMsg_Reload::WriteReplyParams( reply_message, AUTOMATION_MSG_NAVIGATION_ERROR); Send(reply_message); } void AutomationProvider::SetAuth(int tab_handle, const std::wstring& username, const std::wstring& password, IPC::Message* reply_message) { if (tab_tracker_->ContainsHandle(tab_handle)) { NavigationController* tab = tab_tracker_->GetResource(tab_handle); LoginHandlerMap::iterator iter = login_handler_map_.find(tab); if (iter != login_handler_map_.end()) { // If auth is needed again after this, assume login has failed. This is // not strictly correct, because a navigation can require both proxy and // server auth, but it should be OK for now. LoginHandler* handler = iter->second; AddNavigationStatusListener(tab, reply_message, 1); handler->SetAuth(username, password); return; } } AutomationMsg_SetAuth::WriteReplyParams( reply_message, AUTOMATION_MSG_NAVIGATION_AUTH_NEEDED); Send(reply_message); } void AutomationProvider::CancelAuth(int tab_handle, IPC::Message* reply_message) { if (tab_tracker_->ContainsHandle(tab_handle)) { NavigationController* tab = tab_tracker_->GetResource(tab_handle); LoginHandlerMap::iterator iter = login_handler_map_.find(tab); if (iter != login_handler_map_.end()) { // If auth is needed again after this, something is screwy. LoginHandler* handler = iter->second; AddNavigationStatusListener(tab, reply_message, 1); handler->CancelAuth(); return; } } AutomationMsg_CancelAuth::WriteReplyParams( reply_message, AUTOMATION_MSG_NAVIGATION_AUTH_NEEDED); Send(reply_message); } void AutomationProvider::NeedsAuth(int tab_handle, bool* needs_auth) { *needs_auth = false; if (tab_tracker_->ContainsHandle(tab_handle)) { NavigationController* tab = tab_tracker_->GetResource(tab_handle); LoginHandlerMap::iterator iter = login_handler_map_.find(tab); if (iter != login_handler_map_.end()) { // The LoginHandler will be in our map IFF the tab needs auth. *needs_auth = true; } } } void AutomationProvider::GetRedirectsFrom(int tab_handle, const GURL& source_url, IPC::Message* reply_message) { DCHECK(!redirect_query_) << "Can only handle one redirect query at once."; if (tab_tracker_->ContainsHandle(tab_handle)) { NavigationController* tab = tab_tracker_->GetResource(tab_handle); HistoryService* history_service = tab->profile()->GetHistoryService(Profile::EXPLICIT_ACCESS); DCHECK(history_service) << "Tab " << tab_handle << "'s profile " << "has no history service"; if (history_service) { DCHECK(reply_message_ == NULL); reply_message_ = reply_message; // Schedule a history query for redirects. The response will be sent // asynchronously from the callback the history system uses to notify us // that it's done: OnRedirectQueryComplete. redirect_query_ = history_service->QueryRedirectsFrom( source_url, &consumer_, NewCallback(this, &AutomationProvider::OnRedirectQueryComplete)); return; // Response will be sent when query completes. } } // Send failure response. std::vector empty; AutomationMsg_RedirectsFrom::WriteReplyParams(reply_message, false, empty); Send(reply_message); } void AutomationProvider::GetActiveTabIndex(int handle, int* active_tab_index) { *active_tab_index = -1; // -1 is the error code if (browser_tracker_->ContainsHandle(handle)) { Browser* browser = browser_tracker_->GetResource(handle); *active_tab_index = browser->selected_index(); } } void AutomationProvider::GetBrowserLocale(string16* locale) { DCHECK(g_browser_process); *locale = ASCIIToUTF16(g_browser_process->GetApplicationLocale()); } void AutomationProvider::GetBrowserWindowCount(int* window_count) { *window_count = static_cast(BrowserList::size()); } void AutomationProvider::GetNormalBrowserWindowCount(int* window_count) { *window_count = static_cast( BrowserList::GetBrowserCountForType(profile_, Browser::TYPE_NORMAL)); } void AutomationProvider::GetShowingAppModalDialog(bool* showing_dialog, int* dialog_button) { AppModalDialog* dialog_delegate = Singleton()->active_dialog(); *showing_dialog = (dialog_delegate != NULL); if (*showing_dialog) *dialog_button = dialog_delegate->GetDialogButtons(); else *dialog_button = MessageBoxFlags::DIALOGBUTTON_NONE; } void AutomationProvider::ClickAppModalDialogButton(int button, bool* success) { *success = false; AppModalDialog* dialog_delegate = Singleton()->active_dialog(); if (dialog_delegate && (dialog_delegate->GetDialogButtons() & button) == button) { if ((button & MessageBoxFlags::DIALOGBUTTON_OK) == MessageBoxFlags::DIALOGBUTTON_OK) { dialog_delegate->AcceptWindow(); *success = true; } if ((button & MessageBoxFlags::DIALOGBUTTON_CANCEL) == MessageBoxFlags::DIALOGBUTTON_CANCEL) { DCHECK(!*success) << "invalid param, OK and CANCEL specified"; dialog_delegate->CancelWindow(); *success = true; } } } void AutomationProvider::ShutdownSessionService(int handle, bool* result) { if (browser_tracker_->ContainsHandle(handle)) { Browser* browser = browser_tracker_->GetResource(handle); browser->profile()->ShutdownSessionService(); *result = true; } else { *result = false; } } void AutomationProvider::GetBrowserWindow(int index, int* handle) { *handle = 0; if (index >= 0) { BrowserList::const_iterator iter = BrowserList::begin(); for (; (iter != BrowserList::end()) && (index > 0); ++iter, --index); if (iter != BrowserList::end()) { *handle = browser_tracker_->Add(*iter); } } } void AutomationProvider::FindNormalBrowserWindow(int* handle) { *handle = 0; Browser* browser = BrowserList::FindBrowserWithType(profile_, Browser::TYPE_NORMAL); if (browser) *handle = browser_tracker_->Add(browser); } void AutomationProvider::GetLastActiveBrowserWindow(int* handle) { *handle = 0; Browser* browser = BrowserList::GetLastActive(); if (browser) *handle = browser_tracker_->Add(browser); } #if defined(OS_POSIX) // TODO(estade): use this implementation for all platforms? void AutomationProvider::GetActiveWindow(int* handle) { gfx::NativeWindow window = BrowserList::GetLastActive()->window()->GetNativeHandle(); *handle = window_tracker_->Add(window); } #endif void AutomationProvider::ExecuteBrowserCommandAsync(int handle, int command, bool* success) { *success = false; if (browser_tracker_->ContainsHandle(handle)) { Browser* browser = browser_tracker_->GetResource(handle); if (browser->command_updater()->SupportsCommand(command) && browser->command_updater()->IsCommandEnabled(command)) { browser->ExecuteCommand(command); *success = true; } } } void AutomationProvider::ExecuteBrowserCommand( int handle, int command, IPC::Message* reply_message) { // List of commands which just finish synchronously and don't require // setting up an observer. static const int kSynchronousCommands[] = { IDC_HOME, IDC_SELECT_NEXT_TAB, IDC_SELECT_PREVIOUS_TAB, IDC_SHOW_DOWNLOADS, IDC_SHOW_HISTORY, }; if (browser_tracker_->ContainsHandle(handle)) { Browser* browser = browser_tracker_->GetResource(handle); if (browser->command_updater()->SupportsCommand(command) && browser->command_updater()->IsCommandEnabled(command)) { // First check if we can handle the command without using an observer. for (size_t i = 0; i < arraysize(kSynchronousCommands); i++) { if (command == kSynchronousCommands[i]) { browser->ExecuteCommand(command); AutomationMsg_WindowExecuteCommand::WriteReplyParams(reply_message, true); Send(reply_message); return; } } // Use an observer if we have one, otherwise fail. if (ExecuteBrowserCommandObserver::CreateAndRegisterObserver( this, browser, command, reply_message)) { browser->ExecuteCommand(command); return; } } } AutomationMsg_WindowExecuteCommand::WriteReplyParams(reply_message, false); Send(reply_message); } // This task just adds another task to the event queue. This is useful if // you want to ensure that any tasks added to the event queue after this one // have already been processed by the time |task| is run. class InvokeTaskLaterTask : public Task { public: explicit InvokeTaskLaterTask(Task* task) : task_(task) {} virtual ~InvokeTaskLaterTask() {} virtual void Run() { MessageLoop::current()->PostTask(FROM_HERE, task_); } private: Task* task_; DISALLOW_COPY_AND_ASSIGN(InvokeTaskLaterTask); }; #if !defined(OS_MACOSX) void AutomationProvider::WindowSimulateClick(const IPC::Message& message, int handle, const gfx::Point& click, int flags) { if (window_tracker_->ContainsHandle(handle)) { ui_controls::SendMouseMoveNotifyWhenDone(click.x(), click.y(), new ClickTask(flags)); } } void AutomationProvider::WindowSimulateMouseMove(const IPC::Message& message, int handle, const gfx::Point& location) { if (window_tracker_->ContainsHandle(handle)) ui_controls::SendMouseMove(location.x(), location.y()); } void AutomationProvider::WindowSimulateKeyPress(const IPC::Message& message, int handle, int key, int flags) { if (!window_tracker_->ContainsHandle(handle)) return; gfx::NativeWindow window = window_tracker_->GetResource(handle); // The key event is sent to whatever window is active. ui_controls::SendKeyPress(window, static_cast(key), ((flags & views::Event::EF_CONTROL_DOWN) == views::Event::EF_CONTROL_DOWN), ((flags & views::Event::EF_SHIFT_DOWN) == views::Event::EF_SHIFT_DOWN), ((flags & views::Event::EF_ALT_DOWN) == views::Event::EF_ALT_DOWN)); } #endif // !defined(OS_MACOSX) void AutomationProvider::IsWindowActive(int handle, bool* success, bool* is_active) { if (window_tracker_->ContainsHandle(handle)) { *is_active = platform_util::IsWindowActive(window_tracker_->GetResource(handle)); *success = true; } else { *success = false; *is_active = false; } } void AutomationProvider::GetTabCount(int handle, int* tab_count) { *tab_count = -1; // -1 is the error code if (browser_tracker_->ContainsHandle(handle)) { Browser* browser = browser_tracker_->GetResource(handle); *tab_count = browser->tab_count(); } } void AutomationProvider::GetType(int handle, int* type_as_int) { *type_as_int = -1; // -1 is the error code if (browser_tracker_->ContainsHandle(handle)) { Browser* browser = browser_tracker_->GetResource(handle); *type_as_int = static_cast(browser->type()); } } void AutomationProvider::GetTab(int win_handle, int tab_index, int* tab_handle) { *tab_handle = 0; if (browser_tracker_->ContainsHandle(win_handle) && (tab_index >= 0)) { Browser* browser = browser_tracker_->GetResource(win_handle); if (tab_index < browser->tab_count()) { TabContents* tab_contents = browser->GetTabContentsAt(tab_index); *tab_handle = tab_tracker_->Add(&tab_contents->controller()); } } } void AutomationProvider::GetTabTitle(int handle, int* title_string_size, std::wstring* title) { *title_string_size = -1; // -1 is the error code if (tab_tracker_->ContainsHandle(handle)) { NavigationController* tab = tab_tracker_->GetResource(handle); NavigationEntry* entry = tab->GetActiveEntry(); if (entry != NULL) { *title = UTF16ToWideHack(entry->title()); } else { *title = std::wstring(); } *title_string_size = static_cast(title->size()); } } void AutomationProvider::GetTabIndex(int handle, int* tabstrip_index) { *tabstrip_index = -1; // -1 is the error code if (tab_tracker_->ContainsHandle(handle)) { NavigationController* tab = tab_tracker_->GetResource(handle); Browser* browser = Browser::GetBrowserForController(tab, NULL); *tabstrip_index = browser->tabstrip_model()->GetIndexOfController(tab); } } void AutomationProvider::HandleUnused(const IPC::Message& message, int handle) { if (window_tracker_->ContainsHandle(handle)) { window_tracker_->Remove(window_tracker_->GetResource(handle)); } } void AutomationProvider::OnChannelError() { LOG(INFO) << "AutomationProxy went away, shutting down app."; AutomationProviderList::GetInstance()->RemoveProvider(this); } // TODO(brettw) change this to accept GURLs when history supports it void AutomationProvider::OnRedirectQueryComplete( HistoryService::Handle request_handle, GURL from_url, bool success, history::RedirectList* redirects) { DCHECK(request_handle == redirect_query_); DCHECK(reply_message_ != NULL); std::vector redirects_gurl; if (success) { reply_message_->WriteBool(true); for (size_t i = 0; i < redirects->size(); i++) redirects_gurl.push_back(redirects->at(i)); } else { reply_message_->WriteInt(-1); // Negative count indicates failure. } IPC::ParamTraits >::Write(reply_message_, redirects_gurl); Send(reply_message_); redirect_query_ = NULL; reply_message_ = NULL; } bool AutomationProvider::Send(IPC::Message* msg) { DCHECK(channel_.get()); return channel_->Send(msg); } Browser* AutomationProvider::FindAndActivateTab( NavigationController* controller) { int tab_index; Browser* browser = Browser::GetBrowserForController(controller, &tab_index); if (browser) browser->SelectTabContentsAt(tab_index, true); return browser; } void AutomationProvider::GetCookies(const GURL& url, int handle, int* value_size, std::string* value) { *value_size = -1; if (url.is_valid() && tab_tracker_->ContainsHandle(handle)) { NavigationController* tab = tab_tracker_->GetResource(handle); // Since we are running on the UI thread don't call GetURLRequestContext(). net::CookieStore* cookie_store = tab->profile()->GetRequestContext()->GetCookieStore(); *value = cookie_store->GetCookies(url); *value_size = static_cast(value->size()); } } void AutomationProvider::SetCookie(const GURL& url, const std::string value, int handle, int* response_value) { *response_value = -1; if (url.is_valid() && tab_tracker_->ContainsHandle(handle)) { NavigationController* tab = tab_tracker_->GetResource(handle); scoped_refptr request_context = tab->tab_contents()->request_context(); if (!request_context.get()) request_context = tab->profile()->GetRequestContext(); // Since we are running on the UI thread don't call GetURLRequestContext(). scoped_refptr cookie_store = request_context->GetCookieStore(); if (cookie_store->SetCookie(url, value)) *response_value = 1; } } void AutomationProvider::GetTabURL(int handle, bool* success, GURL* url) { *success = false; if (tab_tracker_->ContainsHandle(handle)) { NavigationController* tab = tab_tracker_->GetResource(handle); // Return what the user would see in the location bar. *url = tab->GetActiveEntry()->virtual_url(); *success = true; } } void AutomationProvider::GetTabProcessID(int handle, int* process_id) { *process_id = -1; if (tab_tracker_->ContainsHandle(handle)) { *process_id = 0; TabContents* tab_contents = tab_tracker_->GetResource(handle)->tab_contents(); RenderProcessHost* rph = tab_contents->GetRenderProcessHost(); if (rph) *process_id = base::GetProcId(rph->GetHandle()); } } void AutomationProvider::ApplyAccelerator(int handle, int id) { NOTREACHED() << "This function has been deprecated. " << "Please use ExecuteBrowserCommandAsync instead."; } void AutomationProvider::ExecuteJavascript(int handle, const std::wstring& frame_xpath, const std::wstring& script, IPC::Message* reply_message) { bool succeeded = false; TabContents* tab_contents = GetTabContentsForHandle(handle, NULL); if (tab_contents) { // Set the routing id of this message with the controller. // This routing id needs to be remembered for the reverse // communication while sending back the response of // this javascript execution. std::wstring set_automation_id; SStringPrintf(&set_automation_id, L"window.domAutomationController.setAutomationId(%d);", reply_message->routing_id()); DCHECK(reply_message_ == NULL); reply_message_ = reply_message; tab_contents->render_view_host()->ExecuteJavascriptInWebFrame( frame_xpath, set_automation_id); tab_contents->render_view_host()->ExecuteJavascriptInWebFrame( frame_xpath, script); succeeded = true; } if (!succeeded) { AutomationMsg_DomOperation::WriteReplyParams(reply_message, std::string()); Send(reply_message); } } void AutomationProvider::GetShelfVisibility(int handle, bool* visible) { *visible = false; if (browser_tracker_->ContainsHandle(handle)) { #if defined(OS_CHROMEOS) // Chromium OS shows FileBrowse ui rather than download shelf. So we // enumerate all browsers and look for a chrome://filebrowse... pop up. for (BrowserList::const_iterator it = BrowserList::begin(); it != BrowserList::end(); ++it) { if ((*it)->type() == Browser::TYPE_POPUP) { const GURL& url = (*it)->GetTabContentsAt((*it)->selected_index())->GetURL(); if (url.SchemeIs(chrome::kChromeUIScheme) && url.host() == chrome::kChromeUIFileBrowseHost) { *visible = true; break; } } } #else Browser* browser = browser_tracker_->GetResource(handle); if (browser) { *visible = browser->window()->IsDownloadShelfVisible(); } #endif } } void AutomationProvider::SetShelfVisibility(int handle, bool visible) { if (browser_tracker_->ContainsHandle(handle)) { Browser* browser = browser_tracker_->GetResource(handle); if (browser) { if (visible) browser->window()->GetDownloadShelf()->Show(); else browser->window()->GetDownloadShelf()->Close(); } } } void AutomationProvider::IsFullscreen(int handle, bool* visible) { *visible = false; if (browser_tracker_->ContainsHandle(handle)) { Browser* browser = browser_tracker_->GetResource(handle); if (browser) *visible = browser->window()->IsFullscreen(); } } void AutomationProvider::GetFullscreenBubbleVisibility(int handle, bool* visible) { *visible = false; if (browser_tracker_->ContainsHandle(handle)) { Browser* browser = browser_tracker_->GetResource(handle); if (browser) *visible = browser->window()->IsFullscreenBubbleVisible(); } } void AutomationProvider::GetConstrainedWindowCount(int handle, int* count) { *count = -1; // -1 is the error code if (tab_tracker_->ContainsHandle(handle)) { NavigationController* nav_controller = tab_tracker_->GetResource(handle); TabContents* tab_contents = nav_controller->tab_contents(); if (tab_contents) { *count = static_cast(tab_contents->child_windows_.size()); } } } void AutomationProvider::HandleFindInPageRequest( int handle, const std::wstring& find_request, int forward, int match_case, int* active_ordinal, int* matches_found) { NOTREACHED() << "This function has been deprecated." << "Please use HandleFindRequest instead."; *matches_found = -1; return; } void AutomationProvider::HandleFindRequest( int handle, const AutomationMsg_Find_Params& params, IPC::Message* reply_message) { if (!tab_tracker_->ContainsHandle(handle)) { AutomationMsg_FindInPage::WriteReplyParams(reply_message, -1, -1); Send(reply_message); return; } NavigationController* nav = tab_tracker_->GetResource(handle); TabContents* tab_contents = nav->tab_contents(); find_in_page_observer_.reset(new FindInPageNotificationObserver(this, tab_contents, reply_message)); tab_contents->set_current_find_request_id( FindInPageNotificationObserver::kFindInPageRequestId); tab_contents->render_view_host()->StartFinding( FindInPageNotificationObserver::kFindInPageRequestId, params.search_string, params.forward, params.match_case, params.find_next); } void AutomationProvider::HandleOpenFindInPageRequest( const IPC::Message& message, int handle) { if (browser_tracker_->ContainsHandle(handle)) { Browser* browser = browser_tracker_->GetResource(handle); browser->FindInPage(false, false); } } void AutomationProvider::GetFindWindowVisibility(int handle, bool* visible) { *visible = false; Browser* browser = browser_tracker_->GetResource(handle); if (browser) { FindBarTesting* find_bar = browser->GetFindBarController()->find_bar()->GetFindBarTesting(); find_bar->GetFindBarWindowInfo(NULL, visible); } } void AutomationProvider::HandleFindWindowLocationRequest(int handle, int* x, int* y) { gfx::Point position(0, 0); bool visible = false; if (browser_tracker_->ContainsHandle(handle)) { Browser* browser = browser_tracker_->GetResource(handle); FindBarTesting* find_bar = browser->GetFindBarController()->find_bar()->GetFindBarTesting(); find_bar->GetFindBarWindowInfo(&position, &visible); } *x = position.x(); *y = position.y(); } void AutomationProvider::HandleInspectElementRequest( int handle, int x, int y, IPC::Message* reply_message) { TabContents* tab_contents = GetTabContentsForHandle(handle, NULL); if (tab_contents) { DCHECK(reply_message_ == NULL); reply_message_ = reply_message; DevToolsManager::GetInstance()->InspectElement( tab_contents->render_view_host(), x, y); } else { AutomationMsg_InspectElement::WriteReplyParams(reply_message, -1); Send(reply_message); } } void AutomationProvider::ReceivedInspectElementResponse(int num_resources) { if (reply_message_) { AutomationMsg_InspectElement::WriteReplyParams(reply_message_, num_resources); Send(reply_message_); reply_message_ = NULL; } } class SetProxyConfigTask : public Task { public: SetProxyConfigTask(URLRequestContextGetter* request_context_getter, const std::string& new_proxy_config) : request_context_getter_(request_context_getter), proxy_config_(new_proxy_config) {} virtual void Run() { // First, deserialize the JSON string. If this fails, log and bail. JSONStringValueSerializer deserializer(proxy_config_); std::string error_message; scoped_ptr root(deserializer.Deserialize(&error_message)); if (!root.get() || root->GetType() != Value::TYPE_DICTIONARY) { DLOG(WARNING) << "Received bad JSON string for ProxyConfig: " << error_message; return; } scoped_ptr dict( static_cast(root.release())); // Now put together a proxy configuration from the deserialized string. net::ProxyConfig pc; PopulateProxyConfig(*dict.get(), &pc); net::ProxyService* proxy_service = request_context_getter_->GetURLRequestContext()->proxy_service(); DCHECK(proxy_service); scoped_ptr proxy_config_service( new net::ProxyConfigServiceFixed(pc)); proxy_service->ResetConfigService(proxy_config_service.release()); } void PopulateProxyConfig(const DictionaryValue& dict, net::ProxyConfig* pc) { DCHECK(pc); bool no_proxy = false; if (dict.GetBoolean(automation::kJSONProxyNoProxy, &no_proxy)) { // Make no changes to the ProxyConfig. return; } bool auto_config; if (dict.GetBoolean(automation::kJSONProxyAutoconfig, &auto_config)) { pc->set_auto_detect(true); } std::string pac_url; if (dict.GetString(automation::kJSONProxyPacUrl, &pac_url)) { pc->set_pac_url(GURL(pac_url)); } std::string proxy_bypass_list; if (dict.GetString(automation::kJSONProxyBypassList, &proxy_bypass_list)) { pc->proxy_rules().bypass_rules.ParseFromString(proxy_bypass_list); } std::string proxy_server; if (dict.GetString(automation::kJSONProxyServer, &proxy_server)) { pc->proxy_rules().ParseFromString(proxy_server); } } private: scoped_refptr request_context_getter_; std::string proxy_config_; }; void AutomationProvider::SetProxyConfig(const std::string& new_proxy_config) { URLRequestContextGetter* context_getter = Profile::GetDefaultRequestContext(); if (!context_getter) { FilePath user_data_dir; PathService::Get(chrome::DIR_USER_DATA, &user_data_dir); ProfileManager* profile_manager = g_browser_process->profile_manager(); DCHECK(profile_manager); Profile* profile = profile_manager->GetDefaultProfile(user_data_dir); DCHECK(profile); context_getter = profile->GetRequestContext(); } DCHECK(context_getter); ChromeThread::PostTask( ChromeThread::IO, FROM_HERE, new SetProxyConfigTask(context_getter, new_proxy_config)); } void AutomationProvider::GetDownloadDirectory( int handle, FilePath* download_directory) { DLOG(INFO) << "Handling download directory request"; if (tab_tracker_->ContainsHandle(handle)) { NavigationController* tab = tab_tracker_->GetResource(handle); DownloadManager* dlm = tab->profile()->GetDownloadManager(); DCHECK(dlm); *download_directory = dlm->download_path(); } } void AutomationProvider::OpenNewBrowserWindow(bool show, IPC::Message* reply_message) { OpenNewBrowserWindowOfType(static_cast(Browser::TYPE_NORMAL), show, reply_message); } void AutomationProvider::OpenNewBrowserWindowOfType( int type, bool show, IPC::Message* reply_message) { new BrowserOpenedNotificationObserver(this, reply_message); // We may have no current browser windows open so don't rely on // asking an existing browser to execute the IDC_NEWWINDOW command Browser* browser = new Browser(static_cast(type), profile_); browser->CreateBrowserWindow(); browser->AddBlankTab(true); if (show) browser->window()->Show(); } void AutomationProvider::GetWindowForBrowser(int browser_handle, bool* success, int* handle) { *success = false; *handle = 0; if (browser_tracker_->ContainsHandle(browser_handle)) { Browser* browser = browser_tracker_->GetResource(browser_handle); gfx::NativeWindow win = browser->window()->GetNativeHandle(); // Add() returns the existing handle for the resource if any. *handle = window_tracker_->Add(win); *success = true; } } #if !defined(OS_MACOSX) void AutomationProvider::GetAutocompleteEditForBrowser( int browser_handle, bool* success, int* autocomplete_edit_handle) { *success = false; *autocomplete_edit_handle = 0; if (browser_tracker_->ContainsHandle(browser_handle)) { Browser* browser = browser_tracker_->GetResource(browser_handle); LocationBar* loc_bar = browser->window()->GetLocationBar(); AutocompleteEditView* edit_view = loc_bar->location_entry(); // Add() returns the existing handle for the resource if any. *autocomplete_edit_handle = autocomplete_edit_tracker_->Add(edit_view); *success = true; } } #endif // !defined(OS_MACOSX) void AutomationProvider::ShowInterstitialPage(int tab_handle, const std::string& html_text, IPC::Message* reply_message) { if (tab_tracker_->ContainsHandle(tab_handle)) { NavigationController* controller = tab_tracker_->GetResource(tab_handle); TabContents* tab_contents = controller->tab_contents(); AddNavigationStatusListener(controller, reply_message, 1); AutomationInterstitialPage* interstitial = new AutomationInterstitialPage(tab_contents, GURL("about:interstitial"), html_text); interstitial->Show(); return; } AutomationMsg_ShowInterstitialPage::WriteReplyParams( reply_message, AUTOMATION_MSG_NAVIGATION_ERROR); Send(reply_message); } void AutomationProvider::HideInterstitialPage(int tab_handle, bool* success) { *success = false; TabContents* tab_contents = GetTabContentsForHandle(tab_handle, NULL); if (tab_contents && tab_contents->interstitial_page()) { tab_contents->interstitial_page()->DontProceed(); *success = true; } } void AutomationProvider::CloseTab(int tab_handle, bool wait_until_closed, IPC::Message* reply_message) { if (tab_tracker_->ContainsHandle(tab_handle)) { NavigationController* controller = tab_tracker_->GetResource(tab_handle); int index; Browser* browser = Browser::GetBrowserForController(controller, &index); DCHECK(browser); new TabClosedNotificationObserver(this, wait_until_closed, reply_message); browser->CloseContents(controller->tab_contents()); return; } AutomationMsg_CloseTab::WriteReplyParams(reply_message, false); Send(reply_message); } void AutomationProvider::CloseBrowser(int browser_handle, IPC::Message* reply_message) { if (browser_tracker_->ContainsHandle(browser_handle)) { Browser* browser = browser_tracker_->GetResource(browser_handle); new BrowserClosedNotificationObserver(browser, this, reply_message); browser->window()->Close(); } else { NOTREACHED(); } } void AutomationProvider::CloseBrowserAsync(int browser_handle) { if (browser_tracker_->ContainsHandle(browser_handle)) { Browser* browser = browser_tracker_->GetResource(browser_handle); browser->window()->Close(); } else { NOTREACHED(); } } void AutomationProvider::NavigateInExternalTab( int handle, const GURL& url, const GURL& referrer, AutomationMsg_NavigationResponseValues* status) { *status = AUTOMATION_MSG_NAVIGATION_ERROR; if (tab_tracker_->ContainsHandle(handle)) { NavigationController* tab = tab_tracker_->GetResource(handle); tab->LoadURL(url, referrer, PageTransition::TYPED); *status = AUTOMATION_MSG_NAVIGATION_SUCCESS; } } void AutomationProvider::NavigateExternalTabAtIndex( int handle, int navigation_index, AutomationMsg_NavigationResponseValues* status) { *status = AUTOMATION_MSG_NAVIGATION_ERROR; if (tab_tracker_->ContainsHandle(handle)) { NavigationController* tab = tab_tracker_->GetResource(handle); tab->GoToIndex(navigation_index); *status = AUTOMATION_MSG_NAVIGATION_SUCCESS; } } void AutomationProvider::WaitForTabToBeRestored(int tab_handle, IPC::Message* reply_message) { if (tab_tracker_->ContainsHandle(tab_handle)) { NavigationController* tab = tab_tracker_->GetResource(tab_handle); restore_tracker_.reset( new NavigationControllerRestoredObserver(this, tab, reply_message)); } } void AutomationProvider::GetSecurityState(int handle, bool* success, SecurityStyle* security_style, int* ssl_cert_status, int* mixed_content_status) { if (tab_tracker_->ContainsHandle(handle)) { NavigationController* tab = tab_tracker_->GetResource(handle); NavigationEntry* entry = tab->GetActiveEntry(); *success = true; *security_style = entry->ssl().security_style(); *ssl_cert_status = entry->ssl().cert_status(); *mixed_content_status = entry->ssl().content_status(); } else { *success = false; *security_style = SECURITY_STYLE_UNKNOWN; *ssl_cert_status = 0; *mixed_content_status = 0; } } void AutomationProvider::GetPageType(int handle, bool* success, NavigationEntry::PageType* page_type) { if (tab_tracker_->ContainsHandle(handle)) { NavigationController* tab = tab_tracker_->GetResource(handle); NavigationEntry* entry = tab->GetActiveEntry(); *page_type = entry->page_type(); *success = true; // In order to return the proper result when an interstitial is shown and // no navigation entry were created for it we need to ask the TabContents. if (*page_type == NavigationEntry::NORMAL_PAGE && tab->tab_contents()->showing_interstitial_page()) *page_type = NavigationEntry::INTERSTITIAL_PAGE; } else { *success = false; *page_type = NavigationEntry::NORMAL_PAGE; } } void AutomationProvider::GetMetricEventDuration(const std::string& event_name, int* duration_ms) { *duration_ms = metric_event_duration_observer_->GetEventDurationMs( event_name); } void AutomationProvider::ActionOnSSLBlockingPage(int handle, bool proceed, IPC::Message* reply_message) { if (tab_tracker_->ContainsHandle(handle)) { NavigationController* tab = tab_tracker_->GetResource(handle); NavigationEntry* entry = tab->GetActiveEntry(); if (entry->page_type() == NavigationEntry::INTERSTITIAL_PAGE) { TabContents* tab_contents = tab->tab_contents(); InterstitialPage* ssl_blocking_page = InterstitialPage::GetInterstitialPage(tab_contents); if (ssl_blocking_page) { if (proceed) { AddNavigationStatusListener(tab, reply_message, 1); ssl_blocking_page->Proceed(); return; } ssl_blocking_page->DontProceed(); AutomationMsg_ActionOnSSLBlockingPage::WriteReplyParams( reply_message, AUTOMATION_MSG_NAVIGATION_SUCCESS); Send(reply_message); return; } } } // We failed. AutomationMsg_ActionOnSSLBlockingPage::WriteReplyParams( reply_message, AUTOMATION_MSG_NAVIGATION_ERROR); Send(reply_message); } void AutomationProvider::BringBrowserToFront(int browser_handle, bool* success) { if (browser_tracker_->ContainsHandle(browser_handle)) { Browser* browser = browser_tracker_->GetResource(browser_handle); browser->window()->Activate(); *success = true; } else { *success = false; } } void AutomationProvider::IsPageMenuCommandEnabled(int browser_handle, int message_num, bool* menu_item_enabled) { if (browser_tracker_->ContainsHandle(browser_handle)) { Browser* browser = browser_tracker_->GetResource(browser_handle); *menu_item_enabled = browser->command_updater()->IsCommandEnabled(message_num); } else { *menu_item_enabled = false; } } void AutomationProvider::PrintNow(int tab_handle, IPC::Message* reply_message) { #if defined(OS_WIN) NavigationController* tab = NULL; TabContents* tab_contents = GetTabContentsForHandle(tab_handle, &tab); if (tab_contents) { FindAndActivateTab(tab); notification_observer_list_.AddObserver( new DocumentPrintedNotificationObserver(this, reply_message)); if (tab_contents->PrintNow()) return; } AutomationMsg_PrintNow::WriteReplyParams(reply_message, false); Send(reply_message); #else // TODO(port): Remove once DocumentPrintedNotificationObserver is implemented. NOTIMPLEMENTED(); #endif // defined(OS_WIN) } void AutomationProvider::SavePage(int tab_handle, const FilePath& file_name, const FilePath& dir_path, int type, bool* success) { if (!tab_tracker_->ContainsHandle(tab_handle)) { *success = false; return; } NavigationController* nav = tab_tracker_->GetResource(tab_handle); Browser* browser = FindAndActivateTab(nav); DCHECK(browser); if (!browser->command_updater()->IsCommandEnabled(IDC_SAVE_PAGE)) { *success = false; return; } SavePackage::SavePackageType save_type = static_cast(type); DCHECK(save_type >= SavePackage::SAVE_AS_ONLY_HTML && save_type <= SavePackage::SAVE_AS_COMPLETE_HTML); nav->tab_contents()->SavePage(file_name, dir_path, save_type); *success = true; } #if !defined(OS_MACOSX) // TODO(port): Enable these. void AutomationProvider::GetAutocompleteEditText(int autocomplete_edit_handle, bool* success, std::wstring* text) { *success = false; if (autocomplete_edit_tracker_->ContainsHandle(autocomplete_edit_handle)) { *text = autocomplete_edit_tracker_->GetResource(autocomplete_edit_handle)-> GetText(); *success = true; } } void AutomationProvider::SetAutocompleteEditText(int autocomplete_edit_handle, const std::wstring& text, bool* success) { *success = false; if (autocomplete_edit_tracker_->ContainsHandle(autocomplete_edit_handle)) { autocomplete_edit_tracker_->GetResource(autocomplete_edit_handle)-> SetUserText(text); *success = true; } } void AutomationProvider::AutocompleteEditGetMatches( int autocomplete_edit_handle, bool* success, std::vector* matches) { *success = false; if (autocomplete_edit_tracker_->ContainsHandle(autocomplete_edit_handle)) { const AutocompleteResult& result = autocomplete_edit_tracker_-> GetResource(autocomplete_edit_handle)->model()->result(); for (AutocompleteResult::const_iterator i = result.begin(); i != result.end(); ++i) matches->push_back(AutocompleteMatchData(*i)); *success = true; } } void AutomationProvider::AutocompleteEditIsQueryInProgress( int autocomplete_edit_handle, bool* success, bool* query_in_progress) { *success = false; *query_in_progress = false; if (autocomplete_edit_tracker_->ContainsHandle(autocomplete_edit_handle)) { *query_in_progress = autocomplete_edit_tracker_-> GetResource(autocomplete_edit_handle)->model()->query_in_progress(); *success = true; } } void AutomationProvider::OnMessageFromExternalHost(int handle, const std::string& message, const std::string& origin, const std::string& target) { RenderViewHost* view_host = GetViewForTab(handle); if (!view_host) { return; } if (AutomationExtensionFunction::InterceptMessageFromExternalHost( view_host, message, origin, target)) { // Message was diverted. return; } if (ExtensionPortContainer::InterceptMessageFromExternalHost(message, origin, target, this, view_host, handle)) { // Message was diverted. return; } if (InterceptBrowserEventMessageFromExternalHost(message, origin, target)) { // Message was diverted. return; } view_host->ForwardMessageFromExternalHost(message, origin, target); } bool AutomationProvider::InterceptBrowserEventMessageFromExternalHost( const std::string& message, const std::string& origin, const std::string& target) { if (target != extension_automation_constants::kAutomationBrowserEventRequestTarget) return false; if (origin != extension_automation_constants::kAutomationOrigin) { LOG(WARNING) << "Wrong origin on automation browser event " << origin; return false; } // The message is a JSON-encoded array with two elements, both strings. The // first is the name of the event to dispatch. The second is a JSON-encoding // of the arguments specific to that event. scoped_ptr message_value(base::JSONReader::Read(message, false)); if (!message_value.get() || !message_value->IsType(Value::TYPE_LIST)) { LOG(WARNING) << "Invalid browser event specified through automation"; return false; } const ListValue* args = static_cast(message_value.get()); std::string event_name; if (!args->GetString(0, &event_name)) { LOG(WARNING) << "No browser event name specified through automation"; return false; } std::string json_args; if (!args->GetString(1, &json_args)) { LOG(WARNING) << "No browser event args specified through automation"; return false; } if (profile()->GetExtensionMessageService()) { profile()->GetExtensionMessageService()-> DispatchEventToRenderers(event_name.c_str(), json_args); } return true; } #endif // !defined(OS_MACOSX) TabContents* AutomationProvider::GetTabContentsForHandle( int handle, NavigationController** tab) { if (tab_tracker_->ContainsHandle(handle)) { NavigationController* nav_controller = tab_tracker_->GetResource(handle); if (tab) *tab = nav_controller; return nav_controller->tab_contents(); } return NULL; } TestingAutomationProvider::TestingAutomationProvider(Profile* profile) : AutomationProvider(profile) { BrowserList::AddObserver(this); registrar_.Add(this, NotificationType::SESSION_END, NotificationService::AllSources()); } TestingAutomationProvider::~TestingAutomationProvider() { BrowserList::RemoveObserver(this); } void TestingAutomationProvider::OnChannelError() { BrowserList::CloseAllBrowsersAndExit(); AutomationProvider::OnChannelError(); } void TestingAutomationProvider::OnBrowserRemoving(const Browser* browser) { // For backwards compatibility with the testing automation interface, we // want the automation provider (and hence the process) to go away when the // last browser goes away. if (BrowserList::size() == 1) { // If you change this, update Observer for NotificationType::SESSION_END // below. MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(this, &TestingAutomationProvider::OnRemoveProvider)); } } void TestingAutomationProvider::Observe(NotificationType type, const NotificationSource& source, const NotificationDetails& details) { DCHECK(type == NotificationType::SESSION_END); // OnBrowserRemoving does a ReleaseLater. When session end is received we exit // before the task runs resulting in this object not being deleted. This // Release balance out the Release scheduled by OnBrowserRemoving. Release(); } void TestingAutomationProvider::OnRemoveProvider() { AutomationProviderList::GetInstance()->RemoveProvider(this); } void AutomationProvider::GetInfoBarCount(int handle, int* count) { *count = -1; // -1 means error. if (tab_tracker_->ContainsHandle(handle)) { NavigationController* nav_controller = tab_tracker_->GetResource(handle); if (nav_controller) *count = nav_controller->tab_contents()->infobar_delegate_count(); } } void AutomationProvider::ClickInfoBarAccept(int handle, int info_bar_index, bool wait_for_navigation, IPC::Message* reply_message) { bool success = false; if (tab_tracker_->ContainsHandle(handle)) { NavigationController* nav_controller = tab_tracker_->GetResource(handle); if (nav_controller) { int count = nav_controller->tab_contents()->infobar_delegate_count(); if (info_bar_index >= 0 && info_bar_index < count) { if (wait_for_navigation) { AddNavigationStatusListener(nav_controller, reply_message, 1); } InfoBarDelegate* delegate = nav_controller->tab_contents()->GetInfoBarDelegateAt( info_bar_index); if (delegate->AsConfirmInfoBarDelegate()) delegate->AsConfirmInfoBarDelegate()->Accept(); success = true; } } } // This "!wait_for_navigation || !success condition" logic looks suspicious. // It will send a failure message when success is true but // |wait_for_navigation| is false. // TODO(phajdan.jr): investgate whether the reply param (currently // AUTOMATION_MSG_NAVIGATION_ERROR) should depend on success. if (!wait_for_navigation || !success) AutomationMsg_ClickInfoBarAccept::WriteReplyParams( reply_message, AUTOMATION_MSG_NAVIGATION_ERROR); } void AutomationProvider::GetLastNavigationTime(int handle, int64* last_navigation_time) { Time time = tab_tracker_->GetLastNavigationTime(handle); *last_navigation_time = time.ToInternalValue(); } void AutomationProvider::WaitForNavigation(int handle, int64 last_navigation_time, IPC::Message* reply_message) { NavigationController* controller = tab_tracker_->GetResource(handle); Time time = tab_tracker_->GetLastNavigationTime(handle); if (time.ToInternalValue() > last_navigation_time || !controller) { AutomationMsg_WaitForNavigation::WriteReplyParams(reply_message, controller == NULL ? AUTOMATION_MSG_NAVIGATION_ERROR : AUTOMATION_MSG_NAVIGATION_SUCCESS); Send(reply_message); return; } AddNavigationStatusListener(controller, reply_message, 1); } void AutomationProvider::SetIntPreference(int handle, const std::wstring& name, int value, bool* success) { *success = false; if (browser_tracker_->ContainsHandle(handle)) { Browser* browser = browser_tracker_->GetResource(handle); browser->profile()->GetPrefs()->SetInteger(name.c_str(), value); *success = true; } } void AutomationProvider::SetStringPreference(int handle, const std::wstring& name, const std::wstring& value, bool* success) { *success = false; if (browser_tracker_->ContainsHandle(handle)) { Browser* browser = browser_tracker_->GetResource(handle); browser->profile()->GetPrefs()->SetString(name.c_str(), value); *success = true; } } void AutomationProvider::GetBooleanPreference(int handle, const std::wstring& name, bool* success, bool* value) { *success = false; *value = false; if (browser_tracker_->ContainsHandle(handle)) { Browser* browser = browser_tracker_->GetResource(handle); *value = browser->profile()->GetPrefs()->GetBoolean(name.c_str()); *success = true; } } void AutomationProvider::SetBooleanPreference(int handle, const std::wstring& name, bool value, bool* success) { *success = false; if (browser_tracker_->ContainsHandle(handle)) { Browser* browser = browser_tracker_->GetResource(handle); browser->profile()->GetPrefs()->SetBoolean(name.c_str(), value); *success = true; } } // Gets the current used encoding name of the page in the specified tab. void AutomationProvider::GetPageCurrentEncoding( int tab_handle, std::string* current_encoding) { if (tab_tracker_->ContainsHandle(tab_handle)) { NavigationController* nav = tab_tracker_->GetResource(tab_handle); Browser* browser = FindAndActivateTab(nav); DCHECK(browser); if (browser->command_updater()->IsCommandEnabled(IDC_ENCODING_MENU)) *current_encoding = nav->tab_contents()->encoding(); } } // Gets the current used encoding name of the page in the specified tab. void AutomationProvider::OverrideEncoding(int tab_handle, const std::string& encoding_name, bool* success) { *success = false; #if defined(OS_WIN) if (tab_tracker_->ContainsHandle(tab_handle)) { NavigationController* nav = tab_tracker_->GetResource(tab_handle); Browser* browser = FindAndActivateTab(nav); DCHECK(browser); if (browser->command_updater()->IsCommandEnabled(IDC_ENCODING_MENU)) { int selected_encoding_id = CharacterEncoding::GetCommandIdByCanonicalEncodingName(encoding_name); if (selected_encoding_id) { browser->OverrideEncoding(selected_encoding_id); *success = true; } } } #else // TODO(port): Enable when encoding-related parts of Browser are ported. NOTIMPLEMENTED(); #endif } void AutomationProvider::SavePackageShouldPromptUser(bool should_prompt) { SavePackage::SetShouldPromptUser(should_prompt); } void AutomationProvider::GetWindowTitle(int handle, string16* text) { gfx::NativeWindow window = window_tracker_->GetResource(handle); text->assign(platform_util::GetWindowTitle(window)); } void AutomationProvider::GetBlockedPopupCount(int handle, int* count) { *count = -1; // -1 is the error code if (tab_tracker_->ContainsHandle(handle)) { NavigationController* nav_controller = tab_tracker_->GetResource(handle); TabContents* tab_contents = nav_controller->tab_contents(); if (tab_contents) { BlockedPopupContainer* container = tab_contents->blocked_popup_container(); if (container) { *count = static_cast(container->GetBlockedPopupCount()); } else { // If we don't have a container, we don't have any blocked popups to // contain! *count = 0; } } } } void AutomationProvider::SelectAll(int tab_handle) { RenderViewHost* view = GetViewForTab(tab_handle); if (!view) { NOTREACHED(); return; } view->SelectAll(); } void AutomationProvider::Cut(int tab_handle) { RenderViewHost* view = GetViewForTab(tab_handle); if (!view) { NOTREACHED(); return; } view->Cut(); } void AutomationProvider::Copy(int tab_handle) { RenderViewHost* view = GetViewForTab(tab_handle); if (!view) { NOTREACHED(); return; } view->Copy(); } void AutomationProvider::Paste(int tab_handle) { RenderViewHost* view = GetViewForTab(tab_handle); if (!view) { NOTREACHED(); return; } view->Paste(); } void AutomationProvider::ReloadAsync(int tab_handle) { if (tab_tracker_->ContainsHandle(tab_handle)) { NavigationController* tab = tab_tracker_->GetResource(tab_handle); if (!tab) { NOTREACHED(); return; } tab->Reload(false); } } void AutomationProvider::StopAsync(int tab_handle) { RenderViewHost* view = GetViewForTab(tab_handle); if (!view) { // We tolerate StopAsync being called even before a view has been created. // So just log a warning instead of a NOTREACHED(). DLOG(WARNING) << "StopAsync: no view for handle " << tab_handle; return; } view->Stop(); } void AutomationProvider::OnSetPageFontSize(int tab_handle, int font_size) { AutomationPageFontSize automation_font_size = static_cast(font_size); if (automation_font_size < SMALLEST_FONT || automation_font_size > LARGEST_FONT) { DLOG(ERROR) << "Invalid font size specified : " << font_size; return; } if (tab_tracker_->ContainsHandle(tab_handle)) { NavigationController* tab = tab_tracker_->GetResource(tab_handle); DCHECK(tab != NULL); if (tab && tab->tab_contents()) { DCHECK(tab->tab_contents()->profile() != NULL); tab->tab_contents()->profile()->GetPrefs()->SetInteger( prefs::kWebKitDefaultFontSize, font_size); } } } void AutomationProvider::WaitForBrowserWindowCountToBecome( int target_count, IPC::Message* reply_message) { if (static_cast(BrowserList::size()) == target_count) { AutomationMsg_WaitForBrowserWindowCountToBecome::WriteReplyParams( reply_message, true); Send(reply_message); return; } // Set up an observer (it will delete itself). new BrowserCountChangeNotificationObserver(target_count, this, reply_message); } void AutomationProvider::WaitForAppModalDialogToBeShown( IPC::Message* reply_message) { if (Singleton()->HasActiveDialog()) { AutomationMsg_WaitForAppModalDialogToBeShown::WriteReplyParams( reply_message, true); Send(reply_message); return; } // Set up an observer (it will delete itself). new AppModalDialogShownObserver(this, reply_message); } void AutomationProvider::GoBackBlockUntilNavigationsComplete( int handle, int number_of_navigations, IPC::Message* reply_message) { if (tab_tracker_->ContainsHandle(handle)) { NavigationController* tab = tab_tracker_->GetResource(handle); Browser* browser = FindAndActivateTab(tab); if (browser && browser->command_updater()->IsCommandEnabled(IDC_BACK)) { AddNavigationStatusListener(tab, reply_message, number_of_navigations); browser->GoBack(CURRENT_TAB); return; } } AutomationMsg_GoBackBlockUntilNavigationsComplete::WriteReplyParams( reply_message, AUTOMATION_MSG_NAVIGATION_ERROR); Send(reply_message); } void AutomationProvider::GoForwardBlockUntilNavigationsComplete( int handle, int number_of_navigations, IPC::Message* reply_message) { if (tab_tracker_->ContainsHandle(handle)) { NavigationController* tab = tab_tracker_->GetResource(handle); Browser* browser = FindAndActivateTab(tab); if (browser && browser->command_updater()->IsCommandEnabled(IDC_FORWARD)) { AddNavigationStatusListener(tab, reply_message, number_of_navigations); browser->GoForward(CURRENT_TAB); return; } } AutomationMsg_GoForwardBlockUntilNavigationsComplete::WriteReplyParams( reply_message, AUTOMATION_MSG_NAVIGATION_ERROR); Send(reply_message); } RenderViewHost* AutomationProvider::GetViewForTab(int tab_handle) { if (tab_tracker_->ContainsHandle(tab_handle)) { NavigationController* tab = tab_tracker_->GetResource(tab_handle); if (!tab) { NOTREACHED(); return NULL; } TabContents* tab_contents = tab->tab_contents(); if (!tab_contents) { NOTREACHED(); return NULL; } RenderViewHost* view_host = tab_contents->render_view_host(); return view_host; } return NULL; } void AutomationProvider::GetBrowserForWindow(int window_handle, bool* success, int* browser_handle) { *success = false; *browser_handle = 0; gfx::NativeWindow window = window_tracker_->GetResource(window_handle); if (!window) return; BrowserList::const_iterator iter = BrowserList::begin(); for (;iter != BrowserList::end(); ++iter) { gfx::NativeWindow this_window = (*iter)->window()->GetNativeHandle(); if (window == this_window) { // Add() returns the existing handle for the resource if any. *browser_handle = browser_tracker_->Add(*iter); *success = true; return; } } } void AutomationProvider::InstallExtension(const FilePath& crx_path, IPC::Message* reply_message) { ExtensionsService* service = profile_->GetExtensionsService(); if (service) { // The observer will delete itself when done. new ExtensionNotificationObserver(this, AutomationMsg_InstallExtension::ID, reply_message); const FilePath& install_dir = service->install_directory(); CrxInstaller::Start(crx_path, install_dir, Extension::INTERNAL, "", // no expected id false, // please do not delete crx file true, // privilege increase allowed service, NULL); // silent isntall, no UI } else { AutomationMsg_InstallExtension::WriteReplyParams( reply_message, AUTOMATION_MSG_EXTENSION_INSTALL_FAILED); Send(reply_message); } } void AutomationProvider::LoadExpandedExtension( const FilePath& extension_dir, IPC::Message* reply_message) { if (profile_->GetExtensionsService()) { // The observer will delete itself when done. new ExtensionNotificationObserver(this, AutomationMsg_LoadExpandedExtension::ID, reply_message); profile_->GetExtensionsService()->LoadExtension(extension_dir); } else { AutomationMsg_LoadExpandedExtension::WriteReplyParams( reply_message, AUTOMATION_MSG_EXTENSION_INSTALL_FAILED); Send(reply_message); } } void AutomationProvider::SaveAsAsync(int tab_handle) { NavigationController* tab = NULL; TabContents* tab_contents = GetTabContentsForHandle(tab_handle, &tab); if (tab_contents) tab_contents->OnSavePage(); }