C++ BrowserHandle类代码示例

LRESULT IECommandExecutor::OnWait(UINT uMsg,
                                  WPARAM wParam,
                                  LPARAM lParam,
                                  BOOL& bHandled) {
  BrowserHandle browser;
  int status_code = this->GetCurrentBrowser(&browser);
  if (status_code == SUCCESS && !browser->is_closing()) {
    this->is_waiting_ = !(browser->Wait());
    if (this->is_waiting_) {
      // If we are still waiting, we need to wait a bit then post a message to
      // ourselves to run the wait again. However, we can't wait using Sleep()
      // on this thread. This call happens in a message loop, and we would be 
      // unable to process the COM events in the browser if we put this thread
      // to sleep.
      unsigned int thread_id = 0;
      HANDLE thread_handle = reinterpret_cast<HANDLE>(_beginthreadex(NULL,
                                                      0,
                                                      &IECommandExecutor::WaitThreadProc,
                                                      (void *)this->m_hWnd,
                                                      0,
                                                      &thread_id));
      if (thread_handle != NULL) {
        ::CloseHandle(thread_handle);
      }
    }
  } else {
    this->is_waiting_ = false;
  }
  return 0;
}

int ElementFinder::FindElementsByCssSelector(const IESessionWindow& session, const ElementHandle parent_wrapper, const std::wstring& criteria, Json::Value* found_elements) {
	int result = ENOSUCHELEMENT;

	BrowserHandle browser;
	result = session.GetCurrentBrowser(&browser);
	if (result != SUCCESS) {
		return result;
	}

	std::wstring script_source(L"(function() { return function(){");
	script_source += atoms::SIZZLE;
	script_source += L"\n";
	script_source += L"var root = arguments[1] ? arguments[1] : document.documentElement;";
	script_source += L"if (root['querySelectorAll']) { return root.querySelectorAll(arguments[0]); } ";
	script_source += L"var results = []; Sizzle(arguments[0], root, results);";
	script_source += L"return results;";
	script_source += L"};})();";

	CComPtr<IHTMLDocument2> doc;
	browser->GetDocument(&doc);

	Script script_wrapper(doc, script_source, 2);
	script_wrapper.AddArgument(criteria);
	if (parent_wrapper) {
		// Use a copy for the parent element?
		CComPtr<IHTMLElement> parent(parent_wrapper->element());
		IHTMLElement* parent_element_copy;
		HRESULT hr = parent.CopyTo(&parent_element_copy);
		script_wrapper.AddArgument(parent_element_copy);
	}

	result = script_wrapper.Execute();
	CComVariant snapshot = script_wrapper.result();

	std::wstring get_element_count_script = L"(function(){return function() {return arguments[0].length;}})();";
	Script get_element_count_script_wrapper(doc, get_element_count_script, 1);
	get_element_count_script_wrapper.AddArgument(snapshot);
	result = get_element_count_script_wrapper.Execute();
	if (result == SUCCESS) {
		if (!get_element_count_script_wrapper.ResultIsInteger()) {
			result = EUNEXPECTEDJSERROR;
		} else {
			long length = get_element_count_script_wrapper.result().lVal;
			std::wstring get_next_element_script = L"(function(){return function() {return arguments[0][arguments[1]];}})();";
			for (long i = 0; i < length; ++i) {
				Script get_element_script_wrapper(doc, get_next_element_script, 2);
				get_element_script_wrapper.AddArgument(snapshot);
				get_element_script_wrapper.AddArgument(i);
				result = get_element_script_wrapper.Execute();
				Json::Value json_element;
				get_element_script_wrapper.ConvertResultToJsonValue(session, &json_element);
				found_elements->append(json_element);
			}
		}
	}

	return result;
}

void IECommandExecutor::AddManagedBrowser(BrowserHandle browser_wrapper) {
  LOG(TRACE) << "Entering IECommandExecutor::AddManagedBrowser";

  this->managed_browsers_[browser_wrapper->browser_id()] = browser_wrapper;
  if (this->current_browser_id_ == "") {
    LOG(TRACE) << "Setting current browser id to " << browser_wrapper->browser_id();
    this->current_browser_id_ = browser_wrapper->browser_id();
  }
}

