cpp/iedriver/Element.cpp

// Licensed to the Software Freedom Conservancy (SFC) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The SFC licenses this file
// to you under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Ignoring code analysis warnings for:
// "'argument n' might be '0': this does not adhere to the specification for 
// the function 'IHTMLDocument4::createEventObject'", and "'argument n' might
// be null: this does not adhere to the specification for the function
// 'IHTMLDocument4::createEventObject'", and. 
// IHTMLDocument4::createEventObject() should have its first argument set to 
// NULL to create an empty event object, per documentation at:
// http://msdn.microsoft.com/en-us/library/aa752524(v=vs.85).aspx
#pragma warning (disable: 6309)
#pragma warning (disable: 6387)

#include "Element.h"

#include <algorithm>

#include "errorcodes.h"
#include "logging.h"
#include "json.h"

#include "Browser.h"
#include "Generated/atoms.h"
#include "Script.h"
#include "StringUtilities.h"
#include "VariantUtilities.h"
#include "WebDriverConstants.h"

namespace webdriver {

Element::Element(IHTMLElement* element, HWND containing_window_handle) {
  LOG(TRACE) << "Entering Element::Element";

  // NOTE: COM should be initialized on this thread, so we
  // could use CoCreateGuid() and StringFromGUID2() instead.
  UUID guid;
  RPC_WSTR guid_string = NULL;
  RPC_STATUS status = ::UuidCreate(&guid);
  if (status != RPC_S_OK) {
    // If we encounter an error, not bloody much we can do about it.
    // Just log it and continue.
    LOG(WARN) << "UuidCreate returned a status other then RPC_S_OK: " << status;
  }
  status = ::UuidToString(&guid, &guid_string);
  if (status != RPC_S_OK) {
    // If we encounter an error, not bloody much we can do about it.
    // Just log it and continue.
    LOG(WARN) << "UuidToString returned a status other then RPC_S_OK: " << status;
  }

  // RPC_WSTR is currently typedef'd in RpcDce.h (pulled in by rpc.h)
  // as unsigned short*. It needs to be typedef'd as wchar_t* 
  wchar_t* cast_guid_string = reinterpret_cast<wchar_t*>(guid_string);
  this->element_id_ = StringUtilities::ToString(cast_guid_string);

  ::RpcStringFree(&guid_string);

  this->element_ = element;
  this->containing_window_handle_ = containing_window_handle;
}

Element::Element(IHTMLElement* element, HWND containing_window_handle, const std::string& element_id) {
  this->element_ = element;
  this->element_id_ = element_id;
  this->containing_window_handle_ = containing_window_handle;
}

Element::~Element(void) {
}

Json::Value Element::ConvertToJson() {
  LOG(TRACE) << "Entering Element::ConvertToJson";

  Json::Value json_wrapper;
  json_wrapper[JSON_ELEMENT_PROPERTY_NAME] = this->element_id_;

  return json_wrapper;
}

int Element::IsDisplayed(bool ignore_opacity, bool* result) {
  LOG(TRACE) << "Entering Element::IsDisplayed";

  int status_code = WD_SUCCESS;

  // The atom is just the definition of an anonymous
  // function: "function() {...}"; Wrap it in another function so we can
  // invoke it with our arguments without polluting the current namespace.
  std::wstring script_source(L"(function() { return (");
  script_source += atoms::asString(atoms::IS_DISPLAYED);
  script_source += L")})();";

  CComPtr<IHTMLDocument2> doc;
  this->GetContainingDocument(false, &doc);
  // N.B., The second argument to the IsDisplayed atom is "ignoreOpacity".
  Script script_wrapper(doc, script_source, 2);
  script_wrapper.AddArgument(this->element_);
  script_wrapper.AddArgument(ignore_opacity);
  status_code = script_wrapper.Execute();

  if (status_code == WD_SUCCESS) {
    *result = script_wrapper.result().boolVal == VARIANT_TRUE;
  } else {
    LOG(WARN) << "Failed to determine is element displayed";
  }

  return status_code;
}

std::string Element::GetTagName() {
  LOG(TRACE) << "Entering Element::GetTagName";

  CComBSTR tag_name_bstr;
  HRESULT hr = this->element_->get_tagName(&tag_name_bstr);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Failed calling IHTMLElement::get_tagName";
    return "";
  }
  std::wstring converted_tag_name = tag_name_bstr;
  std::string tag_name = StringUtilities::ToString(converted_tag_name);
  std::transform(tag_name.begin(), tag_name.end(), tag_name.begin(), ::tolower);
  return tag_name;
}

bool Element::IsEnabled() {
  LOG(TRACE) << "Entering Element::IsEnabled";

  bool result = false;

  // The atom is just the definition of an anonymous
  // function: "function() {...}"; Wrap it in another function so we can
  // invoke it with our arguments without polluting the current namespace.
  std::wstring script_source(L"(function() { return (");
  script_source += atoms::asString(atoms::IS_ENABLED);
  script_source += L")})();";

  CComPtr<IHTMLDocument2> doc;
  this->GetContainingDocument(false, &doc);

  if (this->IsXmlDocument(doc)) {
    return false;
  }

  Script script_wrapper(doc, script_source, 1);
  script_wrapper.AddArgument(this->element_);
  int status_code = script_wrapper.Execute();

  if (status_code == WD_SUCCESS) {
    result = script_wrapper.result().boolVal == VARIANT_TRUE;
  } else {
    LOG(WARN) << "Failed to determine is element enabled";
  }

  return result;
}

bool Element::IsXmlDocument(IHTMLDocument2* doc) {
  LOG(TRACE) << "Entering Element::IsXmlDocument";
  // If the document has an xmlVersion property, it can be either an XML
  // document or an XHTML document. Otherwise, it's an HTML document.
  CComPtr<IHTMLDocument7> xml_version_document;
  HRESULT hr = doc->QueryInterface<IHTMLDocument7>(&xml_version_document);
  if (SUCCEEDED(hr) && xml_version_document) {
    CComBSTR xml_version = "";
    hr = xml_version_document->get_xmlVersion(&xml_version);
    if (SUCCEEDED(hr) && xml_version && xml_version != L"") {
      // The document is either XML or XHTML, so to differentiate between
      // the two cases, check for a doctype of "html". If we can't find
      // a doctype property, or the doctype is anything other than "html",
      // the document is an XML document.
      CComPtr<IHTMLDocument5> doc_type_document;
      hr = doc->QueryInterface<IHTMLDocument5>(&doc_type_document);
      if (SUCCEEDED(hr) && doc_type_document) {
        CComPtr<IHTMLDOMNode> doc_type_dom_node;
        hr = doc_type_document->get_doctype(&doc_type_dom_node);
        if (SUCCEEDED(hr) && doc_type_dom_node) {
          CComPtr<IDOMDocumentType> doc_type;
          hr = doc_type_dom_node->QueryInterface<IDOMDocumentType>(&doc_type);
          if (SUCCEEDED(hr) && doc_type) {
            CComBSTR type_name_bstr = L"";
            hr = doc_type->get_name(&type_name_bstr);
            type_name_bstr.ToLower();
            std::wstring type_name(type_name_bstr);
            LOG(INFO) << LOGWSTRING(type_name);
            if (SUCCEEDED(hr) && type_name != L"html") {
              return true;
            }
          }
        } else {
          return true;
        }
      }
    }
  }
  return false;
}

bool Element::IsInteractable() {
  LOG(TRACE) << "Entering Element::IsInteractable";

  bool result = false;

  // The atom is just the definition of an anonymous
  // function: "function() {...}"; Wrap it in another function so we can
  // invoke it with our arguments without polluting the current namespace.
  std::wstring script_source(L"(function() { return (");
  script_source += atoms::asString(atoms::IS_INTERACTABLE);
  script_source += L")})();";

  CComPtr<IHTMLDocument2> doc;
  this->GetContainingDocument(false, &doc);
  Script script_wrapper(doc, script_source, 1);
  script_wrapper.AddArgument(this->element_);
  int status_code = script_wrapper.Execute();

  if (status_code == WD_SUCCESS) {
    result = script_wrapper.result().boolVal == VARIANT_TRUE;
  } else {
    LOG(WARN) << "Failed to determine is element enabled";
  }

  return result;
}

