// 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 "AsyncScriptExecutor.h"

#include <vector>

#include "errorcodes.h"

#include "logging.h"

#include "Script.h"

namespace webdriver {

LRESULT AsyncScriptExecutor::OnInit(UINT uMsg,

WPARAM wParam,

LPARAM lParam,

BOOL& bHandled) {

LOG(TRACE) << "Entering AsyncScriptExecutor::OnInit";

return 0;

}

LRESULT AsyncScriptExecutor::OnCreate(UINT uMsg,

WPARAM wParam,

LPARAM lParam,

BOOL& bHandled) {

LOG(TRACE) << "Entering AsyncScriptExecutor::OnCreate";

CREATESTRUCT* create = reinterpret_cast<CREATESTRUCT*>(lParam);

AsyncScriptExecutorThreadContext* context = reinterpret_cast<AsyncScriptExecutorThreadContext*>(create->lpCreateParams);

this->script_source_code_ = context->script_source;

this->script_argument_count_ = context->script_argument_count;

this->script_argument_index_ = 0;

// Calling vector::resize() is okay here, because the vector

// should be empty when Initialize() is called, and the

// reallocation of variants shouldn't give us too much of a

// negative impact.

this->script_arguments_.resize(this->script_argument_count_);

this->status_code_ = WD_SUCCESS;

this->is_execution_completed_ = false;

this->is_listener_attached_ = true;

return 0;

}

LRESULT AsyncScriptExecutor::OnClose(UINT uMsg,

WPARAM wParam,

LPARAM lParam,

BOOL& bHandled) {

LOG(TRACE) << "Entering AsyncScriptExecutor::OnClose";

this->DestroyWindow();

return 0;

}

LRESULT AsyncScriptExecutor::OnDestroy(UINT uMsg,

WPARAM wParam,

LPARAM lParam,

BOOL& bHandled) {

LOG(TRACE) << "Entering AsyncAtomExecutor::OnDestroy";

::PostQuitMessage(0);

return 0;

}

LRESULT AsyncScriptExecutor::OnSetDocument(UINT uMsg,

WPARAM wParam,

LPARAM lParam,

BOOL& bHandled) {

LOG(TRACE) << "Entering AsyncScriptExecutor::OnSetDocument";

CComPtr<IHTMLDocument2> doc;

LPSTREAM initializer_payload = reinterpret_cast<LPSTREAM>(lParam);

HRESULT hr = ::CoGetInterfaceAndReleaseStream(initializer_payload,

IID_IHTMLDocument2,

reinterpret_cast<void**>(&this->script_host_));

return 0;

}

LRESULT AsyncScriptExecutor::OnSetArgument(UINT uMsg,

WPARAM wParam,

LPARAM lParam,

BOOL& bHandled) {

LOG(TRACE) << "Entering AsyncScriptExecutor::OnSetArgument";

VARTYPE variant_type = static_cast<VARTYPE>(wParam);

switch (variant_type) {

case VT_DISPATCH: {

CComPtr<IDispatch> dispatch;

LPSTREAM message_payload = reinterpret_cast<LPSTREAM>(lParam);

HRESULT hr = ::CoGetInterfaceAndReleaseStream(message_payload,

IID_IDispatch,

reinterpret_cast<void**>(&dispatch));

CComVariant dispatch_variant(dispatch);

this->script_arguments_[this->script_argument_index_] = dispatch_variant;

break;

}

default: {

// TODO: Unmarshal arguments of types other than VT_DISPATCH. At present,

// the asynchronous execution of JavaScript is only used for Automation

// Atoms on an element which take a single argument, an IHTMLElement

// object, which is represented as an IDispatch. This case statement

// will get much more complex should the need arise to execute

// arbitrary scripts in an asynchronous manner.

}

}

++this->script_argument_index_;

return 0;

}

LRESULT AsyncScriptExecutor::OnExecuteScript(UINT uMsg,

WPARAM wParam,

LPARAM lParam,

BOOL& bHandled) {

LOG(TRACE) << "Entering AsyncScriptExecutor::OnExecuteScript";

Script script_to_execute(this->script_host_,

this->script_source_code_,

this->script_argument_count_);

for (size_t index = 0; index < this->script_arguments_.size(); ++index) {

script_to_execute.AddArgument(this->script_arguments_[index]);

}

this->status_code_ = script_to_execute.Execute();

this->is_execution_completed_ = true;

if (!this->is_listener_attached_) {

::PostMessage(this->m_hWnd, WM_CLOSE, NULL, NULL);

}

return 0;

}

LRESULT AsyncScriptExecutor::OnDetachListener(UINT uMsg,

WPARAM wParam,

LPARAM lParam,

BOOL& bHandled) {

LOG(TRACE) << "Entering AsyncScriptExecutor::OnDetachListener";

this->is_listener_attached_ = false;

return 0;

}

LRESULT AsyncScriptExecutor::OnIsExecutionComplete(UINT uMsg,

WPARAM wParam,

LPARAM lParam,

BOOL& bHandled) {

return this->is_execution_completed_ ? 1 : 0;

}

LRESULT AsyncScriptExecutor::OnGetResult(UINT uMsg,

WPARAM wParam,

LPARAM lParam,

BOOL& bHandled) {

LOG(TRACE) << "Entering AsyncScriptExecutor::OnGetResult";

// NOTE: We need to tell this window to close itself. If and when marshaling

// of the actual variant result to the calling thread is implemented, posting

// the message to close the window will have to be moved to the method that

// retrieves the marshaled result.

::PostMessage(this->m_hWnd, WM_CLOSE, NULL, NULL);

return this->status_code_;

}

unsigned int WINAPI AsyncScriptExecutor::ThreadProc(LPVOID lpParameter) {

LOG(TRACE) << "Entering AsyncScriptExecutor::ThreadProc";

AsyncScriptExecutorThreadContext* thread_context = reinterpret_cast<AsyncScriptExecutorThreadContext*>(lpParameter);

HWND window_handle = thread_context->hwnd;

DWORD error = 0;

HRESULT hr = ::CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);

if (FAILED(hr)) {

LOGHR(DEBUG, hr) << "COM library initialization has some problem";

}

AsyncScriptExecutor async_executor;

HWND async_executor_window_handle = async_executor.Create(/*HWND*/ HWND_MESSAGE,

/*_U_RECT rect*/ CWindow::rcDefault,

/*LPCTSTR szWindowName*/ NULL,

/*DWORD dwStyle*/ NULL,

/*DWORD dwExStyle*/ NULL,

/*_U_MENUorID MenuOrID*/ 0U,

/*LPVOID lpCreateParam*/ reinterpret_cast<LPVOID*>(thread_context));

if (async_executor_window_handle == NULL) {

LOGERR(WARN) << "Unable to create new AsyncScriptExecutor";

}

MSG msg;

::PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);

// Return the HWND back through lpParameter, and signal that the

// window is ready for messages.

thread_context->hwnd = async_executor_window_handle;

HANDLE event_handle = ::OpenEvent(EVENT_ALL_ACCESS, FALSE, ASYNC_SCRIPT_EVENT_NAME);

if (event_handle != NULL) {

::SetEvent(event_handle);

::CloseHandle(event_handle);

} else {

LOGERR(DEBUG) << "Unable to signal that window is ready";

}

// Run the message loop

while (::GetMessage(&msg, NULL, 0, 0) > 0) {

::TranslateMessage(&msg);

::DispatchMessage(&msg);

}

::CoUninitialize();

return 0;

}

} // namespace webdriver