Adding detection of intercepted element clicks to IE

This brings the IE driver into alignment with the Chrome and Firefox
(geckodriver) drivers, in that it detects when an element attempting to be
clicked on is covered in the z-order by another element. Do note that this
may cause different behavior from previous versions of the IE driver for
WebDriver code that runs only on IE. For code that runs cross-browser,
this should now yield the same behavior across platforms.

Author: jimevans

cpp/iedriver/CommandHandlers/ClickElementCommandHandler.cpp

@@ -120,6 +120,19 @@ void ClickElementCommandHandler::ExecuteInternal(const IECommandExecutor& execut
             return;
           }
 
+          LocationInfo click_location = {};
+          std::string obscuring_element_description;
+          bool obscured = element_wrapper->IsObscured(&click_location,
+                                                      &obscuring_element_description);
+          if (obscured) {
+            std::string error_msg = StringUtilities::Format("Element not clickable at point (%d,%d). Other element would receive the click: %s",
+                                                            click_location.x,
+                                                            click_location.y,
+                                                            obscuring_element_description.c_str());
+            response->SetErrorResponse(ERROR_ELEMENT_CLICK_INTERCEPTED, error_msg);
+            return;
+          }
+
           IECommandExecutor& mutable_executor = const_cast<IECommandExecutor&>(executor);
           status_code = mutable_executor.input_manager()->PerformInputSequence(browser_wrapper, actions);
           browser_wrapper->set_wait_required(true);

cpp/iedriver/Element.cpp

@@ -188,6 +188,70 @@ bool Element::IsInteractable() {
   return result;
 }
 
+bool Element::IsObscured(LocationInfo* click_location,
+                         std::string* obscuring_element_description) {
+  CComPtr<ISVGElement> svg_element;
+  HRESULT hr = this->element_->QueryInterface<ISVGElement>(&svg_element);
+  if (SUCCEEDED(hr) && svg_element != NULL) {
+    // SVG elements can have complex paths making them non-hierarchical
+    // when drawn. We'll just assume the user knows what they're doing
+    // and bail on this test here.
+    return false;
+  }
+
+  bool is_obscured = false;
+  int status_code = this->GetStaticClickLocation(click_location);
+
+  CComPtr<IHTMLDocument2> doc;
+  this->GetContainingDocument(false, &doc);
+
+  CComPtr<IHTMLDocument8> elements_doc;
+  hr = doc.QueryInterface<IHTMLDocument8>(&elements_doc);
+  if (FAILED(hr)) {
+    LOGHR(WARN, hr) << "QueryInterface for IHTMLDocument8 failed";
+  }
+
+  CComPtr<IHTMLDOMChildrenCollection> elements_hit;
+  hr = elements_doc->elementsFromPoint(static_cast<float>(click_location->x),
+                                       static_cast<float>(click_location->y),
+                                       &elements_hit);
+  if (SUCCEEDED(hr) && elements_hit != NULL) {
+    long element_count;
+    elements_hit->get_length(&element_count);
+    for (long index = 0; index < element_count; ++index) {
+      CComPtr<IDispatch> dispatch_in_list;
+      elements_hit->item(index, &dispatch_in_list);
+
+      CComPtr<IHTMLElement> element_in_list;
+      hr = dispatch_in_list->QueryInterface<IHTMLElement>(&element_in_list);
+      bool are_equal = element_in_list.IsEqualObject(this->element_);
+      if (index == 0) {
+        // Return the top-most element in the event we find an obscuring
+        // element in the tree between this element and the top-most one.
+        // Note that since it's the top-most element, it will have no
+        // descendants, so its outerHTML property will contain only itself.
+        CComBSTR outer_html_bstr;
+        hr = element_in_list->get_outerHTML(&outer_html_bstr);
+        std::wstring outer_html = outer_html_bstr;
+        *obscuring_element_description = StringUtilities::ToString(outer_html);
+      }
+
+    
+      VARIANT_BOOL is_child;
+      hr = this->element_->contains(element_in_list, &is_child);
+      VARIANT_BOOL is_ancestor;
+      hr = element_in_list->contains(this->element_, &is_ancestor);
+      is_obscured = is_obscured ||
+                    (is_child != VARIANT_TRUE && is_ancestor != VARIANT_TRUE);
+      if (is_obscured || are_equal) {
+        break;
+      }
+    }
+  }
+
+  return is_obscured;
+}
+
 bool Element::IsEditable() {
   LOG(TRACE) << "Entering Element::IsEditable";
 

cpp/iedriver/Element.h

@@ -66,6 +66,8 @@ class Element {
   bool IsEditable(void);
   bool IsAttachedToDom(void);
   bool IsDocumentFocused(IHTMLDocument2* focused_doc);
+  bool IsObscured(LocationInfo* click_location,
+                  std::string* obscuring_element_description);
 
   std::string element_id(void) const { return this->element_id_; }
   IHTMLElement* element(void) { return this->element_; }