bool Element::IsFocusable() {
  LOG(TRACE) << "Entering Element::IsFocusable";

  CComPtr<IHTMLBodyElement> body;
  HRESULT hr = this->element_->QueryInterface<IHTMLBodyElement>(&body);
  if (SUCCEEDED(hr) && body) {
    // The <body> element is explicitly focusable.
    return true;
  }

  CComPtr<IHTMLDocument2> doc;
  this->GetContainingDocument(false, &doc);

  CComPtr<IHTMLDocument3> document_element_doc;
  hr = doc->QueryInterface<IHTMLDocument3>(&document_element_doc);
  if (SUCCEEDED(hr) && document_element_doc) {
    CComPtr<IHTMLElement> doc_element;
    hr = document_element_doc->get_documentElement(&doc_element);
    if (SUCCEEDED(hr) && doc_element && this->element_.IsEqualObject(doc_element)) {
      // The document's documentElement is explicitly focusable.
      return true;
    }
  }
  return false;
}

bool Element::IsObscured(LocationInfo* click_location,
                         long* obscuring_element_index,
                         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;
  }

  // If an element has a style value where pointer-events is set to 'none',
  // the element is "obscured" by definition, since any mouse interaction
  // will not be handled by the element.
  CComPtr<IHTMLCSSStyleDeclaration> computed_style;
  if (this->GetComputedStyle(&computed_style)) {
    CComBSTR pointer_events_value = L"";
    hr = computed_style->get_pointerEvents(&pointer_events_value);
    if (SUCCEEDED(hr) && pointer_events_value == L"none") {
      return true;
    }
  }

  // The element being obscured only makes sense within the context
  // of its own document, even if it's not in the top-level document.
  LocationInfo element_location = {};
  int status_code = this->GetLocation(&element_location, nullptr);
  *click_location = this->CalculateClickPoint(element_location, false);
  long x = click_location->x;
  long y = click_location->y;

  bool is_inline = this->IsInline();

  CComPtr<IHTMLDocument2> doc;
  this->GetContainingDocument(false, &doc);
  CComPtr<IHTMLElement> element_hit;
  hr = doc->elementFromPoint(x, y, &element_hit);
  if (SUCCEEDED(hr) && element_hit) {
    if (element_.IsEqualObject(element_hit)) {
      // Short circuit the use of elementsFromPoint if we don't
      // have to use it.
      return false;
    } else {
      // Short circuit in the case where this element is specifically
      // an "inline" element (<label>, <span>, <a>, at present),
      // and the top-most element as determined by elementFromPoint is
      // a direct child of this element. This is to work around IE's bug
      // in elementsFromPoint that does not return inline elements in the
      // list of elements hit.
      // N.B., this is a hack of the highest order, and there's every
      // likelihood that some page somewhere will fail this check.
      if (is_inline) {
        CComPtr<IHTMLElement> element_hit_parent;
        hr = element_hit->get_parentElement(&element_hit_parent);
        CComBSTR element_hit_parent_tag;
        element_hit_parent->get_tagName(&element_hit_parent_tag);
        if (SUCCEEDED(hr) && element_hit_parent) {
          if (this->element_.IsEqualObject(element_hit_parent)) {
            return false;
          }
        }
      }
    }
  }

  bool has_shadow_root = this->HasShadowRoot();
  CComPtr<IHTMLElement> shadow_root_parent;
  if (has_shadow_root) {
    // TODO: Walk up the DOM tree until we receive an ancestor that
    // does not have a shadow root.
    hr = this->element()->get_parentElement(&shadow_root_parent);
    if (FAILED(hr)) {
      LOGHR(WARN, hr) << "Element has shadow root, but cannot get parent";
    }
  }

  CComPtr<IHTMLDocument8> elements_doc;
  hr = doc.QueryInterface<IHTMLDocument8>(&elements_doc);
  if (FAILED(hr)) {
    // If we failed to QI for IHTMLDocument8, we can't easily determine if
    // the element is obscured or not. We will assume we are not obscured
    // and bail, even though that may not be the case.
    LOGHR(WARN, hr) << "QueryInterface for IHTMLDocument8 failed";
    return false;
  }

  bool is_obscured = false;
  CComPtr<IHTMLDOMChildrenCollection> elements_hit;
  hr = elements_doc->elementsFromPoint(static_cast<float>(x),
                                       static_cast<float>(y),
                                       &elements_hit);
  if (SUCCEEDED(hr) && elements_hit != NULL) {
    std::vector<std::string> element_descriptions;
    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 (are_equal) {
        break;
      }

      bool is_list_element_displayed;
      Element list_element_wrapper(element_in_list,
                                   this->containing_window_handle_);
      status_code = list_element_wrapper.IsDisplayed(false,
                                                     &is_list_element_displayed);
      if (is_list_element_displayed) {
        if (has_shadow_root && shadow_root_parent) {
          // Shadow DOM is problematic. Shadow DOM is only available in IE as a
          // polyfill. If the element is part of a Shadow DOM (using a polyfill),
          // elementsFromPoint will show the component elements, not necessarily
          // the Web Component root element itself. If the direct parent of the
          // Web Component host element is in this list, then it counts as a
          // direct descendent, and won't be obscured.
          bool is_shadow_root_parent = element_in_list.IsEqualObject(shadow_root_parent);
          if (is_shadow_root_parent) {
            break;
          }
        }

        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);
        bool found_element_not_in_tree = is_child != VARIANT_TRUE &&
                                         is_ancestor != VARIANT_TRUE;
        if (found_element_not_in_tree) {
          CComPtr<IHTMLFrameBase> frame_element;
          hr = element_in_list->QueryInterface<IHTMLFrameBase>(&frame_element);
          if (SUCCEEDED(hr) && frame_element) {
            // Candidate element is a <frame> or <iframe>, meaning it must
            // be a different document tree, which implies that it cannot
            // be obscuring the element we are attempting to click on.
            continue;
          }

          CComPtr<IHTMLCSSStyleDeclaration> list_element_computed_style;
          if (list_element_wrapper.GetComputedStyle(&list_element_computed_style)) {
            CComBSTR list_element_pointer_events_value = L"";
            hr = list_element_computed_style->get_pointerEvents(&list_element_pointer_events_value);
            if (SUCCEEDED(hr) && list_element_pointer_events_value != L"none") {
              // If the element has a pointer-events value set to 'none', it
              // may be technically obscuring this element, but manipulating
              // it with the pointer device has no effect, so it is effectively
              // not obscuring this element.
              is_obscured = true;
            }
          } else {
            // We were unable to retrieve the computed style, so we must assume
            // the other element is obscuring this one.
            is_obscured = true;
          }
        } else {
          // Repeating the immediate-child-of-inline-element hack from above for
          // elements found in the list.
          if (is_inline) {
            CComPtr<IHTMLElement> list_element_parent;
            hr = element_in_list->get_parentElement(&list_element_parent);
            if (SUCCEEDED(hr) && list_element_parent) {
              if (this->element_.IsEqualObject(list_element_parent)) {
                break;
              }
            }
          }
        }
        if (is_obscured) {
          // 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.
          std::string outer_html = this->GetElementHtmlDescription(element_in_list);
          *obscuring_element_index = index;
          *obscuring_element_description = outer_html;
          break;
        }
      }
    }
  }

  return is_obscured;
}

std::string Element::GetElementHtmlDescription(IHTMLElement* element) {
  CComBSTR outer_html_bstr;
  HRESULT hr = element->get_outerHTML(&outer_html_bstr);
  std::wstring outer_html = outer_html_bstr;
  size_t bracket_pos = outer_html.find(L'>');
  if (bracket_pos != std::wstring::npos) {
    outer_html = outer_html.substr(0, bracket_pos + 1);
  }
  return StringUtilities::ToString(outer_html);
}

bool Element::HasShadowRoot() {
  std::wstring script_source(ANONYMOUS_FUNCTION_START);
  script_source += L"return (function() { if (arguments[0].shadowRoot && arguments[0].shadowRoot !== null) { return true; } return false; })";
  script_source += ANONYMOUS_FUNCTION_END;

  CComPtr<IHTMLDocument2> doc;
  this->GetContainingDocument(false, &doc);
  Script script_wrapper(doc, script_source, 1);
  script_wrapper.AddArgument(this->element_);
  int status_code = script_wrapper.Execute();
  if (status_code == WD_SUCCESS) {
    if (script_wrapper.ResultIsBoolean()) {
      return script_wrapper.result().boolVal == VARIANT_TRUE;
    }
  }
  return false;
}

bool Element::GetComputedStyle(IHTMLCSSStyleDeclaration** computed_style) {
  HRESULT hr = S_OK;
  CComPtr<IHTMLDocument2> doc;
  int status_code = this->GetContainingDocument(false, &doc);
  if (status_code == WD_SUCCESS) {
    CComPtr<IHTMLWindow2> window;
    hr = doc->get_parentWindow(&window);
    if (SUCCEEDED(hr) && window) {
      CComPtr<IHTMLWindow7> style_window;
      hr = window->QueryInterface<IHTMLWindow7>(&style_window);
      if (SUCCEEDED(hr) && style_window) {
        CComPtr<IHTMLDOMNode> node;
        hr = this->element_->QueryInterface<IHTMLDOMNode>(&node);
        if (SUCCEEDED(hr) && node) {
          hr = style_window->getComputedStyle(node, NULL, computed_style);
          if (SUCCEEDED(hr) && computed_style) {
            return true;
          }
        }
      }
    }
  }
  return false;
}

