In chromedriver, check if an element is clickable before clicking.

chrome/test/webdriver/session.cc

 // Copyright (c) 2011 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/test/webdriver/session.h"
 
 #include <sstream>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 694 matching lines @@
 
 Error* Session::GetElementLocationInView(
     const WebElementId& element,
     gfx::Point* location) {
   gfx::Size size;
   Error* error = GetElementSize(current_target_, element, &size);
   if (error)
     return error;
   return GetElementRegionInView(
       element, gfx::Rect(gfx::Point(0, 0), size),
-      false /* center */, location);
+      false /* center */, false /* verify_clickable_at_middle */, location);
 }
 
 Error* Session::GetElementRegionInView(
     const WebElementId& element,
     const gfx::Rect& region,
     bool center,
+    bool verify_clickable_at_middle,
     gfx::Point* location) {
   CHECK(element.is_valid());
 
   gfx::Point region_offset = region.origin();
   gfx::Size region_size = region.size();
   Error* error = GetElementRegionInViewHelper(
-      current_target_, element, region, center, &region_offset);
+      current_target_, element, region, center, verify_clickable_at_middle,
+      &region_offset);
   if (error)
     return error;
 
   for (FramePath frame_path = current_target_.frame_path;
        frame_path.IsSubframe();
        frame_path = frame_path.Parent()) {
     // Find the frame element for the current frame path.
     FrameId frame_id(current_target_.window_id, frame_path.Parent());
     WebElementId frame_element;
     error = FindElement(
@@ skipping 10 matching lines @@
     // Modify |region_offset| by the frame's border.
     int border_left, border_top;
     error = GetElementBorder(
         frame_id, frame_element, &border_left, &border_top);
     if (error)
       return error;
     region_offset.Offset(border_left, border_top);
 
     error = GetElementRegionInViewHelper(
         frame_id, frame_element, gfx::Rect(region_offset, region_size),
-        center, &region_offset);
+        center, verify_clickable_at_middle, &region_offset);
     if (error)
       return error;
   }
   *location = region_offset;
   return NULL;
 }
 
 Error* Session::GetElementSize(const FrameId& frame_id,
                                const WebElementId& element,
                                gfx::Size* size) {
@@ skipping 188 matching lines @@
   if (error)
     return error;
   if (!is_displayed)
     return new Error(kElementNotVisible, "Element must be displayed to click");
 
   gfx::Rect rect;
   error = GetElementFirstClientRect(current_target_, element, &rect);
   if (error)
     return error;
 
-  error = GetElementRegionInView(element, rect, true /* center */, location);
+  error = GetElementRegionInView(
+      element, rect, true /* center */, true /* verify_clickable_at_middle */,
+      location);
   if (error)
     return error;
   location->Offset(rect.width() / 2, rect.height() / 2);
   return NULL;
 }
 
 Error* Session::GetAttribute(const WebElementId& element,
                              const std::string& key, Value** value) {
   std::string script = base::StringPrintf(
       "return (%s).apply(null, arguments);", atoms::GET_ATTRIBUTE);
@@ skipping 327 matching lines @@
     elements->push_back(element);
   } else {
     return new Error(
         kUnknownError,
         "Find element script returned unsupported type: " +
             JsonStringify(value.get()));
   }
   return NULL;
 }
 