int ElementFinder::FindElementUsingSizzle(const IECommandExecutor& executor,
                                          const ElementHandle parent_wrapper,
                                          const std::wstring& criteria,
                                          Json::Value* found_element) {
  LOG(TRACE) << "Entering ElementFinder::FindElementUsingSizzle";

  int result;

  BrowserHandle browser;
  result = executor.GetCurrentBrowser(&browser);
  if (result != WD_SUCCESS) {
    LOG(WARN) << "Unable to get browser";
    return result;
  }

  std::wstring script_source(L"(function() { return function(){ if (!window.Sizzle) {");
  script_source += atoms::asString(atoms::SIZZLE);
  script_source += L"}\n";
  script_source += L"var root = arguments[1] ? arguments[1] : document.documentElement;";
  script_source += L"if (root['querySelector']) { return root.querySelector(arguments[0]); } ";
  script_source += L"var results = []; Sizzle(arguments[0], root, results);";
  script_source += L"return results.length > 0 ? results[0] : null;";
  script_source += L"};})();";

  CComPtr<IHTMLDocument2> doc;
  browser->GetDocument(&doc);
  Script script_wrapper(doc, script_source, 2);
  script_wrapper.AddArgument(criteria);
  if (parent_wrapper) {
    CComPtr<IHTMLElement> parent(parent_wrapper->element());
    script_wrapper.AddArgument(parent);
  }
  result = script_wrapper.Execute();

  if (result == WD_SUCCESS) {
    if (!script_wrapper.ResultIsElement()) {
      LOG(WARN) << "Found result is not element";
      result = ENOSUCHELEMENT;
    } else {
      result = script_wrapper.ConvertResultToJsonValue(executor,
                                                       found_element);
    }
  } else {
    LOG(WARN) << "Unable to find elements";
    result = ENOSUCHELEMENT;
  }

  return result;
}

void IECommandExecutor::DispatchCommand() {
  Response response(this->session_id_);
  CommandHandlerMap::const_iterator found_iterator = 
      this->command_handlers_.find(this->current_command_.command_type());

  if (found_iterator == this->command_handlers_.end()) {
    response.SetErrorResponse(501, "Command not implemented");
  } else {
    BrowserHandle browser;
    int status_code = this->GetCurrentBrowser(&browser);
    if (status_code == SUCCESS) {
      bool alert_is_active = false;
      HWND alert_handle = browser->GetActiveDialogWindowHandle();
      if (alert_handle != NULL) {
        // Found a window handle, make sure it's an actual alert,
        // and not a showModalDialog() window.
        vector<char> window_class_name(34);
        ::GetClassNameA(alert_handle, &window_class_name[0], 34);
        if (strcmp("#32770", &window_class_name[0]) == 0) {
          alert_is_active = true;
        }
      }
      int command_type = this->current_command_.command_type();
      if (alert_is_active &&
          command_type != GetAlertText &&
          command_type != SendKeysToAlert &&
          command_type != AcceptAlert &&
          command_type != DismissAlert) {
        response.SetErrorResponse(EMODALDIALOGOPENED, "Modal dialog present");
        ::SendMessage(alert_handle, WM_COMMAND, IDCANCEL, NULL);
        this->serialized_response_ = response.Serialize();
        return;
      }
    }

	CommandHandlerHandle command_handler = found_iterator->second;
    command_handler->Execute(*this, this->current_command_, &response);

    status_code = this->GetCurrentBrowser(&browser);
    if (status_code == SUCCESS) {
      this->is_waiting_ = browser->wait_required();
      if (this->is_waiting_) {
        ::PostMessage(this->m_hWnd, WD_WAIT, NULL, NULL);
      }
    }
  }

  this->serialized_response_ = response.Serialize();
}

int ElementFinder::FindElement(const IESessionWindow& session, const ElementHandle parent_wrapper, const std::wstring& mechanism, const std::wstring& criteria, Json::Value* found_element) {
	BrowserHandle browser;
	int status_code = session.GetCurrentBrowser(&browser);
	if (status_code == SUCCESS) {
		if (mechanism == L"css") {
			return this->FindElementByCssSelector(session, parent_wrapper, criteria, found_element);
		} else if (mechanism == L"xpath") {
			return this->FindElementByXPath(session, parent_wrapper, criteria, found_element);
		} else {
			std::wstring criteria_object_script = L"(function() { return function(){ return  { \"" + mechanism + L"\" : \"" + criteria + L"\" }; };})();";
			CComPtr<IHTMLDocument2> doc;
			browser->GetDocument(&doc);

			Script criteria_wrapper(doc, criteria_object_script, 0);
			status_code = criteria_wrapper.Execute();
			if (status_code == SUCCESS) {
				CComVariant criteria_object;
				HRESULT hr = ::VariantCopy(&criteria_object, &criteria_wrapper.result());

				// 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::FIND_ELEMENT;
				script_source += L")})();";

				Script script_wrapper(doc, script_source, 2);
				script_wrapper.AddArgument(criteria_object);
				if (parent_wrapper) {
					script_wrapper.AddArgument(parent_wrapper->element());
				}

				status_code = script_wrapper.Execute();
				if (status_code == SUCCESS && script_wrapper.ResultIsElement()) {
					script_wrapper.ConvertResultToJsonValue(session, found_element);
				} else {
					status_code = ENOSUCHELEMENT;
				}
			} else {
				status_code = ENOSUCHELEMENT;
			}
		}
	}
	return status_code;
}