bool Element::IsEditable() {
  LOG(TRACE) << "Entering Element::IsEditable";

  bool result = false;

  // The atom is just the definition of an anonymous
  // function: "function() {...}"; Wrap it in another function so we can
  // invoke it with our arguments without polluting the current namespace.
  std::wstring script_source(L"(function() { return (");
  script_source += atoms::asString(atoms::IS_EDITABLE);
  script_source += L")})();";

  CComPtr<IHTMLDocument2> doc;
  this->GetContainingDocument(false, &doc);
  Script script_wrapper(doc, script_source, 1);
  script_wrapper.AddArgument(this->element_);
  int status_code = script_wrapper.Execute();

  if (status_code == WD_SUCCESS) {
    result = script_wrapper.result().boolVal == VARIANT_TRUE;
  } else {
    LOG(WARN) << "Failed to determine is element enabled";
  }

  return result;
}

int Element::GetClickLocation(const ElementScrollBehavior scroll_behavior,
                              LocationInfo* element_location,
                              LocationInfo* click_location) {
  LOG(TRACE) << "Entering Element::GetClickLocation";

  bool displayed;
  int status_code = this->IsDisplayed(true, &displayed);
  if (status_code != WD_SUCCESS) {
    LOG(WARN) << "Unable to determine element is displayed";
    return status_code;
  } 

  if (!displayed) {
    LOG(WARN) << "Element is not displayed";
    return EELEMENTNOTDISPLAYED;
  }

  std::vector<LocationInfo> frame_locations;
  status_code = this->GetLocationOnceScrolledIntoView(scroll_behavior,
                                                      element_location,
                                                      &frame_locations);

  if (status_code == WD_SUCCESS) {
    bool document_contains_frames = frame_locations.size() != 0;
    *click_location = CalculateClickPoint(*element_location,
                                          document_contains_frames);
  }
  return status_code;
}

int Element::GetStaticClickLocation(LocationInfo* click_location) {
  std::vector<LocationInfo> frame_locations;
  LocationInfo element_location = {};
  int result = this->GetLocation(&element_location, &frame_locations);
  bool document_contains_frames = frame_locations.size() != 0;
  *click_location = this->CalculateClickPoint(element_location, document_contains_frames);
  return result;
}

int Element::GetAttributeValue(const std::string& attribute_name,
                               VARIANT* attribute_value) {
  LOG(TRACE) << "Entering Element::GetAttributeValue";

  std::wstring wide_attribute_name = StringUtilities::ToWString(attribute_name);
  int status_code = WD_SUCCESS;

  // The atom is just the definition of an anonymous
  // function: "function() {...}"; Wrap it in another function so we can
  // invoke it with our arguments without polluting the current namespace.
  std::wstring script_source(L"(function() { return (");
  script_source += atoms::asString(atoms::GET_ATTRIBUTE);
  script_source += L")})();";

  CComPtr<IHTMLDocument2> doc;
  this->GetContainingDocument(false, &doc);
  Script script_wrapper(doc, script_source, 2);
  script_wrapper.AddArgument(this->element_);
  script_wrapper.AddArgument(wide_attribute_name);
  status_code = script_wrapper.Execute();
  
  if (status_code == WD_SUCCESS) {
    ::VariantCopy(attribute_value, &script_wrapper.result());
  } else {
    LOG(WARN) << "Failed to determine element attribute";
  }

  return WD_SUCCESS;
}

int Element::GetPropertyValue(const std::string& property_name,
                              VARIANT* property_value) {
  LOG(TRACE) << "Entering Element::GetPropertyValue";

  std::wstring wide_property_name = StringUtilities::ToWString(property_name);
  int status_code = WD_SUCCESS;

  LPOLESTR property_name_pointer = reinterpret_cast<LPOLESTR>(const_cast<wchar_t*>(wide_property_name.data()));
  DISPID dispid_property;
  HRESULT hr = this->element_->GetIDsOfNames(IID_NULL,
                                             &property_name_pointer,
                                             1,
                                             LOCALE_USER_DEFAULT,
                                             &dispid_property);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Unable to get dispatch ID (dispid) for property "
                    << property_name;
    property_value->vt = VT_EMPTY;
    return WD_SUCCESS;
  }

  // get the value of eval result
  DISPPARAMS no_args_dispatch_parameters = { 0 };
  hr = this->element_->Invoke(dispid_property,
                              IID_NULL,
                              LOCALE_USER_DEFAULT,
                              DISPATCH_PROPERTYGET,
                              &no_args_dispatch_parameters,
                              property_value,
                              NULL,
                              NULL);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Unable to get result for property "
                    << property_name;
    property_value->vt = VT_EMPTY;
    return WD_SUCCESS;
  }

  return WD_SUCCESS;
}

int Element::GetCssPropertyValue(const std::string& property_name,
                                 std::string* property_value) {
  LOG(TRACE) << "Entering Element::GetCssPropertyValue";

  int status_code = WD_SUCCESS;
  CComPtr<IHTMLDocument2> doc;
  this->GetContainingDocument(false, &doc);
  if (this->IsXmlDocument(doc)) {
    *property_value = "";
    return status_code;
  }

  // The atom is just the definition of an anonymous
  // function: "function() {...}"; Wrap it in another function so we can
  // invoke it with our arguments without polluting the current namespace.
  std::wstring script_source = L"(function() { return (";
  script_source += atoms::asString(atoms::GET_EFFECTIVE_STYLE);
  script_source += L")})();";

  Script script_wrapper(doc, script_source, 2);
  script_wrapper.AddArgument(this->element_);
  script_wrapper.AddArgument(property_name);
  status_code = script_wrapper.Execute();

  if (status_code == WD_SUCCESS) {
    std::wstring raw_value = L"";
    if (script_wrapper.ResultIsString()) {
      raw_value.assign(script_wrapper.result().bstrVal);
    } else if (script_wrapper.ResultIsInteger()) {
      long int_value = script_wrapper.result().lVal;
      raw_value = std::to_wstring(int_value);
    } else if (script_wrapper.ResultIsDouble()) {
      double dbl_value = script_wrapper.result().dblVal;
      raw_value = std::to_wstring(dbl_value);
    } else if (script_wrapper.ResultIsBoolean()) {
      if (script_wrapper.result().boolVal == VARIANT_TRUE) {
        raw_value = L"true";
      } else {
        raw_value = L"false";
      }
    }
    std::string value = StringUtilities::ToString(raw_value);
    std::transform(value.begin(),
                   value.end(),
                   value.begin(),
                   tolower);
    *property_value = value;
  } else {
    LOG(WARN) << "Failed to get value of CSS property";
  }
  return status_code;
}

int Element::GetLocationOnceScrolledIntoView(const ElementScrollBehavior scroll,
                                             LocationInfo* location,
                                             std::vector<LocationInfo>* frame_locations) {
  LOG(TRACE) << "Entering Element::GetLocationOnceScrolledIntoView";

  int status_code = WD_SUCCESS;
  CComPtr<IHTMLDOMNode2> node;
  HRESULT hr = this->element_->QueryInterface(&node);

  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Cannot cast html element to node, QI on IHTMLElement for IHTMLDOMNode2 failed";
    return ENOSUCHELEMENT;
  }

  LocationInfo element_location = {};
  int result = this->GetLocation(&element_location, frame_locations);
  bool document_contains_frames = frame_locations->size() != 0;
  LocationInfo click_location = this->CalculateClickPoint(element_location, document_contains_frames);  

  if (result != WD_SUCCESS ||
      !this->IsLocationInViewPort(click_location, document_contains_frames) ||
      this->IsHiddenByOverflow(element_location, click_location) ||
      !this->IsLocationVisibleInFrames(click_location, *frame_locations)) {
    // Scroll the element into view
    LOG(DEBUG) << "Will need to scroll element into view";
    CComVariant scroll_behavior = VARIANT_TRUE;
    if (scroll == BOTTOM) {
      scroll_behavior = VARIANT_FALSE;
    }
    hr = this->element_->scrollIntoView(scroll_behavior);
    if (FAILED(hr)) {
      LOGHR(WARN, hr) << "Cannot scroll element into view, IHTMLElement::scrollIntoView failed";
      return EOBSOLETEELEMENT;
    }

    std::vector<LocationInfo> scrolled_frame_locations;
    result = this->GetLocation(&element_location, &scrolled_frame_locations);
    if (result != WD_SUCCESS) {
      LOG(WARN) << "Unable to get location of scrolled to element";
      return result;
    }

    click_location = this->CalculateClickPoint(element_location, document_contains_frames);
    if (!this->IsLocationInViewPort(click_location, document_contains_frames)) {
      LOG(WARN) << "Scrolled element is not in view";
      status_code = EELEMENTCLICKPOINTNOTSCROLLED;
    }

    // TODO: Handle the case where the element's click point is in
    // the view port but hidden by the overflow of a parent element.
    // That could would look something like the following:
    // if (this->IsHiddenByOverflow(element_location, click_location)) {
    //   if (!this->IsEntirelyHiddenByOverflow()) {
    //     this->ScrollWithinOverflow(element_location);
    //   }
    //   status_code = EELEMENTCLICKPOINTNOTSCROLLED;
    // }
  }

  LOG(DEBUG) << "(x, y, w, h): "
             << element_location.x << ", "
             << element_location.y << ", "
             << element_location.width << ", "
             << element_location.height;

  // At this point, we know the element is displayed according to its
  // style attributes, and we've made a best effort at scrolling it so
  // that it's completely within the viewport. We will always return
  // the coordinates of the element, even if the scrolling is unsuccessful.
  // However, we will still return the "element not displayed" status code
  // if the click point has not been scrolled to the viewport.
  location->x = element_location.x;
  location->y = element_location.y;
  location->width = element_location.width;
  location->height = element_location.height;

  return status_code;
}

