Determine the element location and click synchronously on the renderer.

chrome/browser/automation/automation_tab_helper.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_TAB_HELPER_H_
 #define CHROME_BROWSER_AUTOMATION_AUTOMATION_TAB_HELPER_H_
 #pragma once
 
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/observer_list.h"
 #include "base/memory/weak_ptr.h"
 #include "content/public/browser/web_contents_observer.h"
 
+struct AutomationMouseEvent;
 class AutomationTabHelper;
 
+namespace gfx {
+class Point;
+}
+
 // An observer API implemented by classes which are interested in various
 // tab events from AutomationTabHelper(s).
 class TabEventObserver {
  public:
   // |LOAD_START| and |LOAD_STOP| notifications may occur several times for a
   // sequence of loads that may appear as one complete navigation to a user.
   // For instance, navigating to a non-existent page will cause a load start
   // and stop for the non-existent page; following that, Chrome will schedule
   // a navigation to an error page which causes another load start and stop.
   //
@@ skipping 13 matching lines @@
   //
   // This method will always be called if |OnFirstPendingLoad| was called.
   virtual void OnNoMorePendingLoads(content::WebContents* web_contents) { }
 
   // Called as a result of a tab being snapshotted.
   virtual void OnSnapshotEntirePageACK(
       bool success,
       const std::vector<unsigned char>& png_data,
       const std::string& error_msg) { }
 
+  // Called immediately before the tab processes an automation mouse event.
+  virtual void OnWillProcessMouseEventAt(const gfx::Point& point) { }
+
+  // Called after the tab processes an automation mouse event.
+  // If |success| is false, |error_msg| will be set.
+  virtual void OnProcessMouseEventACK(bool success,
+                                      const std::string& error_msg) { }
+
  protected:
   TabEventObserver();
   virtual ~TabEventObserver();
 
   // On construction, this class does not observe any events. This method
   // sets us up to observe events from the given |AutomationTabHelper|.
   void StartObserving(AutomationTabHelper* tab_helper);
 
   // Stop observing events from the given |AutomationTabHelper|. This does not
   // need to be called before the helper dies, and it is ok if this object is
@@ skipping 24 matching lines @@
   void RemoveObserver(TabEventObserver* observer);
 
   // Snapshots the entire page without resizing.
   void SnapshotEntirePage();
 
 #if !defined(NO_TCMALLOC) && (defined(OS_LINUX) || defined(OS_CHROMEOS))
   // Dumps a heap profile.
   void HeapProfilerDump(const std::string& reason);
 #endif  // !defined(NO_TCMALLOC) && (defined(OS_LINUX) || defined(OS_CHROMEOS))
 
+  void ProcessMouseEvent(const AutomationMouseEvent& event);
+
   // Returns true if the tab is loading or the tab is scheduled to load
   // immediately. Note that scheduled loads may be canceled.
   bool has_pending_loads() const;
 
  private:
   friend class AutomationTabHelperTest;
 
   void OnSnapshotEntirePageACK(
       bool success,
       const std::vector<unsigned char>& png_data,
       const std::string& error_msg);
+  void OnWillProcessMouseEventAt(const gfx::Point& point);
+  void OnProcessMouseEventACK(bool success,
+                              const std::string& error_msg);
 
   // content::WebContentsObserver implementation.
   virtual void DidStartLoading() OVERRIDE;
   virtual void DidStopLoading() OVERRIDE;
   virtual void RenderViewGone(base::TerminationStatus status) OVERRIDE;
   virtual void WebContentsDestroyed(
       content::WebContents* web_contents) OVERRIDE;
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
 
   void OnWillPerformClientRedirect(int64 frame_id, double delay_seconds);
   void OnDidCompleteOrCancelClientRedirect(int64 frame_id);
   void OnTabOrRenderViewDestroyed(content::WebContents* web_contents);
 
   // True if the tab is currently loading. If a navigation is scheduled but not
   // yet loading, this will be false.
   bool is_loading_;
 
   // Set of all the frames (by frame ID) that are scheduled to perform a client
   // redirect.
   std::set<int64> pending_client_redirects_;
 
   // List of all the |TabEventObserver|s, which we broadcast events to.
   ObserverList<TabEventObserver> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(AutomationTabHelper);
 };
 
 #endif  // CHROME_BROWSER_AUTOMATION_AUTOMATION_TAB_HELPER_H_