cpp/iedriver/Alert.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.

#include "Alert.h"

#include <UIAutomation.h>

#include "errorcodes.h"
#include "logging.h"
#include "DocumentHost.h"
#include "StringUtilities.h"
#include "WebDriverConstants.h"

#define INVALID_CONTROL_ID -1

namespace webdriver {

Alert::Alert(std::shared_ptr<DocumentHost> browser, HWND handle) {
  LOG(TRACE) << "Entering Alert::Alert";
  this->browser_ = browser;
  this->alert_handle_ = handle;

  this->is_standard_alert_ = true;
  this->is_standard_control_alert_ = true;
  HWND direct_ui_child = this->GetDirectUIChild();
  if (direct_ui_child) {
    this->is_standard_control_alert_ = false;
    DialogButtonInfo cancel_button_info = this->GetDialogButton(CANCEL);
    if (cancel_button_info.button_exists) {
      this->is_standard_alert_ = !IsLinkButton(cancel_button_info.button_handle);
    } else {
      DialogButtonInfo ok_button_info = this->GetDialogButton(OK);
      if (ok_button_info.button_exists) {
        this->is_standard_alert_ = !IsLinkButton(ok_button_info.button_handle);
      } else {
        this->is_standard_alert_ = false;
      }
    }
  }

  std::vector<char> window_class(30);
  ::GetClassNameA(handle, &window_class[0], 30);

  if (strcmp(&window_class[0], SECURITY_DIALOG_WINDOW_CLASS) == 0) {
    this->is_standard_alert_ = false;
    this->is_standard_control_alert_ = false;
    this->is_security_alert_ = true;
  } else {
    std::vector<HWND> text_boxes;
    ::EnumChildWindows(this->alert_handle_,
                      &Alert::FindTextBoxes,
                      reinterpret_cast<LPARAM>(&text_boxes));
    this->is_security_alert_ = text_boxes.size() > 1;
  }
}


Alert::~Alert(void) {
}

int Alert::Accept() {
  LOG(TRACE) << "Entering Alert::Accept";
  DialogButtonInfo button_info = this->GetDialogButton(OK);
  if (!button_info.button_exists) {
    // No OK button on dialog. Look for a cancel button
    // (JavaScript alert() dialogs have a single button, but its ID
    // can be that of a "cancel" button.)
    LOG(INFO) << "OK button does not exist on dialog; looking for Cancel button";
    button_info = this->GetDialogButton(CANCEL);
  }
    
  if (!button_info.button_exists) {
    LOG(WARN) << "OK and Cancel button do not exist on alert";
    return EUNHANDLEDERROR;
  }

  LOG(DEBUG) << "Closing alert using SendMessage";
  int status_code = this->ClickAlertButton(button_info);
  return WD_SUCCESS;
}

int Alert::Dismiss() {
  LOG(TRACE) << "Entering Alert::Dismiss";
  DialogButtonInfo button_info = this->GetDialogButton(CANCEL);
  if (!button_info.button_exists) {
    if (!this->is_standard_control_alert_) {
      // If this is not a standard control alert (i.e., has the
      // "do not create any more dialogs check box"), the use of
      // dialog control IDs won't work, so we have to look explicitly
      // for the OK button.
      button_info = this->GetDialogButton(OK);
    }
  }

  if (!button_info.button_exists) {
    LOG(WARN) << "Cancel button does not exist on alert";
    return EUNHANDLEDERROR;
  }

  // TODO(JimEvans): Check return code and return an appropriate
  // error if the alert didn't get closed properly.
  LOG(DEBUG) << "Closing alert using SendMessage";
  int status_code = this->ClickAlertButton(button_info);
  return WD_SUCCESS;
}

int Alert::SendKeys(const std::string& keys) {
  LOG(TRACE) << "Entering Alert::SendKeys";
  TextBoxFindInfo text_box_find_info;
  text_box_find_info.textbox_handle = NULL;
  text_box_find_info.match_proc = &Alert::IsSimpleEdit;
  return this->SendKeysInternal(keys, &text_box_find_info);
}

int Alert::SetUserName(const std::string& username) {
  LOG(TRACE) << "Entering Alert::SetUserName";
  // If this isn't a security alert, return an error.
  if (!this->is_security_alert_) {
    return EUNEXPECTEDALERTOPEN;
  }
  return this->SendKeys(username);
}

int Alert::SetPassword(const std::string& password) {
  LOG(TRACE) << "Entering Alert::SetPassword";
  // If this isn't a security alert, return an error.
  if (!this->is_security_alert_) {
    return EUNEXPECTEDALERTOPEN;
  }
  TextBoxFindInfo text_box_find_info;
  text_box_find_info.textbox_handle = NULL;
  text_box_find_info.match_proc = &Alert::IsPasswordEdit;
  return this->SendKeysInternal(password, &text_box_find_info);
}

int Alert::SendKeysInternal(const std::string& keys,
                            TextBoxFindInfo* text_box_find_info) {
  LOG(TRACE) << "Entering Alert::SendKeysInternal";
  if (!this->is_standard_alert_) {
    return EUNSUPPORTEDOPERATION;
  }
  // Alert present, find the text box.
  // Retry up to 10 times to find the dialog.
  int max_wait = 10;
  while ((text_box_find_info->textbox_handle == NULL) && --max_wait) {
    ::EnumChildWindows(this->alert_handle_,
                       &Alert::FindTextBox,
                       reinterpret_cast<LPARAM>(text_box_find_info));
    if (text_box_find_info->textbox_handle == NULL) {
      ::Sleep(50);
    }
  }

  if (text_box_find_info->textbox_handle == NULL) {
    LOG(WARN) << "Text box not found on alert";
    return EELEMENTNOTDISPLAYED;
  } else {
    LOG(DEBUG) << "Sending keystrokes to alert using SendMessage";
    std::wstring text = StringUtilities::ToWString(keys);
    ::SendMessage(text_box_find_info->textbox_handle,
                  WM_SETTEXT,
                  NULL,
                  reinterpret_cast<LPARAM>(text.c_str()));
  }
  return WD_SUCCESS;
}

std::string Alert::GetText() {
  LOG(TRACE) << "Entering Alert::GetText";
  std::string alert_text_value = "";
  if (this->is_standard_control_alert_) {
    alert_text_value = this->GetStandardDialogText();
  } else {
    std::string alert_text = this->GetDirectUIDialogText();
    if (!this->is_security_alert_) {
      if (!this->is_standard_alert_) {
        // This means the alert is from onbeforeunload, and we need to
        // strip off everything up to and including the first CR-LF pair.
        size_t first_crlf = alert_text.find("\r\n\r\n");
        if (first_crlf != std::string::npos && first_crlf + 4 < alert_text.size()) {
          alert_text_value = alert_text.substr(first_crlf + 4);
        }
      } else {
        alert_text_value = alert_text;
      }
    }
  }
  return alert_text_value;
}

std::string Alert::GetStandardDialogText() {
  LOG(TRACE) << "Entering Alert::GetStandardDialogText";
  TextLabelFindInfo info;
  info.label_handle = NULL;
  info.control_id_found = 0;
  info.excluded_control_id = 0;

  // Alert present, find the OK button.
  // Retry up to 10 times to find the dialog.
  int max_wait = 10;
  while ((info.label_handle == NULL) && --max_wait) {
    ::EnumChildWindows(this->alert_handle_,
                       &Alert::FindTextLabel,
                       reinterpret_cast<LPARAM>(&info));
    if (info.label_handle == NULL) {
      ::Sleep(50);
    }
  }

  // BIG ASSUMPTION HERE! If we found the text label, assume that
  // all other controls on the alert are fully drawn too.
  TextBoxFindInfo textbox_find_info;
  textbox_find_info.textbox_handle = NULL;
  textbox_find_info.match_proc = &Alert::IsSimpleEdit;
  ::EnumChildWindows(this->alert_handle_,
                     &Alert::FindTextBox,
                     reinterpret_cast<LPARAM>(&textbox_find_info));
  if (textbox_find_info.textbox_handle) {
    // There's a text box on the alert. That means the first
    // label found is the system-provided label. Ignore that
    // one and return the next one.
    info.label_handle = NULL;
    info.excluded_control_id = info.control_id_found;
    info.control_id_found = 0;
    ::EnumChildWindows(this->alert_handle_,
                       &Alert::FindTextLabel,
                       reinterpret_cast<LPARAM>(&info));
  }
  
  std::string alert_text_value;
  if (info.label_handle == NULL) {
    alert_text_value = "";
  } else {
    int text_length = ::GetWindowTextLength(info.label_handle);
    std::vector<wchar_t> text_buffer(text_length + 1);
    ::GetWindowText(info.label_handle, &text_buffer[0], text_length + 1);
    std::wstring alert_text = &text_buffer[0];
    alert_text_value = StringUtilities::ToString(alert_text);
  }
  return alert_text_value;
}

std::string Alert::GetDirectUIDialogText() {
  LOG(TRACE) << "Entering Alert::GetDirectUIDialogText";
  std::string alert_text_value = "";
  HWND direct_ui_child_handle = this->GetDirectUIChild();

  CComPtr<IAccessible> window_object;
  HRESULT hr = ::AccessibleObjectFromWindow(
      direct_ui_child_handle,
      OBJID_WINDOW,
      IID_IAccessible,
      reinterpret_cast<void**>(&window_object));
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Failed to get Active Accessibility window object from dialog";
    return alert_text_value;
  }