bool Element::IsHiddenByOverflow(const LocationInfo element_location,
                                 const LocationInfo click_location) {
  LOG(TRACE) << "Entering Element::IsHiddenByOverflow";

  bool is_overflow = false;

  int x_offset = click_location.x - element_location.x;
  int y_offset = click_location.y - element_location.y;

  std::wstring script_source(L"(function() { return (");
  script_source += atoms::asString(atoms::IS_OFFSET_IN_PARENT_OVERFLOW);
  script_source += L")})();";

  CComPtr<IHTMLDocument2> doc;
  this->GetContainingDocument(false, &doc);
  Script script_wrapper(doc, script_source, 3);
  script_wrapper.AddArgument(this->element_);
  script_wrapper.AddArgument(x_offset);
  script_wrapper.AddArgument(y_offset);
  int status_code = script_wrapper.Execute();
  if (status_code == WD_SUCCESS) {
    std::wstring raw_overflow_state(script_wrapper.result().bstrVal);
    std::string overflow_state = StringUtilities::ToString(raw_overflow_state);
    is_overflow = (overflow_state == "scroll");
  } else {
    LOG(WARN) << "Unable to determine is element hidden by overflow";
  }

  return is_overflow;
}

bool Element::IsEntirelyHiddenByOverflow() {
  LOG(TRACE) << "Entering Element::IsEntirelyHiddenByOverflow";

  bool is_overflow = false;

  std::wstring script_source(L"(function() { return (");
  script_source += atoms::asString(atoms::IS_ELEMENT_IN_PARENT_OVERFLOW);
  script_source += L")})();";

  CComPtr<IHTMLDocument2> doc;
  this->GetContainingDocument(false, &doc);
  Script script_wrapper(doc, script_source, 1);
  script_wrapper.AddArgument(this->element_);
  int status_code = script_wrapper.Execute();
  if (status_code == WD_SUCCESS) {
    std::wstring raw_overflow_state(script_wrapper.result().bstrVal);
    std::string overflow_state = StringUtilities::ToString(raw_overflow_state);
    is_overflow = (overflow_state == "scroll");
  } else {
    LOG(WARN) << "Unable to determine is element hidden by overflow";
  }

  return is_overflow;
}

bool Element::ScrollWithinOverflow(const LocationInfo element_location) {
  RECT element_rect;
  element_rect.left = element_location.x;
  element_rect.top = element_location.y;
  element_rect.right = element_location.x + element_location.width;
  element_rect.bottom = element_location.y + element_location.height;

  CComPtr<IHTMLElement> parent_element;
  this->element_->get_parentElement(&parent_element);
  while (parent_element != NULL) {
    CComPtr<IHTMLElement2> el2;
    parent_element->QueryInterface<IHTMLElement2>(&el2);
    CComPtr<IHTMLRect> parent_bounding_rect;
    el2->getBoundingClientRect(&parent_bounding_rect);
    RECT parent_rect;
    parent_bounding_rect->get_left(&parent_rect.left);
    parent_bounding_rect->get_top(&parent_rect.top);
    parent_bounding_rect->get_right(&parent_rect.right);
    parent_bounding_rect->get_bottom(&parent_rect.bottom);
    RECT intersection;
    if (::IntersectRect(&intersection, &element_rect, &parent_rect)) {
      if (::EqualRect(&intersection, &element_rect)) {
        CComPtr<IHTMLElement> next_ancestor;
        // The entire element is visible within this ancestor.
        // Need to proceed to the next ancestor in the tree.
        parent_element->get_parentElement(&next_ancestor);
        parent_element.Release();
        parent_element = next_ancestor;
      } else {
        // We have the intersecting rect, so adjust the location
        long intersection_vert_center = intersection.top + ((intersection.bottom - intersection.top) / 2);
        long intersection_horiz_center = intersection.left + ((intersection.right - intersection.left) / 2);

        long offset_top = 0;
        element_->get_offsetTop(&offset_top);
        offset_top += element_location.height / 2;

        long offset_left = 0;
        element_->get_offsetLeft(&offset_left);
        offset_left += element_location.width / 2;

        el2->put_scrollTop(offset_top - intersection_vert_center);
        el2->put_scrollLeft(offset_left - intersection_horiz_center);
        return true;
      }
    } else {
      // the rects don't intersect, so something went wrong.
      break;
    }
  }
  return false;
}
bool Element::IsLocationVisibleInFrames(const LocationInfo location,
                                        const std::vector<LocationInfo> frame_locations) {
  std::vector<LocationInfo>::const_iterator iterator = frame_locations.begin();
  for (; iterator != frame_locations.end(); ++iterator) {
    if (location.x < iterator->x || 
        location.y < iterator->y ||
        location.x > iterator->x + iterator->width || 
        location.y > iterator->y + iterator->height) {
      return false;
    }
  }
  return true;
}

bool Element::IsSelected() {
  LOG(TRACE) << "Entering Element::IsSelected";

  bool selected(false);
  // The atom is just the definition of an anonymous
  // function: "function() {...}"; Wrap it in another function so we can
  // invoke it with our arguments without polluting the current namespace.
  std::wstring script_source(L"(function() { return (");
  script_source += atoms::asString(atoms::IS_SELECTED);
  script_source += L")})();";

  CComPtr<IHTMLDocument2> doc;
  this->GetContainingDocument(false, &doc);
  Script script_wrapper(doc, script_source, 1);
  script_wrapper.AddArgument(this->element_);
  int status_code = script_wrapper.Execute();

  if (status_code == WD_SUCCESS && script_wrapper.ResultIsBoolean()) {
    selected = script_wrapper.result().boolVal == VARIANT_TRUE;
  } else {
    LOG(WARN) << "Unable to determine is element selected";
  }

  return selected;
}

