| // 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 "Browser.h" | |
| #include <comutil.h> | |
| #include <ShlGuid.h> | |
| #include "errorcodes.h" | |
| #include "logging.h" | |
| #include "Alert.h" | |
| #include "BrowserFactory.h" | |
| #include "CustomTypes.h" | |
| #include "messages.h" | |
| #include "HookProcessor.h" | |
| #include "Script.h" | |
| #include "StringUtilities.h" | |
| #include "WebDriverConstants.h" | |
| #include "WindowUtilities.h" | |
| namespace webdriver { | |
| Browser::Browser(IWebBrowser2* browser, HWND hwnd, HWND session_handle, bool is_edge_chromium) : DocumentHost(hwnd, session_handle) { | |
| LOG(TRACE) << "Entering Browser::Browser"; | |
| this->is_explicit_close_requested_ = false; | |
| this->is_navigation_started_ = false; | |
| this->browser_ = browser; | |
| this->AttachEvents(); | |
| this->set_is_edge_chromium(is_edge_chromium); | |
| } | |
| Browser::~Browser(void) { | |
| this->DetachEvents(); | |
| } | |
| void __stdcall Browser::BeforeNavigate2(IDispatch* pObject, | |
| VARIANT* pvarUrl, | |
| VARIANT* pvarFlags, | |
| VARIANT* pvarTargetFrame, | |
| VARIANT* pvarData, | |
| VARIANT* pvarHeaders, | |
| VARIANT_BOOL* pbCancel) { | |
| LOG(TRACE) << "Entering Browser::BeforeNavigate2"; | |
| std::wstring url(pvarUrl->bstrVal); | |
| LOG(DEBUG) << "BeforeNavigate2: Url: " << LOGWSTRING(url) << ", TargetFrame: " << pvarTargetFrame->bstrVal; | |
| } | |
| void __stdcall Browser::OnQuit() { | |
| LOG(TRACE) << "Entering Browser::OnQuit"; | |
| if (!this->is_explicit_close_requested_) { | |
| if (this->is_awaiting_new_process()) { | |
| LOG(WARN) << "A new browser process was requested. This means a Protected " | |
| << "Mode boundary has been crossed, and that future commands to " | |
| << "the current browser instance will fail. The driver will " | |
| << "attempt to reconnect to the newly created browser object, " | |
| << "but there is no guarantee it will work."; | |
| DWORD process_id; | |
| HWND window_handle = this->GetBrowserWindowHandle(); | |
| ::GetWindowThreadProcessId(window_handle, &process_id); | |
| BrowserReattachInfo* info = new BrowserReattachInfo; | |
| info->browser_id = this->browser_id(); | |
| info->current_process_id = process_id; | |
| info->known_process_ids = this->known_process_ids_; | |
| this->DetachEvents(); | |
| this->browser_ = NULL; | |
| ::PostMessage(this->executor_handle(), | |
| WD_BROWSER_REATTACH, | |
| NULL, | |
| reinterpret_cast<LPARAM>(info)); | |
| return; | |
| } else { | |
| LOG(WARN) << "This instance of Internet Explorer (" << this->browser_id() | |
| << ") is exiting without an explicit request to close it. " | |
| << "Unless you clicked a link that specifically attempts to " | |
| << "close the page, that likely means a Protected Mode " | |
| << "boundary has been crossed (either entering or exiting " | |
| << "Protected Mode). It is highly likely that any subsequent " | |
| << "commands to this driver instance will fail. THIS IS NOT A " | |
| << "BUG IN THE IE DRIVER! Fix your code and/or browser " | |
| << "configuration so that a Protected Mode boundary is not " | |
| << "crossed."; | |
| } | |
| } | |
| this->PostQuitMessage(); | |
| } | |
| void __stdcall Browser::NewProcess(DWORD lCauseFlag, | |
| IDispatch* pWB2, | |
| VARIANT_BOOL* pbCancel) { | |
| LOG(TRACE) << "Entering Browser::NewProcess"; | |
| this->InitiateBrowserReattach(); | |
| } | |
| void __stdcall Browser::NewWindow3(IDispatch** ppDisp, | |
| VARIANT_BOOL* pbCancel, | |
| DWORD dwFlags, | |
| BSTR bstrUrlContext, | |
| BSTR bstrUrl) { | |
| LOG(TRACE) << "Entering Browser::NewWindow3"; | |
| ::PostMessage(this->executor_handle(), WD_BEFORE_NEW_WINDOW, NULL, NULL); | |
| std::vector<HWND>* ie_window_handles = nullptr; | |
| WPARAM param_flag = 0; | |
| if (this->is_edge_chromium()) { | |
| param_flag = 1000; | |
| //HWND top_level_handle = this->GetTopLevelWindowHandle(); | |
| // 1) find all Edge browser window handles | |
| std::vector<HWND>edge_window_handles; | |
| ::EnumWindows(&BrowserFactory::FindEdgeBrowserHandles, | |
| reinterpret_cast<LPARAM>(&edge_window_handles)); | |
| // 2) find all IE browser window handlers as child window when Edge runs in IEMode | |
| ie_window_handles = new std::vector<HWND>; | |
| for (HWND& edge_window_handle : edge_window_handles) { | |
| std::vector<HWND> child_window_handles; | |
| ::EnumChildWindows(edge_window_handle, | |
| &BrowserFactory::FindIEBrowserHandles, | |
| reinterpret_cast<LPARAM>(&child_window_handles)); | |
| for (HWND& child_window_handle : child_window_handles) { | |
| ie_window_handles->push_back(child_window_handle); | |
| } | |
| } | |
| } else { | |
| // Handle the NewWindow3 event to allow us to immediately hook | |
| // the events of the new browser window opened by the user action. | |
| // The three ways we can respond to this event are documented at | |
| // http://msdn.microsoft.com/en-us/library/aa768337%28v=vs.85%29.aspx | |
| // We potentially use two of those response methods. | |
| // This will not allow us to handle windows created by the JavaScript | |
| // showModalDialog function(). | |
| std::wstring url = bstrUrl; | |
| IWebBrowser2* browser; | |
| NewWindowInfo info; | |
| info.target_url = StringUtilities::ToString(url); | |
| LRESULT create_result = ::SendMessage(this->executor_handle(), | |
| WD_BROWSER_NEW_WINDOW, | |
| NULL, | |
| reinterpret_cast<LPARAM>(&info)); | |
| if (create_result != 0) { | |
| // The new, blank IWebBrowser2 object was not created, | |
| // so we can't really do anything appropriate here. | |
| // Note this is "response method 2" of the aforementioned | |
| // documentation. | |
| LOG(WARN) << "A valid IWebBrowser2 object could not be created."; | |
| *pbCancel = VARIANT_TRUE; | |
| ::PostMessage(this->executor_handle(), WD_AFTER_NEW_WINDOW, NULL, NULL); | |
| return; | |
| } | |
| // We received a valid IWebBrowser2 pointer, so deserialize it onto this | |
| // thread, and pass the result back to the caller. | |
| HRESULT hr = ::CoGetInterfaceAndReleaseStream(info.browser_stream, | |
| IID_IWebBrowser2, | |
| reinterpret_cast<void**>(&browser)); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Failed to marshal IWebBrowser2 interface from stream."; | |
| } | |
| *ppDisp = browser; | |
| } | |
| // 3) pass all IE window handles to WD_AFTER_NEW_WINDOW | |
| ::PostMessage(this->executor_handle(), | |
| WD_AFTER_NEW_WINDOW, | |
| param_flag, | |
| reinterpret_cast<LPARAM>(ie_window_handles)); | |
| } | |
| void __stdcall Browser::DocumentComplete(IDispatch* pDisp, VARIANT* URL) { | |
| LOG(TRACE) << "Entering Browser::DocumentComplete"; | |
| // Flag the browser as navigation having started. | |
| this->is_navigation_started_ = true; | |
| // DocumentComplete fires last for the top-level frame. If it fires | |
| // for the top-level frame and the focused_frame_window_ member variable | |
| // is not NULL, we assume we have navigated from within a frameset to a | |
| // link that has a target of "_top", which replaces the frameset with the | |
| // target page. On a top-level navigation, we are supposed to reset the | |
| // focused frame to the top-level, so we do that here. | |
| // NOTE: This is a possible source of unreliability if the above | |
| // assumptions turn out to be wrong and/or the event firing doesn't work | |
| // the way we expect it to. | |
| CComPtr<IDispatch> dispatch(this->browser_); | |
| if (dispatch.IsEqualObject(pDisp)) { | |
| if (this->focused_frame_window() != NULL) { | |
| LOG(DEBUG) << "DocumentComplete happened from within a frameset"; | |
| this->SetFocusedFrameByElement(NULL); | |
| } | |
| } | |
| } | |
| void Browser::InitiateBrowserReattach() { | |
| LOG(TRACE) << "Entering Browser::InitiateBrowserReattach"; | |
| LOG(DEBUG) << "Requesting browser reattach"; | |
| this->known_process_ids_.clear(); | |
| WindowUtilities::GetProcessesByName(L"iexplore.exe", | |
| &this->known_process_ids_); | |
| this->set_is_awaiting_new_process(true); | |
| ::SendMessage(this->executor_handle(), WD_BEFORE_BROWSER_REATTACH, NULL, NULL); | |
| } | |
| void Browser::ReattachBrowser(IWebBrowser2* browser) { | |
| LOG(TRACE) << "Entering Browser::ReattachBrowser"; | |
| this->browser_ = browser; | |
| this->AttachEvents(); | |
| this->set_is_awaiting_new_process(false); | |
| LOG(DEBUG) << "Reattach complete"; | |
| } | |
| void Browser::GetDocument(IHTMLDocument2** doc) { | |
| this->GetDocument(false, doc); | |
| } | |
| void Browser::GetDocument(const bool force_top_level_document, | |
| IHTMLDocument2** doc) { | |
| LOG(TRACE) << "Entering Browser::GetDocument"; | |
| CComPtr<IHTMLWindow2> window; | |
| if (this->focused_frame_window() == NULL || force_top_level_document) { | |
| LOG(INFO) << "No child frame focus. Focus is on top-level frame"; | |
| CComPtr<IDispatch> dispatch; | |
| HRESULT hr = this->browser_->get_Document(&dispatch); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Unable to get document, IWebBrowser2::get_Document call failed"; | |
| return; | |
| } | |
| CComPtr<IHTMLDocument2> dispatch_doc; | |
| hr = dispatch->QueryInterface(&dispatch_doc); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Have document but cannot cast, IDispatch::QueryInterface call failed"; | |
| return; | |
| } | |
| dispatch_doc->get_parentWindow(&window); | |
| } else { | |
| window = this->focused_frame_window(); | |
| } | |
| if (window) { | |
| bool result = this->GetDocumentFromWindow(window, doc); | |
| if (!result) { | |
| LOG(WARN) << "Cannot get document"; | |
| } | |
| } else { | |
| LOG(WARN) << "No window is found"; | |
| } | |
| } | |
| std::string Browser::GetTitle() { | |
| LOG(TRACE) << "Entering Browser::GetTitle"; | |
| CComPtr<IDispatch> dispatch; | |
| HRESULT hr = this->browser_->get_Document(&dispatch); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Unable to get document, IWebBrowser2::get_Document call failed"; | |
| return ""; | |
| } | |
| CComPtr<IHTMLDocument2> doc; | |
| hr = dispatch->QueryInterface(&doc); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Have document but cannot cast, IDispatch::QueryInterface call failed"; | |
| return ""; | |
| } | |
| CComBSTR title; | |
| hr = doc->get_title(&title); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Unable to get document title, call to IHTMLDocument2::get_title failed"; | |
| return ""; | |
| } | |
| std::wstring converted_title = title; | |
| std::string title_string = StringUtilities::ToString(converted_title); | |
| return title_string; | |
| } | |
| std::string Browser::GetBrowserUrl() { | |
| LOG(TRACE) << "Entering Browser::GetBrowserUrl"; | |
| CComBSTR url; | |
| HRESULT hr = this->browser_->get_LocationURL(&url); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Unable to get current URL, call to IWebBrowser2::get_LocationURL failed"; | |
| return ""; | |
| } | |
| std::wstring converted_url = url; | |
| std::string current_url = StringUtilities::ToString(converted_url); | |
| return current_url; | |
| } | |
| HWND Browser::GetContentWindowHandle() { | |
| LOG(TRACE) << "Entering Browser::GetContentWindowHandle"; | |
| HWND current_content_window_handle = this->window_handle(); | |
| // If this window is closing, the only reason to care about | |
| // a valid window handle is to check for alerts whose parent | |
| // is this window handle, so return the stored window handle. | |
| if (!this->is_closing()) { | |
| // If, for some reason, the window handle is no longer valid, set the | |
| // member variable to NULL so that we can reacquire the valid window | |
| // handle. Note that this can happen when browsing from one type of | |
| // content to another, like from HTML to a transformed XML page that | |
| // renders content. If the member variable is NULL upon entering this | |
| // method, that is okay, as it typically means only that this object | |
| // is newly constructed, and has not yet had its handle set. | |
| bool window_handle_is_valid = ::IsWindow(current_content_window_handle); | |
| if (!window_handle_is_valid) { | |
| LOG(INFO) << "Flushing window handle as it is no longer valid"; | |
| this->set_window_handle(NULL); | |
| } | |
| if (this->window_handle() == NULL) { | |
| LOG(INFO) << "Restore window handle from tab"; | |
| // GetBrowserWindowHandle gets the TabWindowClass window in IE 7 and 8, | |
| // and the top-level window frame in IE 6. The window we need is the | |
| // InternetExplorer_Server window. | |
| HWND tab_window_handle = this->GetBrowserWindowHandle(); | |
| if (tab_window_handle == NULL) { | |
| LOG(WARN) << "No tab window found"; | |
| } | |
| HWND content_window_handle = this->FindContentWindowHandle(tab_window_handle); | |
| this->set_window_handle(content_window_handle); | |
| } | |
| } | |
| return this->window_handle(); | |
| } | |
| std::string Browser::GetWindowName() { | |
| LOG(TRACE) << "Entering Browser::GetWindowName"; | |
| CComPtr<IDispatch> dispatch; | |
| HRESULT hr = this->browser_->get_Document(&dispatch); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Unable to get document, IWebBrowser2::get_Document call failed"; | |
| return ""; | |
| } | |
| CComPtr<IHTMLDocument2> doc; | |
| dispatch->QueryInterface<IHTMLDocument2>(&doc); | |
| if (!doc) { | |
| LOGHR(WARN, hr) << "Have document but cannot cast, IDispatch::QueryInterface call failed"; | |
| return ""; | |
| } | |
| CComPtr<IHTMLWindow2> window; | |
| hr = doc->get_parentWindow(&window); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Unable to get parent window, call to IHTMLDocument2::get_parentWindow failed"; | |
| return ""; | |
| } | |
| std::string name = ""; | |
| CComBSTR window_name; | |
| hr = window->get_name(&window_name); | |
| if (window_name) { | |
| std::wstring converted_window_name = window_name; | |
| name = StringUtilities::ToString(converted_window_name); | |
| } else { | |
| LOG(WARN) << "Unable to get window name, IHTMLWindow2::get_name failed or returned a NULL value"; | |
| } | |
| return name; | |
| } | |
| long Browser::GetWidth() { | |
| LOG(TRACE) << "Entering Browser::GetWidth"; | |
| long width = 0; | |
| this->browser_->get_Width(&width); | |
| return width; | |
| } | |
| long Browser::GetHeight() { | |
| LOG(TRACE) << "Entering Browser::GetHeight"; | |
| long height = 0; | |
| this->browser_->get_Height(&height); | |
| return height; | |
| } | |
| void Browser::SetWidth(long width) { | |
| LOG(TRACE) << "Entering Browser::SetWidth"; | |
| this->browser_->put_Width(width); | |
| } | |
| void Browser::SetHeight(long height) { | |
| LOG(TRACE) << "Entering Browser::SetHeight"; | |
| this->browser_->put_Height(height); | |
| } | |
| void Browser::AttachEvents() { | |
| LOG(TRACE) << "Entering Browser::AttachEvents"; | |
| CComPtr<IUnknown> unknown; | |
| this->browser_->QueryInterface<IUnknown>(&unknown); | |
| HRESULT hr = this->DispEventAdvise(unknown); | |
| } | |
| void Browser::DetachEvents() { | |
| LOG(TRACE) << "Entering Browser::DetachEvents"; | |
| CComPtr<IUnknown> unknown; | |
| this->browser_->QueryInterface<IUnknown>(&unknown); | |
| HRESULT hr = this->DispEventUnadvise(unknown); | |
| } | |
| void Browser::Close() { | |
| LOG(TRACE) << "Entering Browser::Close"; | |
| if (this->is_edge_chromium()) { | |
| // For Edge in IE Mode, cache the top-level hosting Chromium window | |
| // handle so they can be properly closed on quit. | |
| HWND top_level_window_handle = this->GetTopLevelWindowHandle(); | |
| ::SendMessage(this->executor_handle(), | |
| WD_ADD_CHROMIUM_WINDOW_HANDLE, | |
| reinterpret_cast<WPARAM>(top_level_window_handle), | |
| NULL); | |
| } | |
| this->is_explicit_close_requested_ = true; | |
| this->set_is_closing(true); | |
| // Closing the browser, so having focus on a frame doesn't | |
| // make any sense. | |
| this->SetFocusedFrameByElement(NULL); | |
| HRESULT hr = S_OK; | |
| hr = this->browser_->Stop(); | |
| hr = this->browser_->Quit(); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Call to IWebBrowser2::Quit failed"; | |
| } | |
| } | |
| int Browser::NavigateToUrl(const std::string& url, | |
| std::string* error_message) { | |
| LOG(TRACE) << "Entring Browser::NavigateToUrl"; | |
| std::wstring wide_url = StringUtilities::ToWString(url); | |
| CComVariant url_variant(wide_url.c_str()); | |
| CComVariant dummy; | |
| HRESULT hr = this->browser_->Navigate2(&url_variant, | |
| &dummy, | |
| &dummy, | |
| &dummy, | |
| &dummy); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Call to IWebBrowser2::Navigate2 failed"; | |
| _com_error error(hr); | |
| std::wstring formatted_message = StringUtilities::Format( | |
| L"Received error: 0x%08x ['%s']", | |
| hr, | |
| error.ErrorMessage()); | |
| *error_message = StringUtilities::ToString(formatted_message); | |
| return EUNHANDLEDERROR; | |
| } | |
| this->set_wait_required(true); | |
| return WD_SUCCESS; | |
| } | |
| int Browser::NavigateBack() { | |
| LOG(TRACE) << "Entering Browser::NavigateBack"; | |
| LPSTREAM stream; | |
| HRESULT hr = ::CoMarshalInterThreadInterfaceInStream(IID_IWebBrowser2, this->browser_, &stream); | |
| unsigned int thread_id = 0; | |
| HANDLE thread_handle = reinterpret_cast<HANDLE>(_beginthreadex(NULL, | |
| 0, | |
| &Browser::GoBackThreadProc, | |
| (void *)stream, | |
| 0, | |
| &thread_id)); | |
| if (thread_handle != NULL) { | |
| ::CloseHandle(thread_handle); | |
| } | |
| this->set_wait_required(true); | |
| return WD_SUCCESS; | |
| } | |
| unsigned int WINAPI Browser::GoBackThreadProc(LPVOID param) { | |
| HRESULT hr = ::CoInitialize(NULL); | |
| IWebBrowser2* browser; | |
| LPSTREAM message_payload = reinterpret_cast<LPSTREAM>(param); | |
| hr = ::CoGetInterfaceAndReleaseStream(message_payload, | |
| IID_IWebBrowser2, | |
| reinterpret_cast<void**>(&browser)); | |
| if (browser != NULL) { | |
| hr = browser->GoBack(); | |
| } | |
| return 0; | |
| } | |
| int Browser::NavigateForward() { | |
| LOG(TRACE) << "Entering Browser::NavigateForward"; | |
| LPSTREAM stream; | |
| HRESULT hr = ::CoMarshalInterThreadInterfaceInStream(IID_IWebBrowser2, this->browser_, &stream); | |
| unsigned int thread_id = 0; | |
| HANDLE thread_handle = reinterpret_cast<HANDLE>(_beginthreadex(NULL, | |
| 0, | |
| &Browser::GoForwardThreadProc, | |
| (void *)stream, | |
| 0, | |
| &thread_id)); | |
| if (thread_handle != NULL) { | |
| ::CloseHandle(thread_handle); | |
| } | |
| this->set_wait_required(true); | |
| return WD_SUCCESS; | |
| } | |
| unsigned int WINAPI Browser::GoForwardThreadProc(LPVOID param) { | |
| HRESULT hr = ::CoInitialize(NULL); | |
| IWebBrowser2* browser; | |
| LPSTREAM message_payload = reinterpret_cast<LPSTREAM>(param); | |
| hr = ::CoGetInterfaceAndReleaseStream(message_payload, | |
| IID_IWebBrowser2, | |
| reinterpret_cast<void**>(&browser)); | |
| if (browser != NULL) { | |
| hr = browser->GoForward(); | |
| } | |
| return 0; | |
| } | |
| int Browser::Refresh() { | |
| LOG(TRACE) << "Entering Browser::Refresh"; | |
| HRESULT hr = this->browser_->Refresh(); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Call to IWebBrowser2::Refresh failed"; | |
| } | |
| this->set_wait_required(true); | |
| return WD_SUCCESS; | |
| } | |
| HWND Browser::GetTopLevelWindowHandle() { | |
| LOG(TRACE) << "Entering Browser::GetTopLevelWindowHandle"; | |
| HWND top_level_window_handle = NULL; | |
| HRESULT hr = this->browser_->get_HWND(reinterpret_cast<SHANDLE_PTR*>(&top_level_window_handle)); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Getting HWND property of IWebBrowser2 object failed"; | |
| } | |
| return top_level_window_handle; | |
| } | |
| bool Browser::IsValidWindow() { | |
| LOG(TRACE) << "Entering Browser::IsValidWindow"; | |
| // This is a no-op for this class. Full browser windows can properly notify | |
| // of their window's validity by using the proper events. | |
| return true; | |
| } | |
| bool Browser::IsBusy() { | |
| VARIANT_BOOL is_busy(VARIANT_FALSE); | |
| HRESULT hr = this->browser_->get_Busy(&is_busy); | |
| return SUCCEEDED(hr) && is_busy == VARIANT_TRUE; | |
| } | |
| bool Browser::Wait(const std::string& page_load_strategy) { | |
| LOG(TRACE) << "Entering Browser::Wait"; | |
| if (page_load_strategy == NONE_PAGE_LOAD_STRATEGY) { | |
| LOG(DEBUG) << "Page load strategy is 'none'. Aborting wait."; | |
| this->set_wait_required(false); | |
| return true; | |
| } | |
| if (this->is_awaiting_new_process()) { | |
| return false; | |
| } | |
| bool is_navigating = true; | |
| LOG(DEBUG) << "Navigate Events Completed."; | |
| this->is_navigation_started_ = false; | |
| HWND dialog = this->GetActiveDialogWindowHandle(); | |
| if (dialog != NULL) { | |
| LOG(DEBUG) << "Found alert. Aborting wait."; | |
| this->set_wait_required(false); | |
| return true; | |
| } | |
| // Navigate events completed. Waiting for browser.Busy != false... | |
| is_navigating = this->is_navigation_started_; | |
| if (is_navigating || (page_load_strategy == NORMAL_PAGE_LOAD_STRATEGY && this->IsBusy())) { | |
| if (is_navigating) { | |
| LOG(DEBUG) << "DocumentComplete event fired, indicating a new navigation."; | |
| } else { | |
| LOG(DEBUG) << "Browser busy property is true."; | |
| } | |
| return false; | |
| } | |
| READYSTATE expected_ready_state = READYSTATE_COMPLETE; | |
| if (page_load_strategy == EAGER_PAGE_LOAD_STRATEGY) { | |
| expected_ready_state = READYSTATE_INTERACTIVE; | |
| } | |
| // Waiting for browser.ReadyState >= expected ready state | |
| is_navigating = this->is_navigation_started_; | |
| READYSTATE ready_state; | |
| HRESULT hr = this->browser_->get_ReadyState(&ready_state); | |
| if (is_navigating || FAILED(hr) || ready_state < expected_ready_state) { | |
| if (is_navigating) { | |
| LOG(DEBUG) << "DocumentComplete event fired, indicating a new navigation."; | |
| } else if (FAILED(hr)) { | |
| LOGHR(DEBUG, hr) << "IWebBrowser2::get_ReadyState failed."; | |
| } else { | |
| LOG(DEBUG) << "Browser ReadyState is not at least '" << expected_ready_state << "'; it was " << ready_state; | |
| } | |
| return false; | |
| } | |
| // Waiting for document property != null... | |
| is_navigating = this->is_navigation_started_; | |
| CComPtr<IDispatch> document_dispatch; | |
| hr = this->browser_->get_Document(&document_dispatch); | |
| if (is_navigating || FAILED(hr) || !document_dispatch) { | |
| if (is_navigating) { | |
| LOG(DEBUG) << "DocumentComplete event fired, indicating a new navigation."; | |
| } else if (FAILED(hr)) { | |
| LOGHR(DEBUG, hr) << "IWebBrowser2::get_Document failed."; | |
| } else { | |
| LOG(DEBUG) << "Get Document failed; IWebBrowser2::get_Document did not return a valid IDispatch object."; | |
| } | |
| return false; | |
| } | |
| // Waiting for document to complete... | |
| CComPtr<IHTMLDocument2> doc; | |
| hr = document_dispatch->QueryInterface(&doc); | |
| if (SUCCEEDED(hr)) { | |
| LOG(DEBUG) << "Waiting for document to complete..."; | |
| is_navigating = this->IsDocumentNavigating(page_load_strategy, doc); | |
| } | |
| if (!is_navigating) { | |
| LOG(DEBUG) << "Not in navigating state"; | |
| this->set_wait_required(false); | |
| } | |
| return !is_navigating; | |
| } | |
| bool Browser::IsDocumentNavigating(const std::string& page_load_strategy, | |
| IHTMLDocument2* doc) { | |
| LOG(TRACE) << "Entering Browser::IsDocumentNavigating"; | |
| bool is_navigating = true; | |
| // Starting WaitForDocumentComplete() | |
| is_navigating = this->is_navigation_started_; | |
| CComBSTR ready_state_bstr; | |
| HRESULT hr = doc->get_readyState(&ready_state_bstr); | |
| if (FAILED(hr) || is_navigating) { | |
| if (FAILED(hr)) { | |
| LOGHR(DEBUG, hr) << "IHTMLDocument2::get_readyState failed."; | |
| } else if (is_navigating) { | |
| LOG(DEBUG) << "DocumentComplete event fired, indicating a new navigation."; | |
| } | |
| return true; | |
| } else { | |
| std::wstring ready_state = ready_state_bstr; | |
| if ((ready_state == L"complete") || | |
| (page_load_strategy == EAGER_PAGE_LOAD_STRATEGY && ready_state == L"interactive")) { | |
| is_navigating = false; | |
| } else { | |
| if (page_load_strategy == EAGER_PAGE_LOAD_STRATEGY) { | |
| LOG(DEBUG) << "document.readyState is not 'complete' or 'interactive'; it was " << LOGWSTRING(ready_state); | |
| } else { | |
| LOG(DEBUG) << "document.readyState is not 'complete'; it was " << LOGWSTRING(ready_state); | |
| } | |
| return true; | |
| } | |
| } | |
| // document.readyState == complete | |
| is_navigating = this->is_navigation_started_; | |
| CComPtr<IHTMLFramesCollection2> frames; | |
| hr = doc->get_frames(&frames); | |
| if (is_navigating || FAILED(hr)) { | |
| LOG(DEBUG) << "Could not get frames, navigation has started or call to IHTMLDocument2::get_frames failed"; | |
| return true; | |
| } | |
| if (frames != NULL) { | |
| long frame_count = 0; | |
| hr = frames->get_length(&frame_count); | |
| CComVariant index; | |
| index.vt = VT_I4; | |
| for (long i = 0; i < frame_count; ++i) { | |
| // Waiting on each frame | |
| index.lVal = i; | |
| CComVariant result; | |
| hr = frames->item(&index, &result); | |
| if (FAILED(hr)) { | |
| LOGHR(DEBUG, hr) << "Could not get frame item for index " | |
| << i | |
| << ", call to IHTMLFramesCollection2::item failed, frame/frameset is broken"; | |
| continue; | |
| } | |
| CComPtr<IHTMLWindow2> window; | |
| result.pdispVal->QueryInterface<IHTMLWindow2>(&window); | |
| if (!window) { | |
| LOG(DEBUG) << "Could not get window for frame item with index " | |
| << i | |
| << ", cast to IHTMLWindow2 failed, frame is not an HTML frame"; | |
| continue; | |
| } | |
| CComPtr<IHTMLDocument2> frame_document; | |
| bool is_valid_frame_document = this->GetDocumentFromWindow(window, | |
| &frame_document); | |
| is_navigating = this->is_navigation_started_; | |
| if (is_navigating) { | |
| break; | |
| } | |
| // Recursively call to wait for the frame document to complete | |
| if (is_valid_frame_document) { | |
| is_navigating = this->IsDocumentNavigating(page_load_strategy, frame_document); | |
| if (is_navigating) { | |
| break; | |
| } | |
| } | |
| } | |
| } else { | |
| LOG(DEBUG) << "IHTMLDocument2.get_frames() returned empty collection"; | |
| } | |
| return is_navigating; | |
| } | |
| bool Browser::GetDocumentFromWindow(IHTMLWindow2* window, | |
| IHTMLDocument2** doc) { | |
| LOG(TRACE) << "Entering Browser::GetDocumentFromWindow"; | |
| HRESULT hr = window->get_document(doc); | |
| if (SUCCEEDED(hr)) { | |
| return true; | |
| } | |
| 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 = window->QueryInterface<IServiceProvider>(&service_provider); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Unable to get browser, call to IHTMLWindow2::QueryService failed for IServiceProvider"; | |
| return false; | |
| } | |
| 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 false; | |
| } | |
| CComPtr<IDispatch> document_dispatch; | |
| hr = window_browser->get_Document(&document_dispatch); | |
| if (FAILED(hr) || hr == S_FALSE) { | |
| LOGHR(WARN, hr) << "Unable to get document, call to IWebBrowser2::get_Document failed"; | |
| return false; | |
| } | |
| hr = document_dispatch->QueryInterface(doc); | |
| if (FAILED(hr)) { | |
| LOGHR(WARN, hr) << "Unable to query document, call to IDispatch::QueryInterface failed."; | |
| return false; | |
| } | |
| return true; | |
| } else { | |
| LOGHR(WARN, hr) << "Unable to get main document, IHTMLWindow2::get_document returned other than E_ACCESSDENIED"; | |
| } | |
| return false; | |
| } | |
| HWND Browser::GetBrowserWindowHandle() { | |
| LOG(TRACE) << "Entering Browser::GetBrowserWindowHandle"; | |
| HWND hwnd = NULL; | |
| CComPtr<IServiceProvider> service_provider; | |
| HRESULT hr = this->browser_->QueryInterface(IID_IServiceProvider, | |
| reinterpret_cast<void**>(&service_provider)); | |
| HWND hwnd_tmp = NULL; | |
| this->browser_->get_HWND(reinterpret_cast<SHANDLE_PTR*>(&hwnd_tmp)); | |
| if (SUCCEEDED(hr)) { | |
| CComPtr<IOleWindow> window; | |
| hr = service_provider->QueryService(SID_SShellBrowser, | |
| IID_IOleWindow, | |
| reinterpret_cast<void**>(&window)); | |
| if (SUCCEEDED(hr)) { | |
| // This gets the TabWindowClass window in IE 7 and 8, | |
| // and the top-level window frame in IE 6. | |
| window->GetWindow(&hwnd); | |
| } else { | |
| LOGHR(WARN, hr) << "Unable to get window, call to IOleWindow::QueryService for SID_SShellBrowser failed"; | |
| } | |
| } else { | |
| LOGHR(WARN, hr) << "Unable to get service, call to IWebBrowser2::QueryInterface for IID_IServiceProvider failed"; | |
| } | |
| return hwnd; | |
| } | |
| bool Browser::SetFullScreen(bool is_full_screen) { | |
| VARIANT_BOOL full_screen_value = VARIANT_TRUE; | |
| std::wstring full_screen_script = L"window.fullScreen = true;"; | |
| if (!is_full_screen) { | |
| full_screen_value = VARIANT_FALSE; | |
| full_screen_script = L"delete window.fullScreen;"; | |
| } | |
| this->browser_->put_FullScreen(full_screen_value); | |
| // IE does not support the W3C Fullscreen API (and likely never will). | |
| // The prefixed version cannot be triggered via JavaScript outside of | |
| // a user interaction, so we're going to cheat here and manually set | |
| // the fullScreen property of the window object to the appropriate | |
| // value. This may interfere with polyfills in use, and if that's | |
| // the case, we'll revisit this hack. | |
| CComPtr<IHTMLDocument2> doc; | |
| this->GetDocument(true, &doc); | |
| std::wstring script = ANONYMOUS_FUNCTION_START; | |
| script += full_screen_script; | |
| script += ANONYMOUS_FUNCTION_END; | |
| Script script_wrapper(doc, script, 0); | |
| script_wrapper.Execute(); | |
| return true; | |
| } | |
| bool Browser::IsFullScreen() { | |
| VARIANT_BOOL is_full_screen = VARIANT_FALSE; | |
| this->browser_->get_FullScreen(&is_full_screen); | |
| return is_full_screen == VARIANT_TRUE; | |
| } | |
| HWND Browser::GetActiveDialogWindowHandle() { | |
| LOG(TRACE) << "Entering Browser::GetActiveDialogWindowHandle"; | |
| HWND active_dialog_handle = NULL; | |
| HWND content_window_handle = this->GetContentWindowHandle(); | |
| if (content_window_handle == NULL) { | |
| return active_dialog_handle; | |
| } | |
| DWORD process_id = 0; | |
| ::GetWindowThreadProcessId(content_window_handle, &process_id); | |
| if (process_id == 0) { | |
| return active_dialog_handle; | |
| } | |
| ProcessWindowInfo process_win_info; | |
| process_win_info.dwProcessId = process_id; | |
| process_win_info.hwndBrowser = NULL; | |
| ::EnumWindows(&BrowserFactory::FindDialogWindowForProcess, | |
| reinterpret_cast<LPARAM>(&process_win_info)); | |
| if (process_win_info.hwndBrowser != NULL) { | |
| active_dialog_handle = process_win_info.hwndBrowser; | |
| this->CheckDialogType(active_dialog_handle); | |
| } | |
| return active_dialog_handle; | |
| } | |
| void Browser::CheckDialogType(HWND dialog_window_handle) { | |
| LOG(TRACE) << "Entering Browser::CheckDialogType"; | |
| std::vector<char> window_class_name(34); | |
| if (GetClassNameA(dialog_window_handle, &window_class_name[0], 34)) { | |
| if (strcmp(HTML_DIALOG_WINDOW_CLASS, | |
| &window_class_name[0]) == 0) { | |
| HWND content_window_handle = this->FindContentWindowHandle(dialog_window_handle); | |
| ::PostMessage(this->executor_handle(), | |
| WD_NEW_HTML_DIALOG, | |
| NULL, | |
| reinterpret_cast<LPARAM>(content_window_handle)); | |
| } | |
| } | |
| } | |
| } // namespace webdriver |