Determine the element location and click synchronously on the renderer.

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 33 matching lines @@
 #include "chrome/browser/password_manager/password_store_consumer.h"
 #include "chrome/browser/search_engines/template_url_service_observer.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/automation_constants.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_types.h"
+#include "content/public/browser/render_view_host_observer.h"
+#include "ui/gfx/point.h"
 #include "ui/gfx/size.h"
 
+struct AutomationMouseEvent;
 class AutomationProvider;
 class BalloonCollection;
 class Browser;
 class ExtensionProcessManager;
 class ExtensionService;
 class InfoBarTabHelper;
 class Notification;
 class Profile;
 class SavePackage;
 class TranslateInfoBarDelegate;
 
+namespace automation {
+class Error;
+}
+
 #if defined(OS_CHROMEOS)
 namespace chromeos {
   class ExistingUserController;
 }
 #endif  // defined(OS_CHROMEOS)
 
 namespace IPC {
 class Message;
 }
 
@@ skipping 1217 matching lines @@
 
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   TabContentsWrapper* tab_contents_;
   FilePath image_path_;
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(PageSnapshotTaker);
 };
 
+// Processes automation mouse events and invokes a callback when processing
+// has completed.
+class AutomationMouseEventProcessor : public content::RenderViewHostObserver,
+                                      public content::NotificationObserver {
+ public:
+  typedef base::Callback<void(const gfx::Point&)> CompletionCallback;
+  typedef base::Callback<void(const automation::Error&)> ErrorCallback;
+
+  // Creates a new processor which immediately processes the given event.
+  // Either the |completion_callback| or |error_callback| will be called
+  // exactly once. After invoking the callback, this class will delete itself.
+  // The |completion_callback| will be given the point at which the mouse event
+  // occurred.
+  AutomationMouseEventProcessor(content::RenderViewHost* render_view_host,
+                                const AutomationMouseEvent& event,
+                                const CompletionCallback& completion_callback,
+                                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.
+  virtual void RenderViewHostDestroyed(content::RenderViewHost* host) OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+
+  // NotificationObserver overrides.
+  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();
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details);
@@ skipping 482 matching lines @@
  private:
   base::WeakPtr<AutomationProvider> automation_;
   scoped_ptr<IPC::Message> reply_message_;
   std::string extension_id_;
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPopupObserver);
 };
 
 #endif  // CHROME_BROWSER_AUTOMATION_AUTOMATION_PROVIDER_OBSERVERS_H_