  // ASSUMPTION: There is an object with the role of "pane" as a child of
  // the window object.
  CComPtr<IAccessible> pane_object = this->GetChildWithRole(window_object,
                                                            ROLE_SYSTEM_PANE,
                                                            0);
  if (!pane_object) {
    LOG(WARN) << "Failed to get Active Accessibility pane child object from window";
    return alert_text_value;
  }

  int child_index = 0;
  if (!this->is_standard_alert_) {
    // ASSUMPTION: This means the alert is from onbeforeunload, and
    // the second "static text" accessibility object is the one
    // that contains the message.
    child_index = 1;
  }

  CComPtr<IAccessible> message_text_object = this->GetChildWithRole(
      pane_object,
      ROLE_SYSTEM_STATICTEXT,
      child_index);
  if (!message_text_object) {
    LOG(WARN) << "Failed to get Active Accessibility text child object from pane";
    return alert_text_value;
  }

  CComVariant child_id;
  child_id.vt = VT_I4;
  child_id.lVal = CHILDID_SELF;

  CComBSTR text_bstr;
  hr = message_text_object->get_accName(child_id, &text_bstr);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Failed to get accName property from text object";
    return alert_text_value;
  } else if (hr != S_OK) {
    // N.B., get_accName can return an error value without it being a
    // standard COM error.
    LOG(WARN) << "Getting accName property from text object returned an error "
              << "(value: " << hr << "). The text object may not have a name.";
    return alert_text_value;
  } else if (text_bstr == NULL) {
    LOG(WARN) << "Getting accName property from text object returned a null "
              << "value";
    return alert_text_value;
  }

  std::wstring text = text_bstr;
  alert_text_value = StringUtilities::ToString(text);
  return alert_text_value;
}