bool Element::IsImageMap(LocationInfo* location) {
  CComPtr<IHTMLElement> map_element;
  CComPtr<IHTMLAreaElement> area_element;
  CComPtr<IHTMLMapElement> map_element_candidate;
  this->element_->QueryInterface<IHTMLMapElement>(&map_element_candidate);
  if (map_element_candidate == NULL) {
    this->element_->QueryInterface<IHTMLAreaElement>(&area_element);
    if (area_element) {
      this->element_->get_parentElement(&map_element);
      if (map_element) {
        map_element->QueryInterface<IHTMLMapElement>(&map_element_candidate);
      }
    }
  }

  if (map_element_candidate && map_element) {
    CComBSTR name_bstr;
    map_element_candidate->get_name(&name_bstr);
    CComBSTR img_selector = L"*[usemap='#";
    img_selector.Append(name_bstr);
    img_selector.Append(L"']");

    CComPtr<IDispatch> doc_dispatch;
    map_element->get_document(&doc_dispatch);

    CComPtr<IDocumentSelector> doc;
    doc_dispatch->QueryInterface<IDocumentSelector>(&doc);
    if (doc) {
      CComPtr<IHTMLElement> img_element;
      doc->querySelector(img_selector, &img_element);
      if (img_element) {
        CComPtr<IHTMLElement2> rect_element;
        img_element->QueryInterface<IHTMLElement2>(&rect_element);
        if (rect_element) {
          CComPtr<IHTMLRect> rect;
          rect_element->getBoundingClientRect(&rect);
          RECT img_rect;
          rect->get_left(&img_rect.left);
          rect->get_top(&img_rect.top);
          rect->get_right(&img_rect.right);
          rect->get_bottom(&img_rect.bottom);

          CComBSTR shape;
          area_element->get_shape(&shape);
          shape.ToLower();
          if (shape == L"default") {
            location->x = img_rect.left;
            location->y = img_rect.top;
            location->width = img_rect.right - img_rect.left;
            location->height = img_rect.bottom - img_rect.top;
            return true;
          }

          CComBSTR coords_bstr;
          area_element->get_coords(&coords_bstr);
          std::wstring coords(coords_bstr);
          std::vector<std::wstring> individual;
          StringUtilities::Split(coords, L",", &individual);
          RECT area_rect = { 0, 0, 0, 0 };
          if (shape == L"rect" && individual.size() == 4) {
            area_rect.left = std::stol(individual.at(0).c_str(), 0, 10);
            area_rect.top = std::stol(individual.at(1).c_str(), 0, 10);
            area_rect.right = std::stol(individual.at(2).c_str(), 0, 10);
            area_rect.bottom = std::stol(individual.at(3).c_str(), 0, 10);
          }
          else if ((shape == L"circle" || shape == "circ") && individual.size() == 3) {
            long center_x = std::stol(individual.at(0), 0, 10);
            long center_y = std::stol(individual.at(1), 0, 10);
            long radius = std::stol(individual.at(2), 0, 10);
            area_rect.left = center_x - radius;
            area_rect.top = center_y - radius;
            area_rect.right = center_x + radius;
            area_rect.bottom = center_y + radius;
          }
          else if ((shape == L"poly" || shape == L"polygon") && individual.size() > 2) {
            long min_x = std::stol(individual.at(0), 0, 10);
            long min_y = std::stol(individual.at(1), 0, 10);
            long max_x = min_x;
            long max_y = min_y;
            for (size_t i = 2; i + 1 < individual.size(); i += 2) {
              long next_x = std::stol(individual.at(i), 0, 10);
              long next_y = std::stol(individual.at(i + 1), 0, 10);
              min_x = min(min_x, next_x);
              max_x = max(max_x, next_x);
              min_y = min(min_y, next_y);
              max_y = max(max_y, next_y);
            }
            area_rect.left = min_x;
            area_rect.bottom = min_y;
            area_rect.right = max_x;
            area_rect.bottom = max_y;
          }
          else {
            // Invalid shape value or coordinate values. Not modifying location.
            return false;
          }

          long img_width = img_rect.right - img_rect.left;
          long img_height = img_rect.bottom - img_rect.top;
          long area_width = area_rect.right - area_rect.left;
          long area_height = area_rect.bottom - area_rect.top;
          location->x = img_rect.left + min(max(area_rect.left, 0), img_width);
          location->y = img_rect.top + min(max(area_rect.top, 0), img_height);
          location->width = min(area_width, img_width - location->x);
          location->height = min(area_height, img_height - location->y);
          return true;
        }
      }
    }
  }
  return false;
}

int Element::GetLocation(LocationInfo* location,
                         std::vector<LocationInfo>* frame_locations) {
  LOG(TRACE) << "Entering Element::GetLocation";

  bool has_absolute_position_ready_to_return = false;

  CComPtr<IHTMLElement2> element2;
  HRESULT hr = this->element_->QueryInterface(&element2);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Unable to cast element to IHTMLElement2";
    return EOBSOLETEELEMENT;
  }

  long top = 0, bottom = 0, left = 0, right = 0;
  LocationInfo map_location = { 0, 0, 0, 0 };
  if (this->IsImageMap(&map_location)) {
    left = map_location.x;
    top = map_location.y;
    right = map_location.x + map_location.width;
    bottom = map_location.y + map_location.height;
  } else {
    // If this element is inline, we need to check whether we should 
    // use getBoundingClientRect() or the first non-zero-sized rect returned
    // by getClientRects(). If the element is not inline, we can use
    // getBoundingClientRect() directly.
    CComPtr<IHTMLRect> rect;
    if (this->IsInline()) {
      CComPtr<IHTMLRectCollection> rects;
      hr = element2->getClientRects(&rects);
      long rect_count;
      rects->get_length(&rect_count);
      if (rect_count > 1) {
        LOG(DEBUG) << "Element is inline with multiple client rects, finding first non-zero sized client rect";
        for (long i = 0; i < rect_count; ++i) {
          CComVariant index(i);
          CComVariant rect_variant;
          hr = rects->item(&index, &rect_variant);
          if (SUCCEEDED(hr) && rect_variant.pdispVal) {
            CComPtr<IHTMLRect> qi_rect;
            rect_variant.pdispVal->QueryInterface<IHTMLRect>(&qi_rect);
            if (qi_rect) {
              rect = qi_rect;
              if (RectHasNonZeroDimensions(rect)) {
                // IE returns absolute positions in the page, rather than frame- and scroll-bound
                // positions, for clientRects (as opposed to boundingClientRects).
                has_absolute_position_ready_to_return = true;
                break;
              }
            }
          }
        }
      }
      else {
        LOG(DEBUG) << "Element is inline with one client rect, using IHTMLElement2::getBoundingClientRect";
        hr = element2->getBoundingClientRect(&rect);
      }
    }
    else {
      LOG(DEBUG) << "Element is a block element, using IHTMLElement2::getBoundingClientRect";
      hr = element2->getBoundingClientRect(&rect);
      if (this->HasFirstChildTextNodeOfMultipleChildren()) {
        LOG(DEBUG) << "Element has multiple children, but the first child is a text node, using text node boundaries";
        // Note that since subsequent statements in this method use the HTMLRect
        // object, we will update that object with the values of the text node.
        LocationInfo text_node_location;
        this->GetTextBoundaries(&text_node_location);
        rect->put_left(text_node_location.x);
        rect->put_top(text_node_location.y);
        rect->put_right(text_node_location.x + text_node_location.width);
        rect->put_bottom(text_node_location.y + text_node_location.height);
      }
    }
    if (FAILED(hr)) {
      LOGHR(WARN, hr) << "Cannot figure out where the element is on screen, client rect retrieval failed";
      return EUNHANDLEDERROR;
    }

    // If the rect of the element has zero width and height, check its
    // children to see if any of them have width and height, in which
    // case, this element will be visible.
    if (!RectHasNonZeroDimensions(rect)) {
      LOG(DEBUG) << "Element has client rect with zero dimension, checking children for non-zero dimension client rects";
      CComPtr<IHTMLDOMNode> node;
      element2->QueryInterface(&node);
      CComPtr<IDispatch> children_dispatch;
      node->get_childNodes(&children_dispatch);
      CComPtr<IHTMLDOMChildrenCollection> children;
      children_dispatch->QueryInterface<IHTMLDOMChildrenCollection>(&children);
      if (!!children) {
        long children_count = 0;
        children->get_length(&children_count);
        for (long i = 0; i < children_count; ++i) {
          CComPtr<IDispatch> child_dispatch;
          children->item(i, &child_dispatch);
          CComPtr<IHTMLElement> child;
          child_dispatch->QueryInterface(&child);
          if (child != NULL) {
            int result = WD_SUCCESS;
            Element child_element(child, this->containing_window_handle_);
            if (frame_locations == nullptr) {
              result = child_element.GetLocation(location, nullptr);
            }
            else {
              std::vector<LocationInfo> child_frame_locations;
              result = child_element.GetLocation(location, &child_frame_locations);
            }
            if (result == WD_SUCCESS) {
              return result;
            }
          }
        }
      }
    }

    rect->get_top(&top);
    rect->get_left(&left);
    rect->get_bottom(&bottom);
    rect->get_right(&right);
  }

  long w = right - left;
  long h = bottom - top;

  bool element_is_in_frame = this->AppendFrameDetails(frame_locations);
  if (!has_absolute_position_ready_to_return) {
    // On versions of IE prior to 8 on Vista, if the element is out of the 
    // viewport this would seem to return 0,0,0,0. IE 8 returns position in 
    // the DOM regardless of whether it's in the browser viewport.
    long scroll_left, scroll_top = 0;
    element2->get_scrollLeft(&scroll_left);
    element2->get_scrollTop(&scroll_top);
    left += scroll_left;
    top += scroll_top;

    // Only add the frame offset if the element is actually in a frame.
    if (element_is_in_frame) {
      LocationInfo frame_location = frame_locations->back();
      left += frame_location.x;
      top += frame_location.y;
    } else {
      LOG(DEBUG) << "Element is not in a frame";
    }
  }

  location->x = left;
  location->y = top;
  location->width = w;
  location->height = h;

  return WD_SUCCESS;
}

