Support maximize window command.

chrome/browser/automation/automation_provider_observers.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CHROME_BROWSER_AUTOMATION_AUTOMATION_PROVIDER_OBSERVERS_H_
 #define CHROME_BROWSER_AUTOMATION_AUTOMATION_PROVIDER_OBSERVERS_H_
 #pragma once
 
 #include <deque>
 #include <map>
@@ skipping 88 matching lines @@
 
 namespace policy {
 class BrowserPolicyConnector;
 }
 
 class InitialLoadObserver : public content::NotificationObserver {
  public:
   InitialLoadObserver(size_t tab_count, AutomationProvider* automation);
   virtual ~InitialLoadObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
   // Caller owns the return value and is responsible for deleting it.
   // Example return value:
   // {'tabs': [{'start_time_ms': 1, 'stop_time_ms': 2.5},
   //           {'start_time_ms': 0.5, 'stop_time_ms': 3}]}
   // stop_time_ms values may be null if WaitForInitialLoads has not finished.
   // Only includes entries for the |tab_count| tabs we are monitoring.
   // There is no defined ordering of the return value.
   base::DictionaryValue* GetTimingInformation() const;
 
@@ skipping 32 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(NetworkManagerInitObserver);
 };
 
 // Observes when the ChromeOS login WebUI becomes ready (by showing the login
 // form, account picker, a network error or the OOBE wizard, depending on Chrome
 // flags and state).
 class OOBEWebuiReadyObserver : public content::NotificationObserver {
  public:
   explicit OOBEWebuiReadyObserver(AutomationProvider* automation);
+
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   void OOBEWebuiReady();
 
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
 
   DISALLOW_COPY_AND_ASSIGN(OOBEWebuiReadyObserver);
 };
 #endif  // defined(OS_CHROMEOS)
 
 // Watches for NewTabUI page loads for performance timing purposes.
 class NewTabUILoadObserver : public content::NotificationObserver {
  public:
   explicit NewTabUILoadObserver(AutomationProvider* automation,
                                 Profile* profile);
   virtual ~NewTabUILoadObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
 
   DISALLOW_COPY_AND_ASSIGN(NewTabUILoadObserver);
 };
 
 class NavigationControllerRestoredObserver
     : public content::NotificationObserver {
  public:
   NavigationControllerRestoredObserver(
       AutomationProvider* automation,
       content::NavigationController* controller,
       IPC::Message* reply_message);
   virtual ~NavigationControllerRestoredObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   bool FinishedRestoring();
   void SendDone();
 
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   content::NavigationController* controller_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(NavigationControllerRestoredObserver);
 };
 
 class NavigationNotificationObserver : public content::NotificationObserver {
  public:
   NavigationNotificationObserver(content::NavigationController* controller,
                                  AutomationProvider* automation,
                                  IPC::Message* reply_message,
                                  int number_of_navigations,
                                  bool include_current_navigation,
                                  bool use_json_interface);
   virtual ~NavigationNotificationObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
   void ConditionMet(AutomationMsg_NavigationResponseValues navigation_result);
 
  private:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   content::NavigationController* controller_;
   int navigations_remaining_;
   bool navigation_started_;
   bool use_json_interface_;
 
   DISALLOW_COPY_AND_ASSIGN(NavigationNotificationObserver);
 };
 
 class TabStripNotificationObserver : public content::NotificationObserver {
  public:
   TabStripNotificationObserver(int notification,
                                AutomationProvider* automation);
   virtual ~TabStripNotificationObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
   virtual void ObserveTab(content::NavigationController* controller) = 0;
 
  protected:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   int notification_;
 };
 
 class TabAppendedNotificationObserver : public TabStripNotificationObserver {
@@ skipping 64 matching lines @@
 };
 
 // Observes when an extension has been uninstalled.
 class ExtensionUninstallObserver : public content::NotificationObserver {
  public:
   ExtensionUninstallObserver(AutomationProvider* automation,
                              IPC::Message* reply_message,
                              const std::string& id);
   virtual ~ExtensionUninstallObserver();
 
-  // Implementation of content::NotificationObserver.
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   std::string id_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionUninstallObserver);
 };
 
 // Observes when an extension has finished loading and is ready for use. Also
 // checks for possible install errors.
 class ExtensionReadyNotificationObserver
     : public content::NotificationObserver {
  public:
   // Creates an observer that replies using the JSON automation interface.
   ExtensionReadyNotificationObserver(ExtensionProcessManager* manager,
                                      ExtensionService* service,
                                      AutomationProvider* automation,
                                      IPC::Message* reply_message);
   virtual ~ExtensionReadyNotificationObserver();
 
-  // Implementation of NotificationObserver.
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   void Init();
 
   content::NotificationRegistrar registrar_;
   ExtensionProcessManager* manager_;
   ExtensionService* service_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   const extensions::Extension* extension_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionReadyNotificationObserver);
 };
 
 class ExtensionUnloadNotificationObserver
     : public content::NotificationObserver {
  public:
   ExtensionUnloadNotificationObserver();
   virtual ~ExtensionUnloadNotificationObserver();
 
-  // Implementation of NotificationObserver.
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
   bool did_receive_unload_notification() {
     return did_receive_unload_notification_;
   }
 
  private:
   content::NotificationRegistrar registrar_;
   bool did_receive_unload_notification_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionUnloadNotificationObserver);
 };
 
 // Observes when the extensions have been fully updated.  The ExtensionUpdater
 // service provides notifications for each extension that gets updated, but
 // it does not wait for the updated extensions to be installed or loaded.  This
 // observer waits until all updated extensions have actually been loaded.
 class ExtensionsUpdatedObserver : public content::NotificationObserver {
  public:
   ExtensionsUpdatedObserver(ExtensionProcessManager* manager,
                             AutomationProvider* automation,
                             IPC::Message* reply_message);
   virtual ~ExtensionsUpdatedObserver();
 
-  // Implementation of NotificationObserver.
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::NotificationRegistrar registrar_;
   ExtensionProcessManager* manager_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   std::set<std::string> in_progress_updates_;
   bool updater_finished_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionsUpdatedObserver);
 };
 
 // Observes when a new browser has been opened and a tab within it has stopped
 // loading.
 class BrowserOpenedNotificationObserver : public content::NotificationObserver {
  public:
   BrowserOpenedNotificationObserver(AutomationProvider* automation,
                                     IPC::Message* reply_message);
   virtual ~BrowserOpenedNotificationObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
   void set_for_browser_command(bool for_browser_command);
 
  private:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   int new_window_id_;
   bool for_browser_command_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserOpenedNotificationObserver);
 };
 
 class BrowserClosedNotificationObserver : public content::NotificationObserver {
  public:
   BrowserClosedNotificationObserver(Browser* browser,
                                     AutomationProvider* automation,
                                     IPC::Message* reply_message);
   virtual ~BrowserClosedNotificationObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
   void set_for_browser_command(bool for_browser_command);
 
  private:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   bool for_browser_command_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserClosedNotificationObserver);
 };
 
 class BrowserCountChangeNotificationObserver
     : public content::NotificationObserver {
  public:
   BrowserCountChangeNotificationObserver(int target_count,
                                          AutomationProvider* automation,
                                          IPC::Message* reply_message);
   virtual ~BrowserCountChangeNotificationObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   int target_count_;
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserCountChangeNotificationObserver);
 };
 
 class ExecuteBrowserCommandObserver : public content::NotificationObserver {
  public:
   virtual ~ExecuteBrowserCommandObserver();
 
   static bool CreateAndRegisterObserver(AutomationProvider* automation,
                                         Browser* browser,
                                         int command,
                                         IPC::Message* reply_message);
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   ExecuteBrowserCommandObserver(AutomationProvider* automation,
                                 IPC::Message* reply_message);
 
   bool Register(int command);
 
   bool Getint(int command, int* type);
 
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   int notification_type_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(ExecuteBrowserCommandObserver);
 };
 
 class FindInPageNotificationObserver : public content::NotificationObserver {
  public:
   FindInPageNotificationObserver(AutomationProvider* automation,
                                  content::WebContents* parent_tab,
                                  bool reply_with_json,
                                  IPC::Message* reply_message);
   virtual ~FindInPageNotificationObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
   // The Find mechanism is over asynchronous IPC, so a search is kicked off and
   // we wait for notification to find out what the results are. As the user is
   // typing, new search requests can be issued and the Request ID helps us make
   // sense of whether this is the current request or an old one. The unit tests,
   // however, which uses this constant issues only one search at a time, so we
   // don't need a rolling id to identify each search. But, we still need to
   // specify one, so we just use a fixed one - its value does not matter.
   static const int kFindInPageRequestId;
 
  private:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   // We will at some point (before final update) be notified of the ordinal and
   // we need to preserve it so we can send it later.
   int active_match_ordinal_;
   // Send reply using json automation interface.
   bool reply_with_json_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(FindInPageNotificationObserver);
 };
 
 class DomOperationObserver : public content::NotificationObserver {
  public:
   explicit DomOperationObserver(int automation_id);
   virtual ~DomOperationObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   virtual void OnDomOperationCompleted(const std::string& json) = 0;
   virtual void OnModalDialogShown() = 0;
   virtual void OnJavascriptBlocked() = 0;
 
  private:
   int automation_id_;
@@ skipping 25 matching lines @@
 
 // Collects METRIC_EVENT_DURATION notifications and keep track of the times.
 class MetricEventDurationObserver : public content::NotificationObserver {
  public:
   MetricEventDurationObserver();
   virtual ~MetricEventDurationObserver();
 
   // Get the duration of an event.  Returns -1 if we haven't seen the event.
   int GetEventDurationMs(const std::string& event_name);
 
-  // NotificationObserver interface.
-  virtual void Observe(int type, const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+  // Overridden from content::NotificationObserver:
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::NotificationRegistrar registrar_;
 
   typedef std::map<std::string, int> EventDurationMap;
   EventDurationMap durations_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricEventDurationObserver);
 };
 
 class PageTranslatedObserver : public content::NotificationObserver {
  public:
   PageTranslatedObserver(AutomationProvider* automation,
                          IPC::Message* reply_message,
                          content::WebContents* web_contents);
   virtual ~PageTranslatedObserver();
 
-  // content::NotificationObserver interface.
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(PageTranslatedObserver);
 };
 
 class TabLanguageDeterminedObserver : public content::NotificationObserver {
  public:
   TabLanguageDeterminedObserver(AutomationProvider* automation,
                                 IPC::Message* reply_message,
                                 content::WebContents* web_contents,
                                 TranslateInfoBarDelegate* translate_bar);
   virtual ~TabLanguageDeterminedObserver();
 
-  // content::NotificationObserver interface.
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   content::WebContents* web_contents_;
   TranslateInfoBarDelegate* translate_bar_;
 
   DISALLOW_COPY_AND_ASSIGN(TabLanguageDeterminedObserver);
 };
 
 class InfoBarCountObserver : public content::NotificationObserver {
  public:
   InfoBarCountObserver(AutomationProvider* automation,
                        IPC::Message* reply_message,
                        TabContents* tab_contents,
                        size_t target_count);
   virtual ~InfoBarCountObserver();
 
-  // content::NotificationObserver interface.
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   // Checks whether the infobar count matches our target, and if so
   // sends the reply message and deletes itself.
   void CheckCount();
 
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   TabContents* tab_contents_;
@@ skipping 69 matching lines @@
 // whether authentication succeeded to the automation provider.
 class ScreenLockUnlockObserver : public content::NotificationObserver {
  public:
   // Set lock_screen to true to observe lock screen events,
   // false for unlock screen events.
   ScreenLockUnlockObserver(AutomationProvider* automation,
                            IPC::Message* reply_message,
                            bool lock_screen);
   virtual ~ScreenLockUnlockObserver();
 
-  // content::NotificationObserver interface.
-  virtual void Observe(int type, const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+  // Overridden from content::NotificationObserver:
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE;
 
  protected:
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
  private:
   content::NotificationRegistrar registrar_;
   bool lock_screen_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenLockUnlockObserver);
@@ skipping 429 matching lines @@
       public content::NotificationObserver {
  public:
   PasswordStoreLoginsChangedObserver(AutomationProvider* automation,
                                      IPC::Message* reply_message,
                                      PasswordStoreChange::Type expected_type,
                                      const std::string& result_key);
 
   // Schedules a task on the DB thread to register the appropriate observers.
   virtual void Init();
 
-  // content::NotificationObserver interface.
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   friend struct content::BrowserThread::DeleteOnThread<
       content::BrowserThread::UI>;
   ~PasswordStoreLoginsChangedObserver();
   friend class base::DeleteHelper<PasswordStoreLoginsChangedObserver>;
 
   // Registers the appropriate observers.  Called on the DB thread.
   void RegisterObserversTask();
 
@@ skipping 35 matching lines @@
 
 // Allows automation provider to wait until page load after selecting an item
 // in the omnibox popup.
 class OmniboxAcceptNotificationObserver : public content::NotificationObserver {
  public:
    OmniboxAcceptNotificationObserver(content::NavigationController* controller,
                                      AutomationProvider* automation,
                                      IPC::Message* reply_message);
   virtual ~OmniboxAcceptNotificationObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   content::NavigationController* controller_;
 
   DISALLOW_COPY_AND_ASSIGN(OmniboxAcceptNotificationObserver);
 };
 
 // Allows the automation provider to wait for a save package notification.
 class SavePackageNotificationObserver : public content::NotificationObserver {
  public:
   SavePackageNotificationObserver(content::DownloadManager* download_manager,
                                   AutomationProvider* automation,
                                   IPC::Message* reply_message);
   virtual ~SavePackageNotificationObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(SavePackageNotificationObserver);
 };
 
 // This class manages taking a snapshot of a page.
 class PageSnapshotTaker : public TabEventObserver,
                           public content::NotificationObserver {
  public:
   PageSnapshotTaker(AutomationProvider* automation,
                     IPC::Message* reply_message,
                     TabContents* tab_contents,
                     const FilePath& path);
   virtual ~PageSnapshotTaker();
 
   // Start the process of taking a snapshot of the entire page.
   void Start();
 
  private:
-  // TabEventObserver overrides.
+  // Overridden from TabEventObserver:
   virtual void OnSnapshotEntirePageACK(
       bool success,
       const std::vector<unsigned char>& png_data,
       const std::string& error_msg) OVERRIDE;
-  // NotificationObserver overrides.
+
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
   // Helper method to send a response back to the client. Deletes this.
   void SendMessage(bool success, const std::string& error_msg);
 
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   TabContents* tab_contents_;
   FilePath image_path_;
   content::NotificationRegistrar registrar_;
 
@@ skipping 19 matching lines @@
                                 const ErrorCallback& error_callback);
   virtual ~AutomationMouseEventProcessor();
 
  private:
   // IPC message handlers.
   virtual void OnWillProcessMouseEventAt(const gfx::Point& point);
   virtual void OnProcessMouseEventACK(
       bool success,
       const std::string& error_msg);
 
-  // RenderViewHostObserver overrides.
+  // Overriden from RenderViewHostObserver.
   virtual void RenderViewHostDestroyed(content::RenderViewHost* host) OVERRIDE;
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
 
-  // NotificationObserver overrides.
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // Helper method to invoke the appropriate callback. Uses the given error
   // only if the operation failed. Deletes this.
   void InvokeCallback(const automation::Error& error);
 
   content::NotificationRegistrar registrar_;
   CompletionCallback completion_callback_;
   ErrorCallback error_callback_;
   bool has_point_;
   gfx::Point point_;
 
   DISALLOW_COPY_AND_ASSIGN(AutomationMouseEventProcessor);
 };
 
 class NTPInfoObserver : public content::NotificationObserver {
  public:
   NTPInfoObserver(AutomationProvider* automation,
                   IPC::Message* reply_message,
                   CancelableRequestConsumer* consumer);
   virtual ~NTPInfoObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   void OnTopSitesLoaded();
   void OnTopSitesReceived(const history::MostVisitedURLList& visited_list);
 
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   CancelableRequestConsumer* consumer_;
   CancelableRequestProvider::Handle request_;
   scoped_ptr<base::DictionaryValue> ntp_info_;
   history::TopSites* top_sites_;
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(NTPInfoObserver);
 };
 
 // Observes when an app has been launched, as indicated by a notification that
 // a content load in some tab has stopped.
 class AppLaunchObserver : public content::NotificationObserver {
  public:
   AppLaunchObserver(content::NavigationController* controller,
                     AutomationProvider* automation,
                     IPC::Message* reply_message,
                     extension_misc::LaunchContainer launch_container);
   virtual ~AppLaunchObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::NavigationController* controller_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   content::NotificationRegistrar registrar_;
   extension_misc::LaunchContainer launch_container_;
   int new_window_id_;
 
   DISALLOW_COPY_AND_ASSIGN(AppLaunchObserver);
 };
 
 // Observes when Autofill information is displayed in the renderer.  This can
 // happen in two different ways: (1) a popup containing Autofill suggestions
 // has been shown in the renderer; (2) a webpage form is filled or previewed
 // with Autofill suggestions.  A constructor argument specifies the appropriate
 // notification to wait for.
 class AutofillDisplayedObserver : public content::NotificationObserver {
  public:
   AutofillDisplayedObserver(int notification,
                             content::RenderViewHost* render_view_host,
                             AutomationProvider* automation,
                             IPC::Message* reply_message);
   virtual ~AutofillDisplayedObserver();
 
-  // content::NotificationObserver interface.
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   int notification_;
   content::RenderViewHost* render_view_host_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(AutofillDisplayedObserver);
 };
 
 // Observes when a specified number of autofill profiles and credit cards have
 // been changed in the WebDataService.  The notifications are sent on the DB
 // thread, the thread that interacts with the database.
 class AutofillChangedObserver
     : public base::RefCountedThreadSafe<
           AutofillChangedObserver,
           content::BrowserThread::DeleteOnUIThread>,
       public content::NotificationObserver {
  public:
   AutofillChangedObserver(AutomationProvider* automation,
                           IPC::Message* reply_message,
                           int num_profiles,
                           int num_credit_cards);
 
   // Schedules a task on the DB thread to register the appropriate observers.
   virtual void Init();
 
-  // content::NotificationObserver interface.
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   friend struct content::BrowserThread::DeleteOnThread<
       content::BrowserThread::UI>;
   ~AutofillChangedObserver();
   friend class base::DeleteHelper<AutofillChangedObserver>;
 
   // Registers the appropriate observers.  Called on the DB thread.
   void RegisterObserversTask();
 
@@ skipping 24 matching lines @@
  public:
   AutofillFormSubmittedObserver(AutomationProvider* automation,
                                 IPC::Message* reply_message,
                                 PersonalDataManager* pdm);
   virtual ~AutofillFormSubmittedObserver();
 
   // PersonalDataManagerObserver interface.
   virtual void OnPersonalDataChanged() OVERRIDE;
   virtual void OnInsufficientFormData() OVERRIDE;
 
-  // content::NotificationObserver interface.
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   PersonalDataManager* pdm_;
   InfoBarTabHelper* infobar_helper_;
 };
 
 // Allows the automation provider to wait until all the notification
 // processes are ready.
 class GetAllNotificationsObserver : public content::NotificationObserver {
  public:
   GetAllNotificationsObserver(AutomationProvider* automation,
                               IPC::Message* reply_message);
   virtual ~GetAllNotificationsObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   // Sends a message via the |AutomationProvider|. |automation_| must be valid.
   // Deletes itself after the message is sent.
   void SendMessage();
   // Returns a new dictionary describing the given notification.
   base::DictionaryValue* NotificationToJson(const Notification* note);
 
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(GetAllNotificationsObserver);
 };
 
 // Allows the automation provider to wait for a new notification balloon
 // to appear and be ready.
 class NewNotificationBalloonObserver : public content::NotificationObserver {
  public:
   NewNotificationBalloonObserver(AutomationProvider* provider,
                                  IPC::Message* reply_message);
   virtual ~NewNotificationBalloonObserver();
+
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(NewNotificationBalloonObserver);
 };
 
 // Allows the automation provider to wait for a given number of
 // notification balloons.
 class OnNotificationBalloonCountObserver
     : public content::NotificationObserver {
  public:
   OnNotificationBalloonCountObserver(AutomationProvider* provider,
                                      IPC::Message* reply_message,
                                      int count);
   virtual ~OnNotificationBalloonCountObserver();
 
   // Sends an automation reply message if |automation_| is still valid and the
   // number of ready balloons matches the desired count. Deletes itself if the
   // message is sent or if |automation_| is invalid.
   void CheckBalloonCount();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
   BalloonCollection* collection_;
   int count_;
 
   DISALLOW_COPY_AND_ASSIGN(OnNotificationBalloonCountObserver);
 };
 
 // Allows the automation provider to wait for a RENDERER_PROCESS_CLOSED
 // notification.
 class RendererProcessClosedObserver : public content::NotificationObserver {
  public:
   RendererProcessClosedObserver(AutomationProvider* automation,
                                 IPC::Message* reply_message);
   virtual ~RendererProcessClosedObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererProcessClosedObserver);
 };
 
 // Allows the automation provider to wait for acknowledgement that a certain
 // type and number of input events has been processed by the renderer.
 class InputEventAckNotificationObserver : public content::NotificationObserver {
  public:
   InputEventAckNotificationObserver(AutomationProvider* automation,
                                     IPC::Message* reply_message,
                                     int event_type, int count);
   virtual ~InputEventAckNotificationObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   int event_type_;
   int count_;
 
   DISALLOW_COPY_AND_ASSIGN(InputEventAckNotificationObserver);
 };
 
 // Allows the automation provider to wait for all render views to finish any
 // pending loads. This wait is only guaranteed for views that exist at the
 // observer's creation. Will send a message on construction if no views are
 // currently loading.
 class AllViewsStoppedLoadingObserver : public TabEventObserver,
                                        public content::NotificationObserver {
  public:
   AllViewsStoppedLoadingObserver(
       AutomationProvider* automation,
       IPC::Message* reply_message,
       ExtensionProcessManager* extension_process_manager);
   virtual ~AllViewsStoppedLoadingObserver();
 
   // TabEventObserver implementation.
   virtual void OnFirstPendingLoad(content::WebContents* web_contents) OVERRIDE;
   virtual void OnNoMorePendingLoads(
       content::WebContents* web_contents) OVERRIDE;
 
-  // content::NotificationObserver implementation.
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
  private:
   typedef std::set<content::WebContents*> TabSet;
 
   // Checks if there are no pending loads. If none, it will send an automation
   // relpy and delete itself.
   void CheckIfNoMorePendingLoads();
 
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   ExtensionProcessManager* extension_process_manager_;
   content::NotificationRegistrar registrar_;
   TabSet pending_tabs_;
 
   DISALLOW_COPY_AND_ASSIGN(AllViewsStoppedLoadingObserver);
 };
 
 // Observer used to listen for new tab creation to complete.
 class NewTabObserver : public content::NotificationObserver {
  public:
   NewTabObserver(AutomationProvider* automation, IPC::Message* reply_message);
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
  private:
   virtual ~NewTabObserver();
 
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
@@ skipping 39 matching lines @@
 
 // Allows the automation provider to wait for acknowledgement that a drop
 // operation has been processed by the renderer.
 class DragTargetDropAckNotificationObserver
     : public content::NotificationObserver {
  public:
   DragTargetDropAckNotificationObserver(AutomationProvider* automation,
                                         IPC::Message* reply_message);
   virtual ~DragTargetDropAckNotificationObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(DragTargetDropAckNotificationObserver);
 };
 
 // Allows the automation provider to wait for process memory details to be
@@ skipping 14 matching lines @@
 };
 
 // Observes when new v8 heap statistics are computed for a renderer process.
 class V8HeapStatsObserver : public content::NotificationObserver {
  public:
   V8HeapStatsObserver(AutomationProvider* automation,
                       IPC::Message* reply_message,
                       base::ProcessId renderer_id);
   virtual ~V8HeapStatsObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   base::ProcessId renderer_id_;
 
   DISALLOW_COPY_AND_ASSIGN(V8HeapStatsObserver);
 };
 
 // Observes when a new FPS value is computed for a renderer process.
 class FPSObserver : public content::NotificationObserver {
  public:
   FPSObserver(AutomationProvider* automation,
               IPC::Message* reply_message,
               base::ProcessId renderer_id,
               int routing_id);
   virtual ~FPSObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   base::ProcessId renderer_id_;
   int routing_id_;
 
   DISALLOW_COPY_AND_ASSIGN(FPSObserver);
 };
 
 // Manages the process of creating a new Profile and opening a new browser with
 // that profile. This observer should be created, and then a new Profile
 // should be created through the ProfileManager using
 // profile_manager->CreateMultiProfileAsync(). The Observer watches for profile
 // creation, upon which it creates a new browser window; after observing
 // window creation, it creates a new tab and then finally observes it finish
 // loading.
 class BrowserOpenedWithNewProfileNotificationObserver
     : public content::NotificationObserver {
  public:
   BrowserOpenedWithNewProfileNotificationObserver(
       AutomationProvider* automation,
       IPC::Message* reply_message);
   virtual ~BrowserOpenedWithNewProfileNotificationObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details);
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   content::NotificationRegistrar registrar_;
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   int new_window_id_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserOpenedWithNewProfileNotificationObserver);
 };
 
 // Waits for an extension popup to appear and load.
 class ExtensionPopupObserver : public content::NotificationObserver {
  public:
   ExtensionPopupObserver(
       AutomationProvider* automation,
       IPC::Message* reply_message,
       const std::string& extension_id);
   ~ExtensionPopupObserver();
 
+  // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
  private:
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   std::string extension_id_;
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPopupObserver);
 };
 
+#if defined(OS_LINUX)
+// Allows the automation provider to wait for a WINDOW_MAXIMIZED notification.
+class WindowMaximizedObserver : public content::NotificationObserver {
+ public:
+  WindowMaximizedObserver(AutomationProvider* automation,
+                          IPC::Message* reply_message);
+  virtual ~WindowMaximizedObserver();
+
+  // Overridden from content::NotificationObserver:
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE;
+
+ private:
+  content::NotificationRegistrar registrar_;
+  base::WeakPtr<AutomationProvider> automation_;
+  scoped_ptr<IPC::Message> reply_message_;
+
+  DISALLOW_COPY_AND_ASSIGN(WindowMaximizedObserver);
+};
+#endif  // defined(OS_LINUX)
+
+
+
 #endif  // CHROME_BROWSER_AUTOMATION_AUTOMATION_PROVIDER_OBSERVERS_H_