IAccessible* Alert::GetChildWithRole(IAccessible* parent, long expected_role, int index) {
  LOG(TRACE) << "Entering Alert::GetChildWithRole";
  IAccessible* child = NULL;
  long child_count;
  HRESULT hr = parent->get_accChildCount(&child_count);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Failed to get accChildCount property from Active Accessibility object";
    return child;
  }

  long returned_children = 0;
  std::vector<CComVariant> child_array(child_count);
  hr = ::AccessibleChildren(parent, 0, child_count, &child_array[0], &returned_children);

  int found_index = 0;
  for (long i = 0; i < child_count; ++i) {
    if (child_array[i].vt == VT_DISPATCH) {
      CComPtr<IAccessible> child_object;
      hr = child_array[i].pdispVal->QueryInterface<IAccessible>(&child_object);
      if (FAILED(hr)) {
        LOGHR(WARN, hr) << "QueryInterface for IAccessible failed for child object with index " << i;
      }

      CComVariant child_id;
      child_id.vt = VT_I4;
      child_id.lVal = CHILDID_SELF;

      CComVariant actual_role;
      hr = child_object->get_accRole(child_id, &actual_role);
      if (FAILED(hr)) {
        LOGHR(WARN, hr) << "Failed to get accRole property from Active Accessibility object";
      }

      if (expected_role == actual_role.lVal) {
        if (found_index == index) {
          child = child_object.Detach();
        } else {
          ++found_index;
        }
      }
      LOG(DEBUG) << "accRole for child with index " << i << ": " << actual_role.lVal;
    }
  }
  return child;
}