int ElementFinder::FindElementByXPath(const IESessionWindow& session, const ElementHandle parent_wrapper, const std::wstring& criteria, Json::Value* found_element) {
	int result = ENOSUCHELEMENT;

	BrowserHandle browser;
	result = session.GetCurrentBrowser(&browser);
	if (result != SUCCESS) {
		return result;
	}

	result = this->InjectXPathEngine(browser);
	// TODO(simon): Why does the injecting sometimes fail?
	if (result != SUCCESS) {
		return result;
	}

	// Call it
	std::wstring query;
	if (parent_wrapper) {
		query += L"(function() { return function(){var res = document.__webdriver_evaluate(arguments[0], arguments[1], null, 7, null); return res.snapshotItem(0) ;};})();";
	} else {
		query += L"(function() { return function(){var res = document.__webdriver_evaluate(arguments[0], document, null, 7, null); return res.snapshotLength != 0 ? res.snapshotItem(0) : undefined ;};})();";
	}

	CComPtr<IHTMLDocument2> doc;
	browser->GetDocument(&doc);
	Script script_wrapper(doc, query, 2);
	script_wrapper.AddArgument(criteria);
	if (parent_wrapper) {
		CComPtr<IHTMLElement> parent(parent_wrapper->element());
		IHTMLElement* parent_element_copy;
		HRESULT hr = parent.CopyTo(&parent_element_copy);
		script_wrapper.AddArgument(parent_element_copy);
	}
	result = script_wrapper.Execute();

	if (result == SUCCESS) {
		if (!script_wrapper.ResultIsElement()) {
			result = ENOSUCHELEMENT;
		} else {
			result = script_wrapper.ConvertResultToJsonValue(session, found_element);
		}
	}

	return result;
}

  HRESULT ScreenshotCommandHandler::CaptureViewport(BrowserHandle browser) {
    LOG(TRACE) << "Entering ScreenshotCommandHandler::CaptureViewport";

    HWND content_window_handle = browser->GetContentWindowHandle();
    int content_width = 0, content_height = 0;

    this->GetWindowDimensions(content_window_handle, &content_width, &content_height);
    CaptureWindow(content_window_handle, content_width, content_height);

    return S_OK;
  }

LRESULT IECommandExecutor::OnWait(UINT uMsg,
                                  WPARAM wParam,
                                  LPARAM lParam,
                                  BOOL& bHandled) {
  LOG(TRACE) << "Entering IECommandExecutor::OnWait";

  BrowserHandle browser;
  int status_code = this->GetCurrentBrowser(&browser);
  if (status_code == WD_SUCCESS && !browser->is_closing()) {
    if (this->page_load_timeout_ >= 0 && this->wait_timeout_ < clock()) {
      Response timeout_response;
      timeout_response.SetErrorResponse(ETIMEOUT, "Timed out waiting for page to load.");
      this->serialized_response_ = timeout_response.Serialize();
      this->is_waiting_ = false;
      browser->set_wait_required(false);
    } else {
      this->is_waiting_ = !(browser->Wait());
      if (this->is_waiting_) {
        // If we are still waiting, we need to wait a bit then post a message to
        // ourselves to run the wait again. However, we can't wait using Sleep()
        // on this thread. This call happens in a message loop, and we would be 
        // unable to process the COM events in the browser if we put this thread
        // to sleep.
        unsigned int thread_id = 0;
        HANDLE thread_handle = reinterpret_cast<HANDLE>(_beginthreadex(NULL,
                                                        0,
                                                        &IECommandExecutor::WaitThreadProc,
                                                        (void *)this->m_hWnd,
                                                        0,
                                                        &thread_id));
        if (thread_handle != NULL) {
          ::CloseHandle(thread_handle);
        }
      }
    }
  } else {
    this->is_waiting_ = false;
  }
  return 0;
}