bool Element::IsInline() {
  LOG(TRACE) << "Entering Element::IsInline";

  // TODO(jimevans): Clean up this extreme lameness.
  // We should be checking styles here for whether the
  // element is inline or not.
  CComPtr<IHTMLAnchorElement> anchor;
  HRESULT hr = this->element_->QueryInterface(&anchor);
  if (anchor) {
    return true;
  }

  CComPtr<IHTMLSpanElement> span;
  hr = this->element_->QueryInterface(&span);
  if (span) {
    return true;
  }

  CComPtr<IHTMLLabelElement> label;
  hr = this->element_->QueryInterface(&label);
  if (label) {
    return true;
  }

  return false;
}

bool Element::RectHasNonZeroDimensions(IHTMLRect* rect) {
  LOG(TRACE) << "Entering Element::RectHasNonZeroDimensions";

  long top = 0, bottom = 0, left = 0, right = 0;

  rect->get_top(&top);
  rect->get_left(&left);
  rect->get_bottom(&bottom);
  rect->get_right(&right);

  long w = right - left;
  long h = bottom - top;

  return w > 0 && h > 0;
}

bool Element::AppendFrameDetails(std::vector<LocationInfo>* frame_locations) {
  LOG(TRACE) << "Entering Element::GetFrameDetails";

  if (frame_locations == nullptr) {
    return false;
  }

  CComPtr<IHTMLDocument2> owner_doc;
  int status_code = this->GetContainingDocument(true, &owner_doc);
  if (status_code != WD_SUCCESS) {
    LOG(WARN) << "Unable to get containing document";
    return false;
  }

  CComPtr<IHTMLWindow2> owner_doc_window;
  HRESULT hr = owner_doc->get_parentWindow(&owner_doc_window);
  if (!owner_doc_window) {
    LOG(WARN) << "Unable to get parent window, call to IHTMLDocument2::get_parentWindow failed";
    return false;
  }

  // Get the parent window to the current window, where "current window" is
  // the window containing the parent document of this element. If that parent
  // window exists, and it is not the same as the current window, we assume
  // this element exists inside a frame or iframe. If it is in a frame, get
  // the parent document containing the frame, so we can get the information
  // about the frame or iframe element hosting the document of this element.
  CComPtr<IHTMLWindow2> parent_window;
  hr = owner_doc_window->get_parent(&parent_window);
  if (parent_window && !owner_doc_window.IsEqualObject(parent_window)) {
    LOG(DEBUG) << "Element is in a frame.";
    CComPtr<IHTMLDocument2> parent_doc;
    status_code = this->GetDocumentFromWindow(parent_window, &parent_doc);

    CComPtr<IHTMLFramesCollection2> frames;
    hr = parent_doc->get_frames(&frames);

    long frame_count(0);
    hr = frames->get_length(&frame_count);
    CComVariant index;
    index.vt = VT_I4;
    for (long i = 0; i < frame_count; ++i) {
      // See if the document in each frame is this element's 
      // owner document.
      index.lVal = i;
      CComVariant result;
      hr = frames->item(&index, &result);
      CComPtr<IHTMLWindow2> frame_window;
      result.pdispVal->QueryInterface<IHTMLWindow2>(&frame_window);
      if (!frame_window) {
        // Frame is not an HTML frame.
        continue;
      }

      CComPtr<IHTMLDocument2> frame_doc;
      status_code = this->GetDocumentFromWindow(frame_window, &frame_doc);

      if (frame_doc.IsEqualObject(owner_doc)) {
        // The document in this frame *is* this element's owner
        // document. Get the frameElement property of the document's
        // containing window (which is itself an HTML element, either
        // a frame or an iframe). Then get the x and y coordinates of
        // that frame element.
        // N.B. We must use JavaScript here, as directly using
        // IHTMLWindow4.get_frameElement() returns E_NOINTERFACE under
        // some circumstances.
        LOG(DEBUG) << "Located host frame. Attempting to get hosting element";
        std::wstring script_source = L"(function(){ return function() { return arguments[0].frameElement };})();";
        Script script_wrapper(frame_doc, script_source, 1);
        CComVariant window_variant(frame_window);
        script_wrapper.AddArgument(window_variant);
        status_code = script_wrapper.Execute();
        CComPtr<IHTMLFrameBase> frame_base;
        if (status_code == WD_SUCCESS) {
          hr = script_wrapper.result().pdispVal->QueryInterface<IHTMLFrameBase>(&frame_base);
          if (FAILED(hr)) {
            LOG(WARN) << "Found the frame element, but could not QueryInterface to IHTMLFrameBase.";
          }
        } else {
          // Can't get the frameElement property, likely because the frames are from different
          // domains. So start at the parent document, and use getElementsByTagName to retrieve
          // all of the iframe elements (if there are no iframe elements, get the frame elements)
          // **** BIG HUGE ASSUMPTION!!! ****
          // The index of the frame from the document.frames collection will correspond to the 
          // index into the collection of iframe/frame elements returned by getElementsByTagName.
          LOG(WARN) << "Attempting to get frameElement via JavaScript failed. "
                    << "This usually means the frame is in a different domain than the parent frame. "
                    << "Browser security against cross-site scripting attacks will not allow this. "
                    << "Attempting alternative method.";
          long collection_count = 0;
          CComPtr<IDispatch> element_dispatch;
          CComPtr<IHTMLDocument3> doc;
          parent_doc->QueryInterface<IHTMLDocument3>(&doc);
          if (doc) {
            LOG(DEBUG) << "Looking for <iframe> elements in parent document.";
            CComBSTR iframe_tag_name = L"iframe";
            CComPtr<IHTMLElementCollection> iframe_collection;
            hr = doc->getElementsByTagName(iframe_tag_name, &iframe_collection);
            hr = iframe_collection->get_length(&collection_count);
            if (collection_count != 0) {
              if (collection_count > index.lVal) {
                LOG(DEBUG) << "Found <iframe> elements in parent document, retrieving element" << index.lVal << ".";
                hr = iframe_collection->item(index, index, &element_dispatch);
                hr = element_dispatch->QueryInterface<IHTMLFrameBase>(&frame_base);
              }
            } else {
              LOG(DEBUG) << "No <iframe> elements, looking for <frame> elements in parent document.";
              CComBSTR frame_tag_name = L"frame";
              CComPtr<IHTMLElementCollection> frame_collection;
              hr = doc->getElementsByTagName(frame_tag_name, &frame_collection);
              hr = frame_collection->get_length(&collection_count);
              if (collection_count > index.lVal) {
                LOG(DEBUG) << "Found <frame> elements in parent document, retrieving element" << index.lVal << ".";
                hr = frame_collection->item(index, index, &element_dispatch);
                hr = element_dispatch->QueryInterface<IHTMLFrameBase>(&frame_base);
              }
            }
          } else {
            LOG(WARN) << "QueryInterface of parent document to IHTMLDocument3 failed.";
          }
        }

        if (frame_base) {
          LOG(DEBUG) << "Successfully found frame hosting element";
          LocationInfo frame_doc_info;
          bool doc_dimensions_success = DocumentHost::GetDocumentDimensions(
              frame_doc,
              &frame_doc_info);

          // Wrap the element so we can find its location. Note that
          // GetLocation() may recursively call into this method.
          CComPtr<IHTMLElement> frame_element;
          frame_base->QueryInterface<IHTMLElement>(&frame_element);
          Element element_wrapper(frame_element, this->containing_window_handle_);
          CComPtr<IHTMLStyle> style;
          frame_element->get_style(&style);

          LocationInfo frame_location = {};
          status_code = element_wrapper.GetLocation(&frame_location,
                                                    frame_locations);

          if (status_code == WD_SUCCESS) {
            // Take the border of the frame element into account.
            // N.B. We don't have to do this for non-frame elements,
            // because the border is part of the hit-test region. For
            // finding offsets to get absolute position of elements 
            // within frames, the origin of the frame document is offset
            // by the border width.
            CComPtr<IHTMLElement2> border_width_element;
            frame_element->QueryInterface<IHTMLElement2>(&border_width_element);

            long left_border_width = 0;
            border_width_element->get_clientLeft(&left_border_width);
            frame_location.x += left_border_width;

            long top_border_width = 0;
            border_width_element->get_clientTop(&top_border_width);
            frame_location.y += top_border_width;

            // Take into account the presence of scrollbars in the frame.
            if (doc_dimensions_success) {
              if (frame_doc_info.height > frame_location.height) {
                int horizontal_scrollbar_height = ::GetSystemMetrics(SM_CYHSCROLL);
                frame_location.height -= horizontal_scrollbar_height;
              }
              if (frame_doc_info.width > frame_location.width) {
                int vertical_scrollbar_width = ::GetSystemMetrics(SM_CXVSCROLL);
                frame_location.width -= vertical_scrollbar_width;
              }
            }
            frame_locations->push_back(frame_location);
          }
          return true;
        }
      }
    }
  }

  // If we reach here, the element isn't in a frame/iframe.
  return false;
}