HWND Alert::GetDirectUIChild() {
  LOG(TRACE) << "Entering Alert::GetDirectUIChild";
  HWND direct_ui_child = NULL;
  ::EnumChildWindows(this->alert_handle_,
                     &Alert::FindDirectUIChild,
                     reinterpret_cast<LPARAM>(&direct_ui_child));
  return direct_ui_child;
}

int Alert::ClickAlertButton(DialogButtonInfo button_info) {
  LOG(TRACE) << "Entering Alert::ClickAlertButton";
  // Click on the appropriate button of the Alert
  if (this->is_standard_control_alert_) {
    ::SendMessage(this->alert_handle_,
                  WM_COMMAND,
                  button_info.button_control_id,
                  NULL);
  } else {
    if (button_info.use_accessibility) {
      int status_code = ClickAlertButtonUsingAccessibility(button_info.accessibility_id);
      if (status_code != WD_SUCCESS) {
        return status_code;
      }
    } else {
      // For non-standard alerts (that is, alerts that are not
      // created by alert(), confirm() or prompt() JavaScript
      // functions), we cheat. Sending the BN_CLICKED notification
      // via WM_COMMAND makes the dialog think that the proper
      // button was clicked, but it's not the same as sending the
      // click message to the button. N.B., sending the BM_CLICK
      // message to the button may fail if the dialog doesn't have
      // focus, so we do it this way. Also, we send the notification
      // to the immediate parent of the button, which, in turn,
      // notifies the top-level dialog.
      ::SendMessage(::GetParent(button_info.button_handle),
                    WM_COMMAND,
                    MAKEWPARAM(0, BN_CLICKED),
                    reinterpret_cast<LPARAM>(button_info.button_handle));
    }
  }
  // Hack to make sure alert is really closed, and browser
  // is ready for the next operation. This may be a flawed
  // algorithim, since the busy property of the browser may
  // not be the right thing to check here.
  int retry_count = 20;
  bool is_alert_handle_valid = (::IsWindow(this->alert_handle_) == TRUE);
  while ((is_alert_handle_valid || this->browser_->IsBusy()) && retry_count > 0) {
    ::Sleep(50);
    is_alert_handle_valid = (::IsWindow(this->alert_handle_) == TRUE);
    retry_count--;
  }

  // TODO(JimEvans): Check for the following error conditions:
  // 1. Alert window still present (::IsWindow(this->alert_handle_) == TRUE)
  // 2. Browser still busy (this->browser_->IsBusy() == true)
  // and return an appropriate non-WD_SUCCESS error code.
  LOG(DEBUG) << "IsWindow() for alert handle 0x" << this->alert_handle_ << ": "
             << is_alert_handle_valid ? "true" : "false";
  return WD_SUCCESS;
}

Alert::DialogButtonInfo Alert::GetDialogButton(BUTTON_TYPE button_type) {
  LOG(TRACE) << "Entering Alert::GetDialogButton";
  // Return the simple version of the struct so that subclasses do not
  // have to know anything about the function pointer definition.
  DialogButtonInfo button_info;
  if (this->is_standard_alert_ || !this->is_security_alert_) {
    DialogButtonFindInfo button_find_info;
    button_find_info.button_handle = NULL;
    button_find_info.button_control_id = this->is_standard_alert_ ? IDOK : INVALID_CONTROL_ID;
    if (button_type == OK) {
      button_find_info.match_proc = &Alert::IsOKButton;
    } else {
      button_find_info.match_proc = &Alert::IsCancelButton;
    }

    int max_wait = 10;
    // Retry up to 10 times to find the dialog.
    while ((button_find_info.button_handle == NULL) && --max_wait) {
      ::EnumChildWindows(this->alert_handle_,
                         &Alert::FindDialogButton,
                         reinterpret_cast<LPARAM>(&button_find_info));
      if (button_find_info.button_handle == NULL) {
        ::Sleep(50);
      } else {
        break;
      }
    }
    button_info.button_handle = button_find_info.button_handle;
    button_info.button_control_id = button_find_info.button_control_id;
    button_info.button_exists = button_find_info.button_handle != NULL;
    button_info.accessibility_id = "";
    button_info.use_accessibility = false;
  } else {
    button_info.button_handle = NULL;
    button_info.button_control_id = 0;
    button_info.button_exists = true;
    button_info.accessibility_id = button_type == OK ? "OKButton" : "CancelButton";
    button_info.use_accessibility = true;
  }

  return button_info;
}

