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;

this->element_ = element;

this->element_id_ = element_id;

this->containing_window_handle_ = containing_window_handle;

LOG(TRACE) << "Entering Element::ConvertToJson";

Json::Value json_wrapper;

json_wrapper[JSON_ELEMENT_PROPERTY_NAME] = this->element_id_;

return json_wrapper;

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;

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;

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;

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;

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;

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;

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;

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);

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;

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;

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;

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;

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;

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;

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;

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;

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;

}

}

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;

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;

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;

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;

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;

}

// 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;

}

}

}

}

}

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;

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;

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;

}