bool Element::GetClickableViewPortLocation(const bool document_contains_frames, LocationInfo* location) {
  LOG(TRACE) << "Entering Element::GetClickableViewPortLocation";

  WINDOWINFO window_info;
  window_info.cbSize = sizeof(WINDOWINFO);
  BOOL get_window_info_result = ::GetWindowInfo(this->containing_window_handle_, &window_info);
  if (get_window_info_result == FALSE) {
    LOGERR(WARN) << "Cannot determine size of window, call to GetWindowInfo API failed";
    return false;
  }

  long window_width = window_info.rcClient.right - window_info.rcClient.left;
  long window_height = window_info.rcClient.bottom - window_info.rcClient.top;

  // If we're not on the top-level document, we can assume that the view port
  // includes the entire client window, since scrollIntoView should do the
  // right thing and make it visible. Otherwise, we prefer getting the view
  // port size by either getting the window.innerWidth and .innerHeight, or
  // by using documentElement.clientHeight and .clientWidth.
  if (!document_contains_frames) {
    CComPtr<IHTMLDocument2> doc;
    int status_code = this->GetContainingDocument(false, &doc);
    if (status_code == WD_SUCCESS) {
      bool used_window_properties = false;
      CComPtr<IHTMLWindow2> parent_window;
      HRESULT hr = doc->get_parentWindow(&parent_window);
      if (SUCCEEDED(hr) && parent_window) {
        CComPtr<IHTMLWindow7> window;
        hr = parent_window->QueryInterface<IHTMLWindow7>(&window);
        if (SUCCEEDED(hr) && window) {
          window->get_innerHeight(&window_height);
          window->get_innerWidth(&window_width);
          used_window_properties = true;
        }
      }

      // If using the window object's innerWidth and innerHeight properties
      // failed, then fall back to the document element's clientWidth and
      // clientHeight properties.
      if (!used_window_properties) {
        int document_mode = DocumentHost::GetDocumentMode(doc);
        CComPtr<IHTMLDocument3> document_element_doc;
        CComPtr<IHTMLElement> document_element;
        hr = doc->QueryInterface<IHTMLDocument3>(&document_element_doc);
        if (SUCCEEDED(hr) && document_element_doc) {
          hr = document_element_doc->get_documentElement(&document_element);
        }
        if (SUCCEEDED(hr) && document_mode > 5 && document_element) {
          CComPtr<IHTMLElement2> size_element;
          hr = document_element->QueryInterface<IHTMLElement2>(&size_element);
          size_element->get_clientHeight(&window_height);
          size_element->get_clientWidth(&window_width);
        } else {
          // This branch is only included if getting documentElement fails.
          LOG(WARN) << "Document containing element does not contains frames, "
                    << "but getting the documentElement property failed, or the "
                    << "doctype has thrown the browser into pre-IE6 rendering. "
                    << "The view port calculation may be inaccurate";
          LocationInfo document_info;
          DocumentHost::GetDocumentDimensions(doc, &document_info);
          if (document_info.height > window_height) {
            int vertical_scrollbar_width = ::GetSystemMetrics(SM_CXVSCROLL);
            window_width -= vertical_scrollbar_width;
          }
          if (document_info.width > window_width) {
            int horizontal_scrollbar_height = ::GetSystemMetrics(SM_CYHSCROLL);
            window_height -= horizontal_scrollbar_height;
          }
        }
      }
    }
  }

  // Hurrah! Now we know what the visible area of the viewport is
  // N.B. There is an n-pixel sized area next to the client area border
  // where clicks are interpreted as a click on the window border, not
  // within the client area. Some clicks may fail if they are close enough
  // to the border.
  location->width = window_width;
  location->height = window_height;
  return true;
}

LocationInfo Element::CalculateClickPoint(const LocationInfo location, const bool document_contains_frames) {
  LOG(TRACE) << "Entering Element::CalculateClickPoint";

  long corrected_width = location.width;
  long corrected_height = location.height;
  long corrected_x = location.x;
  long corrected_y = location.y;

  LocationInfo clickable_viewport = {};
  bool result = this->GetClickableViewPortLocation(document_contains_frames,
                                                   &clickable_viewport);

  if (result) {
    // TODO: Handle the case where the center of the target element
    // is already in the view port. The code would look something like
    // the following:
    // If the center of the target element is already in the view port,
    // we don't need to adjust to find the "in view center point."
    // Technically, this is a deliberate violation of the spec.
    //long element_center_x = location.x + static_cast<long>(floor(location.width / 2.0));
    //long element_center_y = location.y + static_cast<long>(floor(location.height / 2.0));
    //if (element_center_x < 0 ||
    //    element_center_x >= clickable_viewport.width ||
    //    element_center_y < 0 ||
    //    element_center_y >= clickable_viewport.height) {
    RECT element_rect;
    element_rect.left = location.x;
    element_rect.top = location.y;
    element_rect.right = location.x + location.width;
    element_rect.bottom = location.y + location.height;

    RECT viewport_rect;
    viewport_rect.left = clickable_viewport.x;
    viewport_rect.top = clickable_viewport.y;
    viewport_rect.right = clickable_viewport.x + clickable_viewport.width;
    viewport_rect.bottom = clickable_viewport.y + clickable_viewport.height;

    RECT intersect_rect;
    BOOL is_intersecting = ::IntersectRect(&intersect_rect,
      &element_rect,
      &viewport_rect);
    if (is_intersecting) {
      corrected_width = intersect_rect.right - intersect_rect.left;
      corrected_height = intersect_rect.bottom - intersect_rect.top;
      // If the x or y coordinate is greater than or equal to zero, the
      // initial location will already be correct, and not need to be
      // adjusted.
      if (location.x < 0) {
        corrected_x = 0;
      }
      if (location.y < 0) {
        corrected_y = 0;
      }
    }
  }

  LocationInfo click_location = {};  
  click_location.x = corrected_x + static_cast<long>(floor(corrected_width / 2.0));
  click_location.y = corrected_y + static_cast<long>(floor(corrected_height / 2.0));
  return click_location;
}

bool Element::IsLocationInViewPort(const LocationInfo location, const bool document_contains_frames) {
  LOG(TRACE) << "Entering Element::IsLocationInViewPort";

  LocationInfo clickable_viewport = {};
  bool result = this->GetClickableViewPortLocation(document_contains_frames, &clickable_viewport);
  if (!result) {
    // problem is already logged, so just return 
    return false;
  }

  if (location.x < 0 || location.x >= clickable_viewport.width) {
    LOG(WARN) << "X coordinate is out of element area";
    return false;
  }

  // And in the Y?
  if (location.y < 0 || location.y >= clickable_viewport.height) {
    LOG(WARN) << "Y coordinate is out of element area";
    return false;
  }

  return true;
}

int Element::GetContainingDocument(const bool use_dom_node,
                                   IHTMLDocument2** doc) {
  LOG(TRACE) << "Entering Element::GetContainingDocument";

  HRESULT hr = S_OK;
  CComPtr<IDispatch> dispatch_doc;

  if (use_dom_node) {
    CComPtr<IHTMLDOMNode2> node;
    hr = this->element_->QueryInterface(&node);
    if (FAILED(hr)) {
      LOGHR(WARN, hr) << "Unable to cast element to IHTMLDomNode2";
      return ENOSUCHDOCUMENT;
    }

    hr = node->get_ownerDocument(&dispatch_doc);
    if (FAILED(hr)) {
      LOGHR(WARN, hr) << "Unable to locate owning document, call to IHTMLDOMNode2::get_ownerDocument failed";
      return ENOSUCHDOCUMENT;
    }
  } else {
    hr = this->element_->get_document(&dispatch_doc);
    if (FAILED(hr)) {
      LOGHR(WARN, hr) << "Unable to locate document property, call to IHTMLELement::get_document failed";
      return ENOSUCHDOCUMENT;
    }
  }

  try {
    hr = dispatch_doc.QueryInterface<IHTMLDocument2>(doc);
    if (FAILED(hr)) {
      LOGHR(WARN, hr) << "Found document but it's not the expected type (IHTMLDocument2)";
      return ENOSUCHDOCUMENT;
    }
  } catch(...) {
    LOG(WARN) << "Found document but it's not the expected type (IHTMLDocument2)";
    return ENOSUCHDOCUMENT;
  }

  return WD_SUCCESS;
}