int Alert::ClickAlertButtonUsingAccessibility(const std::string& automation_id) {
  CComPtr<IUIAutomation> ui_automation;
  HRESULT hr = ::CoCreateInstance(CLSID_CUIAutomation,
                                  NULL,
                                  CLSCTX_INPROC_SERVER,
                                  IID_IUIAutomation,
                                  reinterpret_cast<void**>(&ui_automation));

  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Unable to create global UI Automation object";
    return EUNHANDLEDERROR;
  }

  CComPtr<IUIAutomationElement> parent_window;
  hr = ui_automation->ElementFromHandle(this->alert_handle_,
                                        &parent_window);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Unable to get automation object from window handle";
    return EUNHANDLEDERROR;
  }

  CComVariant button_automation_id = automation_id.c_str();
  CComPtr<IUIAutomationCondition> button_condition;
  hr = ui_automation->CreatePropertyCondition(UIA_AutomationIdPropertyId,
                                              button_automation_id,
                                              &button_condition);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Unable to create button finding condition";
    return EUNHANDLEDERROR;
  }

  CComPtr<IUIAutomationElement> button;
  hr = parent_window->FindFirst(TreeScope::TreeScope_Children,
                                button_condition,
                                &button);
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Unable to find button";
    return EUNHANDLEDERROR;
  }

  CComPtr<IUIAutomationInvokePattern> button_invoke_pattern;
  hr = button->GetCurrentPatternAs(UIA_InvokePatternId,
                                   IID_PPV_ARGS(&button_invoke_pattern));
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Unable to get invoke pattern on button";
    return EUNHANDLEDERROR;
  }

  hr = button_invoke_pattern->Invoke();
  if (FAILED(hr)) {
    LOGHR(WARN, hr) << "Unable to invoke button";
    return EUNHANDLEDERROR;
  }

  return WD_SUCCESS;
}

bool Alert::IsOKButton(HWND button_handle) {
  int control_id = ::GetDlgCtrlID(button_handle);
  if (control_id != 0) {
    return control_id == IDOK || control_id == IDYES || control_id == IDRETRY;
  }
  std::vector<wchar_t> button_window_class(100);
  ::GetClassName(button_handle, &button_window_class[0], static_cast<int>(button_window_class.size()));
  if (wcscmp(&button_window_class[0], L"Button") == 0) {
    long window_long = ::GetWindowLong(button_handle, GWL_STYLE);
    long button_style = window_long & BS_TYPEMASK;
    return button_style == BS_DEFCOMMANDLINK || button_style == BS_DEFPUSHBUTTON;
  }
  return false;
}

bool Alert::IsCancelButton(HWND button_handle) {
  int control_id = ::GetDlgCtrlID(button_handle);
  if (control_id != 0) {
    return control_id == IDCANCEL || control_id == IDNO;
  }
  std::vector<wchar_t> button_window_class(100);
  ::GetClassName(button_handle, &button_window_class[0], static_cast<int>(button_window_class.size()));
  if (wcscmp(&button_window_class[0], L"Button") == 0) {
    long window_long = ::GetWindowLong(button_handle, GWL_STYLE);
    long button_style = window_long & BS_TYPEMASK;
    // The BS_DEFCOMMANDLINK mask includes BS_COMMANDLINK, but we
    // want only to match those without the default bits set.
    return button_style == BS_COMMANDLINK || button_style == BS_PUSHBUTTON;
  }
  return false;
}