+Error* Session::VerifyElementIsClickable(
+    const FrameId& frame_id,
+    const WebElementId& element,
+    const gfx::Point& location) {
+  std::string jscript = base::StringPrintf(
+      "return (%s).apply(null, arguments);", atoms::IS_ELEMENT_CLICKABLE);
+  ListValue jscript_args;
+  jscript_args.Append(element.ToValue());
+  DictionaryValue* location_dict = new DictionaryValue();
+  location_dict->SetInteger("x", location.x());
+  location_dict->SetInteger("y", location.y());
+  jscript_args.Append(location_dict);
+  Value* unscoped_value = NULL;
+  Error* error = ExecuteScript(frame_id, jscript, &jscript_args,
+                               &unscoped_value);
+  if (error)
+    return error;
+
+  scoped_ptr<Value> value(unscoped_value);
+  if (!value->IsType(Value::TYPE_DICTIONARY)) {
+    return new Error(
+        kUnknownError,
+        "isElementClickable atom returned non-dictionary type: " +
+            JsonStringify(value.get()));
+  }
+  DictionaryValue* dict = static_cast<DictionaryValue*>(value.get());
+  bool clickable = false;
+  if (!dict->GetBoolean("clickable", &clickable)) {
+    return new Error(
+        kUnknownError,
+        "isElementClickable atom returned bad invalid dictionary: " +
+            JsonStringify(dict));
+  }
+  std::string message;
+  dict->GetString("message", &message);
+  if (!clickable) {
+    if (message.empty())
+      message = "element is not clickable";
+    return new Error(kUnknownError, message);
+  }
+  if (message.length()) {
+    LOG(WARNING) << message;
+  }
+  return NULL;
+}
+
 Error* Session::GetElementRegionInViewHelper(
     const FrameId& frame_id,
     const WebElementId& element,
     const gfx::Rect& region,
     bool center,
+    bool verify_clickable_at_middle,
     gfx::Point* location) {
   std::string jscript = base::StringPrintf(
       "return (%s).apply(null, arguments);", atoms::GET_LOCATION_IN_VIEW);
   ListValue jscript_args;
   jscript_args.Append(element.ToValue());
   jscript_args.Append(Value::CreateBooleanValue(center));
   DictionaryValue* elem_offset_dict = new DictionaryValue();
   elem_offset_dict->SetInteger("left", region.x());
   elem_offset_dict->SetInteger("top", region.y());
   elem_offset_dict->SetInteger("width", region.width());
   elem_offset_dict->SetInteger("height", region.height());
   jscript_args.Append(elem_offset_dict);
   Value* unscoped_value = NULL;
   Error* error = ExecuteScript(frame_id, jscript, &jscript_args,
                                &unscoped_value);
   scoped_ptr<Value> value(unscoped_value);
   if (error)
     return error;
+
   if (!value->IsType(Value::TYPE_DICTIONARY)) {
     return new Error(
         kUnknownError,
         "Location atom returned non-dictionary type: " +
             JsonStringify(value.get()));
   }
   DictionaryValue* loc_dict = static_cast<DictionaryValue*>(value.get());
   int x = 0, y = 0;
   if (!loc_dict->GetInteger("x", &x) ||
       !loc_dict->GetInteger("y", &y)) {
     return new Error(
         kUnknownError,
         "Location atom returned bad coordinate dictionary: " +
             JsonStringify(loc_dict));
   }
-  *location = gfx::Point(x, y);
+  gfx::Point temp_location = gfx::Point(x, y);
+
+  if (verify_clickable_at_middle) {
+    gfx::Point middle_point = temp_location;
+    middle_point.Offset(region.width() / 2, region.height() / 2);
+    error = VerifyElementIsClickable(frame_id, element, middle_point);
+    if (error)
+      return error;
+  }
+  *location = temp_location;
   return NULL;
 }
 
 Error* Session::GetScreenShot(std::string* png) {
   Error* error = NULL;
   ScopedTempDir screenshots_dir;
   if (!screenshots_dir.CreateUniqueTempDir()) {
     return new Error(kUnknownError,
                      "Could not create temp directory for screenshot");
   }
 
   FilePath path = screenshots_dir.path().AppendASCII("screen");
   RunSessionTask(NewRunnableMethod(
       automation_.get(),
       &Automation::CaptureEntirePageAsPNG,
       current_target_.window_id,
       path,
       &error));
   if (error)
     return error;
   if (!file_util::ReadFileToString(path, png))
     return new Error(kUnknownError, "Could not read screenshot file");
   return NULL;
 }
 
 }  // namespace webdriver