int Element::GetDocumentFromWindow(IHTMLWindow2* parent_window,
                                   IHTMLDocument2** parent_doc) {
  LOG(TRACE) << "Entering Element::GetParentDocument";

  HRESULT hr = parent_window->get_document(parent_doc);
  if (FAILED(hr)) {
    if (hr == E_ACCESSDENIED) {
      // Cross-domain documents may throw Access Denied. If so,
      // get the document through the IWebBrowser2 interface.
      CComPtr<IServiceProvider> service_provider;
      hr = parent_window->QueryInterface<IServiceProvider>(&service_provider);
      if (FAILED(hr)) {
        LOGHR(WARN, hr) << "Unable to get browser, call to IHTMLWindow2::QueryInterface failed for IServiceProvider";
        return ENOSUCHDOCUMENT;
      }
      CComPtr<IWebBrowser2> window_browser;
      hr = service_provider->QueryService(IID_IWebBrowserApp, &window_browser);
      if (FAILED(hr)) {
        LOGHR(WARN, hr) << "Unable to get browser, call to IServiceProvider::QueryService failed for IID_IWebBrowserApp";
        return ENOSUCHDOCUMENT;
      }
      CComPtr<IDispatch> parent_doc_dispatch;
      hr = window_browser->get_Document(&parent_doc_dispatch);
      if (FAILED(hr)) {
        LOGHR(WARN, hr) << "Unable to get document, call to IWebBrowser2::get_Document failed";
        return ENOSUCHDOCUMENT;
      }
      try {
        hr = parent_doc_dispatch->QueryInterface<IHTMLDocument2>(parent_doc);
        if (FAILED(hr)) {
          LOGHR(WARN, hr) << "Unable to get document, QueryInterface for IHTMLDocument2 failed";
          return ENOSUCHDOCUMENT;
        }
      } catch(...) {
        LOG(WARN) << "Unable to get document, exception thrown attempting to QueryInterface for IHTMLDocument2";
        return ENOSUCHDOCUMENT;
      }
    } else {
      LOGHR(WARN, hr) << "Unable to get document, IHTMLWindow2::get_document failed with error code other than E_ACCESSDENIED";
      return ENOSUCHDOCUMENT;
    }
  }
  return WD_SUCCESS;
}

bool Element::IsAttachedToDom() {
  // Verify that the element is still valid by getting the document
  // element and calling IHTMLElement::contains() to see if the document
  // contains this element.
  if (this->element_) {
    CComPtr<IHTMLDOMNode2> node;
    HRESULT hr = this->element_->QueryInterface<IHTMLDOMNode2>(&node);
    if (FAILED(hr)) {
      LOGHR(WARN, hr) << "Unable to cast element to IHTMLDomNode2";
      return false;
    }

    CComPtr<IDispatch> dispatch_doc;
    hr = node->get_ownerDocument(&dispatch_doc);
    if (FAILED(hr)) {
      LOGHR(WARN, hr) << "Unable to locate owning document, call to IHTMLDOMNode2::get_ownerDocument failed";
      return false;
    }

    if (dispatch_doc) {
      CComPtr<IHTMLDocument3> doc;
      hr = dispatch_doc.QueryInterface<IHTMLDocument3>(&doc);
      if (FAILED(hr)) {
        LOGHR(WARN, hr) << "Found document but it's not the expected type (IHTMLDocument3)";
        return false;
      }

      CComPtr<IHTMLElement> document_element;
      hr = doc->get_documentElement(&document_element);
      if (FAILED(hr)) {
        LOGHR(WARN, hr) << "Unable to locate document element, call to IHTMLDocument3::get_documentElement failed";
        return false;
      }

      if (document_element) {
        VARIANT_BOOL contains(VARIANT_FALSE);
        hr = document_element->contains(this->element_, &contains);
        if (FAILED(hr)) {
          LOGHR(WARN, hr) << "Call to IHTMLElement::contains failed";
          return false;
        }

        return contains == VARIANT_TRUE;
      }
    }
  }
  return false;
}

bool Element::IsDocumentFocused(IHTMLDocument2* focused_doc) {
  CComPtr<IDispatch> parent_doc_dispatch;
  this->element_->get_document(&parent_doc_dispatch);

  if (parent_doc_dispatch.IsEqualObject(focused_doc)) {
    return true;
  } else {
    LOG(WARN) << "Found managed element's document is not currently focused";
  }
  return false;
}

bool Element::HasFirstChildTextNodeOfMultipleChildren() {
  CComPtr<IHTMLDOMNode> element_node;
  HRESULT hr = this->element_.QueryInterface<IHTMLDOMNode>(&element_node);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "QueryInterface for IHTMLDOMNode on element failed.";
    return false;
  }

  CComPtr<IDispatch> child_nodes_dispatch;
  hr = element_node->get_childNodes(&child_nodes_dispatch);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Call to get_childNodes on element failed.";
    return false;
  }

  CComPtr<IHTMLDOMChildrenCollection> child_nodes;
  hr = child_nodes_dispatch.QueryInterface<IHTMLDOMChildrenCollection>(&child_nodes);

  long length = 0;
  hr = child_nodes->get_length(&length);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Call to get_length on child nodes collection failed.";
    return false;
  }

  // If the element has no children, then it has no single text node child.
  // If the element has only one child, then the element itself should be seen
  // as the correct size by the caller. Only in the case where we have multiple
  // children, and the first is a text element containing non-whitespace text
  // should we have to worry about using the text node as the focal point.
  if (length > 1) {
    CComPtr<IDispatch> child_dispatch;
    hr = child_nodes->item(0, &child_dispatch);
    if (FAILED(hr)) {
      LOGHR(WARN, hr) << "Call to item(0) on child nodes collection failed.";
      return false;
    }

    CComPtr<IHTMLDOMNode> child_node;
    hr = child_dispatch.QueryInterface<IHTMLDOMNode>(&child_node);
    if (FAILED(hr)) {
      LOGHR(WARN, hr) << "QueryInterface for IHTMLDOMNode on child node failed.";
      return false;
    }

    long node_type = 0;
    hr = child_node->get_nodeType(&node_type);
    if (FAILED(hr)) {
      LOGHR(WARN, hr) << "Call to get_nodeType on child node failed.";
      return false;
    }

    if (node_type == 3) {
      CComVariant node_value;
      hr = child_node->get_nodeValue(&node_value);
      if (FAILED(hr)) {
        LOGHR(WARN, hr) << "Call to get_nodeValue on child node failed.";
        return false;
      }

      if (node_value.vt != VT_BSTR) {
        // nodeValue is not a string.
        return false;
      }

      CComBSTR bstr = node_value.bstrVal;
      std::wstring node_text = node_value.bstrVal;
      if (StringUtilities::Trim(node_text) != L"") {
        // This element has a text node only if the text node
        // contains actual text other than whitespace.
        return true;
      }
    }
  }
  return false;
}

bool Element::GetTextBoundaries(LocationInfo* text_info) {
  CComPtr<IHTMLDocument2> doc;
  this->GetContainingDocument(false, &doc);
  CComPtr<IHTMLElement> body_element;
  HRESULT hr = doc->get_body(&body_element);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Call to get_body on document failed.";
    return false;
  }

  CComPtr<IHTMLBodyElement> body;
  hr = body_element.QueryInterface<IHTMLBodyElement>(&body);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "QueryInterface for IHTMLBodyElement on body element failed.";
    return false;
  }

  CComPtr<IHTMLTxtRange> range;
  hr = body->createTextRange(&range);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Call to createTextRange on body failed.";
    return false;
  }

  hr = range->moveToElementText(this->element_);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Call to moveToElementText on range failed.";
    return false;
  }

  CComPtr<IHTMLTextRangeMetrics> range_metrics;
  hr = range.QueryInterface<IHTMLTextRangeMetrics>(&range_metrics);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "QueryInterface for IHTMLTextRangeMetrics on range failed.";
    return false;
  }

  long height = 0;
  hr = range_metrics->get_boundingHeight(&height);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Call to get_boundingHeight on range metrics failed.";
    return false;
  }

  long width = 0;
  hr = range_metrics->get_boundingWidth(&width);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Call to get_boundingWidth on range metrics failed.";
    return false;
  }

  long top = 0;
  hr = range_metrics->get_offsetTop(&top);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Call to get_offsetTop on range metrics failed.";
    return false;
  }

  long left = 0;
  hr = range_metrics->get_offsetLeft(&left);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Call to get_offsetLeft on range metrics failed.";
    return false;
  }

  text_info->x = left;
  text_info->y = top;
  text_info->height = height;
  text_info->width = width;
  return true;
}

} // namespace webdriver