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