GTTF: Continue moving testing automation bits to TestingAutomationProvider

chrome/browser/automation/automation_provider.h

 // Copyright (c) 2010 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.
 
 // 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.
 
@@ skipping 35 matching lines @@
 class AutomationExtensionTracker;
 class AutomationResourceMessageFilter;
 class AutomationTabTracker;
 class AutomationWindowTracker;
 class CreditCard;
 class DictionaryValue;
 class Extension;
 class ExtensionPortContainer;
 class ExtensionTestResultNotificationObserver;
 class ExternalTabContainer;
+class InitialLoadObserver;
 class LoginHandler;
 class MetricEventDurationObserver;
-class InitialLoadObserver;
+class NavigationController;
 class NavigationControllerRestoredObserver;
+class Profile;
 struct AutocompleteMatchData;
 
 namespace gfx {
 class Point;
 }
 
 class AutomationProvider : public base::RefCounted<AutomationProvider>,
                            public IPC::Channel::Listener,
                            public IPC::Message::Sender {
  public:
@@ skipping 89 matching lines @@
   virtual ~AutomationProvider();
 
   // 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);
 
   scoped_ptr<AutomationBrowserTracker> browser_tracker_;
   scoped_ptr<AutomationTabTracker> tab_tracker_;
 
+  typedef std::map<NavigationController*, LoginHandler*> LoginHandlerMap;
+  LoginHandlerMap login_handler_map_;
+
+  Profile* profile_;
+
+  // A pointer to reply message used when we do asynchronous processing in the
+  // message handler.
+  // TODO(phajdan.jr): Remove |reply_message_|, it is error-prone.
+  IPC::Message* reply_message_;
+
+  // Consumer for asynchronous history queries.
+  CancelableRequestConsumer consumer_;
+
  private:
   // IPC Message callbacks.
-  void GetBrowserWindowCount(int* window_count);
   void GetBrowserLocale(string16* locale);
-  void GetNormalBrowserWindowCount(int* window_count);
   void GetShowingAppModalDialog(bool* showing_dialog, int* dialog_button);
   void ClickAppModalDialogButton(int button, bool* success);
   void ShutdownSessionService(int handle, bool* result);
   // Be aware that the browser window returned might be of non TYPE_NORMAL
   // or in incognito mode.
   void GetBrowserWindow(int index, int* handle);
   void FindNormalBrowserWindow(int* handle);
   void GetLastActiveBrowserWindow(int* handle);
   void GetActiveWindow(int* handle);
   void ExecuteBrowserCommandAsync(int handle, int command, bool* success);
@@ skipping 30 matching lines @@
   void GetTab(int win_handle, int tab_index, int* tab_handle);
 #if defined(OS_WIN)
   // TODO(port): Replace HWND.
   void GetTabHWND(int handle, HWND* tab_hwnd);
 #endif  // defined(OS_WIN)
   void GetTabProcessID(int handle, int* process_id);
   void GetTabTitle(int handle, int* title_string_size, std::wstring* title);
   void GetTabIndex(int handle, int* tabstrip_index);
   void GetTabURL(int handle, bool* success, GURL* url);
   void HandleUnused(const IPC::Message& message, int handle);
-  void NavigationAsync(int handle, const GURL& url, bool* status);
-  void NavigationAsyncWithDisposition(int handle,
-                                      const GURL& url,
-                                      WindowOpenDisposition disposition,
-                                      bool* status);
-  void GoBack(int handle, IPC::Message* reply_message);
-  void GoForward(int handle, IPC::Message* reply_message);
-  void Reload(int handle, IPC::Message* reply_message);
-  void SetAuth(int tab_handle, const std::wstring& username,
-               const std::wstring& password, IPC::Message* reply_message);
-  void CancelAuth(int tab_handle, IPC::Message* reply_message);
-  void NeedsAuth(int tab_handle, bool* needs_auth);
-  void GetRedirectsFrom(int tab_handle,
-                        const GURL& source_url,
-                        IPC::Message* reply_message);
   void ExecuteJavascript(int handle,
                          const std::wstring& frame_xpath,
                          const std::wstring& script,
                          IPC::Message* reply_message);
   void GetShelfVisibility(int handle, bool* visible);
   void SetShelfVisibility(int handle, bool visible);
   void SetFilteredInet(const IPC::Message& message, bool enabled);
   void GetFilteredInetHitCount(int* hit_count);
   void SetProxyConfig(const std::string& new_proxy_config);
   void IsFullscreen(int handle, bool* is_fullscreen);
@@ skipping 564 matching lines @@
   TabContents* GetTabContentsForHandle(int handle, NavigationController** tab);
 
 #if defined(OS_CHROMEOS)
   // Logs in through the Chrome OS Login Wizard with given |username| and
   // password.  Returns true via |reply_message| on success.
   void LoginWithUserAndPass(const std::string& username,
                             const std::string& password,
                             IPC::Message* reply_message);
 #endif
 
-  // Callback for history redirect queries.
-  virtual void OnRedirectQueryComplete(
-      HistoryService::Handle request_handle,
-      GURL from_url,
-      bool success,
-      history::RedirectList* redirects);
-
   // Returns the associated view for the tab handle passed in.
   // Returns NULL on failure.
   RenderViewHost* GetViewForTab(int tab_handle);
 
   // Returns the extension for the given handle. Returns NULL if there is
   // no extension for the handle.
   Extension* GetExtension(int extension_handle);
 
   // Returns the extension for the given handle, if the handle is valid and
   // the associated extension is enabled. Returns NULL otherwise.
@@ skipping 70 matching lines @@
 
   void OnRunUnloadHandlers(int handle, gfx::NativeWindow notification_window,
                            int notification_message);
 
   void OnSetZoomLevel(int handle, int zoom_level);
 
   ExternalTabContainer* GetExternalTabForHandle(int handle);
 #endif  // defined(OS_WIN)
 
   typedef ObserverList<NotificationObserver> NotificationObserverList;
-  typedef std::map<NavigationController*, LoginHandler*> LoginHandlerMap;
   typedef std::map<int, ExtensionPortContainer*> PortContainerMap;
 
   scoped_ptr<IPC::ChannelProxy> channel_;
   scoped_ptr<InitialLoadObserver> 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<ExtensionTestResultNotificationObserver>
       extension_test_result_observer_;
   scoped_ptr<MetricEventDurationObserver> metric_event_duration_observer_;
   scoped_ptr<AutomationExtensionTracker> extension_tracker_;
   scoped_ptr<AutomationWindowTracker> window_tracker_;
   scoped_ptr<AutomationAutocompleteEditTracker> autocomplete_edit_tracker_;
   scoped_ptr<NavigationControllerRestoredObserver> restore_tracker_;
-  LoginHandlerMap login_handler_map_;
   PortContainerMap port_containers_;
   NotificationObserverList notification_observer_list_;
   scoped_refptr<AutomationResourceMessageFilter>
       automation_resource_message_filter_;
 
-  // 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.
-  HistoryService::Handle redirect_query_;
-
-  // Consumer for asynchronous history queries.
-  CancelableRequestConsumer consumer_;
-
-  Profile* profile_;
-
-  IPC::Message* reply_message_;
-
   // Keep track of whether a popup menu has been opened since the last time
   // that StartTrackingPopupMenus has been called.
   bool popup_menu_opened_;
 
   // A temporary object that receives a notification when a popup menu opens.
   PopupMenuWaiter* popup_menu_waiter_;
 
   DISALLOW_COPY_AND_ASSIGN(AutomationProvider);
 };
 
 #endif  // CHROME_BROWSER_AUTOMATION_AUTOMATION_PROVIDER_H_