int ElementFinder::FindElementByCssSelector(const IESessionWindow& session, const ElementHandle parent_wrapper, const std::wstring& criteria, Json::Value* found_element) {
	int result = ENOSUCHELEMENT;

	BrowserHandle browser;
	result = session.GetCurrentBrowser(&browser);
	if (result != SUCCESS) {
		return result;
	}

	std::wstring script_source(L"(function() { return function(){");
	script_source += atoms::SIZZLE;
	script_source += L"\n";
	script_source += L"var root = arguments[1] ? arguments[1] : document.documentElement;";
	script_source += L"if (root['querySelector']) { return root.querySelector(arguments[0]); } ";
	script_source += L"var results = []; Sizzle(arguments[0], root, results);";
	script_source += L"return results.length > 0 ? results[0] : null;";
	script_source += L"};})();";

	CComPtr<IHTMLDocument2> doc;
	browser->GetDocument(&doc);
	Script script_wrapper(doc, script_source, 2);
	script_wrapper.AddArgument(criteria);
	if (parent_wrapper) {
		CComPtr<IHTMLElement> parent(parent_wrapper->element());
		IHTMLElement* parent_element_copy;
		HRESULT hr = parent.CopyTo(&parent_element_copy);
		script_wrapper.AddArgument(parent_element_copy);
	}
	result = script_wrapper.Execute();

	if (result == SUCCESS) {
		if (!script_wrapper.ResultIsElement()) {
			result = ENOSUCHELEMENT;
		} else {
			result = script_wrapper.ConvertResultToJsonValue(session, found_element);
		}
	}

	return result;
}

void IESessionWindow::DispatchCommand() {
	std::string session_id = CW2A(this->session_id_.c_str(), CP_UTF8);
	Response response(session_id);
	CommandHandlerMap::const_iterator found_iterator = this->command_handlers_.find(this->current_command_.command_value());

	if (found_iterator == this->command_handlers_.end()) {
		response.SetErrorResponse(501, "Command not implemented");
	} else {
		CommandHandlerHandle command_handler = found_iterator->second;
		command_handler->Execute(*this, this->current_command_, &response);

		BrowserHandle browser;
		int status_code = this->GetCurrentBrowser(&browser);
		if (status_code == SUCCESS) {
			this->is_waiting_ = browser->wait_required();
			if (this->is_waiting_) {
				::PostMessage(this->m_hWnd, WD_WAIT, NULL, NULL);
			}
		}
	}

	this->serialized_response_ = response.Serialize();
}

int ElementFinder::InjectXPathEngine(BrowserHandle browser_wrapper) {
	// Inject the XPath engine
	std::wstring script_source;
	for (int i = 0; XPATHJS[i]; i++) {
		script_source += XPATHJS[i];
	}

	CComPtr<IHTMLDocument2> doc;
	browser_wrapper->GetDocument(&doc);
	Script script_wrapper(doc, script_source, 0);
	int status_code = script_wrapper.Execute();

	return status_code;
}

int ClickElementCommandHandler::ExecuteAtom(
    const std::wstring& atom_script_source,
    BrowserHandle browser_wrapper,
    ElementHandle element_wrapper,
    std::string* error_msg) {
  CComPtr<IHTMLDocument2> doc;
  browser_wrapper->GetDocument(&doc);
  Script script_wrapper(doc, atom_script_source, 1);
  script_wrapper.AddArgument(element_wrapper);
  int status_code = script_wrapper.ExecuteAsync(ASYNC_SCRIPT_EXECUTION_TIMEOUT_IN_MILLISECONDS);
  if (status_code != WD_SUCCESS) {
    if (script_wrapper.ResultIsString()) {
      std::wstring error = script_wrapper.result().bstrVal;
      *error_msg = StringUtilities::ToString(error);
    } else {
      std::string error = "Executing JavaScript click function returned an";
      error.append(" unexpected error, but no error could be returned from");
      error.append(" Internet Explorer's JavaScript engine.");
      *error_msg = error;
    }
  }
  return status_code;
}

void IESessionWindow::AddManagedBrowser(BrowserHandle browser_wrapper) {
	this->managed_browsers_[browser_wrapper->browser_id()] = browser_wrapper;
	if (this->current_browser_id_ == L"") {
		this->current_browser_id_ = browser_wrapper->browser_id();
	}
}

void IECommandExecutor::AddManagedBrowser(BrowserHandle browser_wrapper) {
  this->managed_browsers_[browser_wrapper->browser_id()] = browser_wrapper;
  if (this->current_browser_id_ == "") {
    this->current_browser_id_ = browser_wrapper->browser_id();
  }
}