bool Alert::IsLinkButton(HWND button_handle) {
  std::vector<wchar_t> button_window_class(100);
  ::GetClassName(button_handle, &button_window_class[0], static_cast<int>(button_window_class.size()));
  if (wcscmp(&button_window_class[0], L"Button") == 0) {
    long window_long = ::GetWindowLong(button_handle, GWL_STYLE);
    long button_style = window_long & BS_TYPEMASK;
    return button_style == BS_COMMANDLINK;
  }
  return false;
}

bool Alert::IsSimpleEdit(HWND edit_handle) {
  std::vector<wchar_t> child_window_class(100);
  ::GetClassName(edit_handle, &child_window_class[0], 100);

  if (wcscmp(&child_window_class[0], L"Edit") == 0) {
    long window_long = ::GetWindowLong(edit_handle, GWL_STYLE);
    bool is_read_only = (window_long & ES_READONLY) == ES_READONLY;
    bool is_password = (window_long & ES_PASSWORD) == ES_PASSWORD;
    return !is_read_only && !is_password;
  }
  return false;
}

bool Alert::IsPasswordEdit(HWND edit_handle) {
  std::vector<wchar_t> child_window_class(100);
  ::GetClassName(edit_handle, &child_window_class[0], 100);

  if (wcscmp(&child_window_class[0], L"Edit") == 0) {
    long window_long = ::GetWindowLong(edit_handle, GWL_STYLE);
    bool is_password = (window_long & ES_PASSWORD) == ES_PASSWORD;
    return is_password;
  }
  return false;
}

BOOL CALLBACK Alert::FindDialogButton(HWND hwnd, LPARAM arg) {
  Alert::DialogButtonFindInfo* button_info = reinterpret_cast<Alert::DialogButtonFindInfo*>(arg);
  int control_id = ::GetDlgCtrlID(hwnd);
  if (button_info->match_proc(hwnd)) {
    button_info->button_handle = hwnd;
    button_info->button_control_id = control_id;
    return FALSE;
  }
  return TRUE;
}

BOOL CALLBACK Alert::FindTextBox(HWND hwnd, LPARAM arg) {
  TextBoxFindInfo* find_info = reinterpret_cast<TextBoxFindInfo*>(arg);
  if (find_info->match_proc(hwnd)) {
    find_info->textbox_handle = hwnd;
    return FALSE;
  }
  return TRUE;
}

BOOL CALLBACK Alert::FindTextLabel(HWND hwnd, LPARAM arg) {
  TextLabelFindInfo* find_info = reinterpret_cast<TextLabelFindInfo*>(arg);
  std::vector<wchar_t> child_window_class(100);
  ::GetClassName(hwnd, &child_window_class[0], 100);

  if (wcscmp(&child_window_class[0], L"Static") != 0) {
    return TRUE;
  }

  int control_id = ::GetDlgCtrlID(hwnd);
  int text_length = ::GetWindowTextLength(hwnd);
  if (text_length > 0) {
    if (find_info->excluded_control_id == 0 ||
        control_id != find_info->excluded_control_id) {
      find_info->label_handle = hwnd;
      find_info->control_id_found = control_id;
      return FALSE;
    }
  }
  return TRUE;
}

BOOL CALLBACK Alert::FindDirectUIChild(HWND hwnd, LPARAM arg){
  HWND *dialog_handle = reinterpret_cast<HWND*>(arg);
  std::vector<wchar_t> child_window_class(100);
  ::GetClassName(hwnd, &child_window_class[0], 100);

  if (wcscmp(&child_window_class[0], L"DirectUIHWND") != 0) {
    return TRUE;
  }
  *dialog_handle = hwnd;
  return FALSE;
}

BOOL CALLBACK Alert::FindTextBoxes(HWND hwnd, LPARAM arg) {
  std::vector<HWND>* dialog_handles = reinterpret_cast<std::vector<HWND>*>(arg);
  std::vector<wchar_t> child_window_class(100);
  ::GetClassName(hwnd, &child_window_class[0], 100);

  if (wcscmp(&child_window_class[0], L"Edit") == 0) {
    dialog_handles->push_back(hwnd);
  }
  return TRUE;
}

} // namespace webdriver