Refactor IE user-initiated JavaScript execution to use JSON objects

This IE driver refactor is internal, but should not change behavior of the
driver. It is intended to let the driver's internal script executor use
the direct internal JSON objects as arguments for script execution,
deferring their conversion into variants until directly before execution.

Author: jimevans

cpp/iedriver/AsyncScriptExecutor.cpp

@@ -105,6 +105,22 @@ LRESULT AsyncScriptExecutor::OnSetArgument(UINT uMsg,
       this->script_arguments_[this->script_argument_index_] = dispatch_variant;
       break;
     }
+    case VT_BSTR: {
+      CComVariant str_arg(*reinterpret_cast<LPCTSTR*>(lParam));
+      this->script_arguments_[this->script_argument_index_] = str_arg;
+      break;
+    }
+    case VT_BOOL:
+      this->script_arguments_[this->script_argument_index_] = static_cast<int>(lParam) != VARIANT_FALSE;
+      break;
+    case VT_I4:
+    case VT_I8:
+      this->script_arguments_[this->script_argument_index_] = static_cast<long>(lParam);
+      break;
+    case VT_R4:
+    case VT_R8:
+      this->script_arguments_[this->script_argument_index_] = *reinterpret_cast<double*>(lParam);
+      break;
     default: {
       // TODO: Unmarshal arguments of types other than VT_DISPATCH. At present,
       // the asynchronous execution of JavaScript is only used for Automation
@@ -130,10 +146,17 @@ LRESULT AsyncScriptExecutor::OnExecuteScript(UINT uMsg,
     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);
+  } else {
+    Script store_result_script(this->script_host_,
+                               "(function() { return function(){ window.document.__webdriver_script_result = arguments[0]; };})();",
+                               1);
+    store_result_script.AddArgument(script_to_execute.result());
+    store_result_script.Execute();
   }
+  this->is_execution_completed_ = true;
   return 0;
 }
 

cpp/iedriver/CommandHandlers/ExecuteScriptCommandHandler.cpp

@@ -56,10 +56,9 @@ void ExecuteScriptCommandHandler::ExecuteInternal(
 
     CComPtr<IHTMLDocument2> doc;
     browser_wrapper->GetDocument(&doc);
-    Script script_wrapper(doc, script_source, json_args.size());
-    status_code = this->PopulateArgumentArray(executor,
-                                              script_wrapper,
-                                              json_args);
+    Script script_wrapper(doc, script_source);
+    status_code = script_wrapper.AddArguments(executor.window_handle(), json_args);
+
     if (status_code != WD_SUCCESS) {
       response->SetErrorResponse(status_code, "Error setting arguments for script");
       return;
@@ -72,10 +71,19 @@ void ExecuteScriptCommandHandler::ExecuteInternal(
       return;
     } else {
       Json::Value script_result;
-      script_wrapper.ConvertResultToJsonValue(executor, &script_result);
+      script_wrapper.ConvertResultToJsonValue(executor.window_handle(), &script_result);
       response->SetSuccessResponse(script_result);
       return;
     }
+
+    //HWND async_executor_handle;
+    //status_code = script_wrapper.BeginAsyncExecution(&async_executor_handle);
+    //browser_wrapper->set_script_executor_handle(async_executor_handle);
+
+    //if (status_code != WD_SUCCESS) {
+    //  response->SetErrorResponse(status_code, "JavaScript error");
+    //  return;
+    //}
   }
 }
 

cpp/iedriver/DocumentHost.cpp

@@ -58,6 +58,7 @@ DocumentHost::DocumentHost(HWND hwnd, HWND executor_handle) {
 
   this->window_handle_ = hwnd;
   this->executor_handle_ = executor_handle;
+  this->script_executor_handle_ = NULL;
   this->is_closing_ = false;
   this->wait_required_ = false;
   this->focused_frame_window_ = NULL;

cpp/iedriver/DocumentHost.h

@@ -81,6 +81,12 @@ class DocumentHost {
   bool wait_required(void) const { return this->wait_required_; }
   void set_wait_required(const bool value) { this->wait_required_ = value; }
 
+  bool script_wait_required(void) const { return this->script_wait_required_; }
+  void set_script_wait_required(const bool value) { this->script_wait_required_ = value; }
+
+  HWND script_executor_handle(void) const { return this->script_executor_handle_; }
+  void set_script_executor_handle(HWND value) { this->script_executor_handle_ = value; }
+
   bool is_closing(void) const { return this->is_closing_; }
 
   std::string browser_id(void) const { return this->browser_id_; }
@@ -110,8 +116,10 @@ class DocumentHost {
   CComPtr<IHTMLWindow2> focused_frame_window_;
   HWND window_handle_;
   HWND executor_handle_;
+  HWND script_executor_handle_;
   std::string browser_id_;
   bool wait_required_;
+  bool script_wait_required_;
   bool is_closing_;
 };
 

cpp/iedriver/IECommandExecutor.cpp

@@ -31,13 +31,15 @@
 #include "BrowserFactory.h"
 #include "CommandExecutor.h"
 #include "CommandHandlerRepository.h"
+#include "Element.h"
 #include "ElementFinder.h"
 #include "ElementRepository.h"
 #include "IECommandHandler.h"
 #include "InputManager.h"
 #include "HtmlDialog.h"
 #include "ProxyManager.h"
 #include "StringUtilities.h"
+#include "Script.h"
 
 namespace webdriver {
 
@@ -350,6 +352,71 @@ LRESULT IECommandExecutor::OnGetQuitStatus(UINT uMsg,
   return this->is_quitting_ && this->managed_browsers_.size() > 0 ? 1 : 0;
 }
 
+LRESULT IECommandExecutor::OnScriptWait(UINT uMsg,
+                                        WPARAM wParam,
+                                        LPARAM lParam,
+                                        BOOL& bHandled) {
+  LOG(TRACE) << "Entering IECommandExecutor::OnScriptWait";
+
+  BrowserHandle browser;
+  int status_code = this->GetCurrentBrowser(&browser);
+  if (status_code == WD_SUCCESS && !browser->is_closing()) {
+    if (this->async_script_timeout_ >= 0 && this->wait_timeout_ < clock()) {
+      ::SendMessage(browser->script_executor_handle(), WD_ASYNC_SCRIPT_DETACH_LISTENTER, NULL, NULL);
+      Response timeout_response;
+      timeout_response.SetErrorResponse(ERROR_SCRIPT_TIMEOUT, "Timed out waiting for script to complete.");
+      this->serialized_response_ = timeout_response.Serialize();
+      this->is_waiting_ = false;
+      browser->set_script_executor_handle(NULL);
+    } else {
+      HWND alert_handle;
+      bool is_execution_finished = ::SendMessage(browser->script_executor_handle(), WD_ASYNC_SCRIPT_IS_EXECUTION_COMPLETE, NULL, NULL) != 0;
+      bool is_alert_active = this->IsAlertActive(browser, &alert_handle);
+      this->is_waiting_ = !is_execution_finished && !is_alert_active;
+      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::ScriptWaitThreadProc,
+                                                        (void *)this->m_hWnd,
+                                                        0,
+                                                        &thread_id));
+        if (thread_handle != NULL) {
+          ::CloseHandle(thread_handle);
+        } else {
+          LOGERR(DEBUG) << "Unable to create waiter thread";
+        }
+      } else {
+        Response response;
+        ::SendMessage(browser->script_executor_handle(), WD_ASYNC_SCRIPT_DETACH_LISTENTER, NULL, NULL);
+        int status_code = static_cast<int>(::SendMessage(browser->script_executor_handle(), WD_ASYNC_SCRIPT_GET_RESULT, NULL, NULL));
+        if (status_code != WD_SUCCESS) {
+          response.SetErrorResponse(status_code, "Error executing JavaScript");
+        } else {
+          CComPtr<IHTMLDocument2> doc;
+          browser->GetDocument(&doc);
+          Script result_retrieval_script(doc,
+                                         "(function() { return function(){ return window.document.__webdriver_script_result; };})();",
+                                         0);
+          status_code = result_retrieval_script.Execute();
+          Json::Value script_result;
+          result_retrieval_script.ConvertResultToJsonValue(*this, &script_result);
+          response.SetSuccessResponse(script_result);
+        }
+        this->serialized_response_ = response.Serialize();
+      }
+    }
+  } else {
+    this->is_waiting_ = false;
+  }
+  return 0;
+}
+
 LRESULT IECommandExecutor::OnRefreshManagedElements(UINT uMsg,
                                                     WPARAM wParam,
                                                     LPARAM lParam,
@@ -374,6 +441,39 @@ LRESULT IECommandExecutor::OnHandleUnexpectedAlerts(UINT uMsg,
   return 0;
 }
 
+LRESULT IECommandExecutor::OnGetManagedElement(UINT uMsg,
+                                               WPARAM wParam,
+                                               LPARAM lParam,
+                                               BOOL& bHandled) {
+  ElementInfo* info = reinterpret_cast<ElementInfo*>(lParam);
+  ElementHandle element_handle;
+  int status_code = this->GetManagedElement(info->element_id, &element_handle);
+  if (status_code == WD_SUCCESS) {
+    info->element = element_handle->element();
+  }
+  return status_code;
+}
+
+LRESULT IECommandExecutor::OnAddManagedElement(UINT uMsg,
+                                               WPARAM wParam,
+                                               LPARAM lParam,
+                                               BOOL& bHandled) {
+  ElementInfo* info = reinterpret_cast<ElementInfo*>(lParam);
+  ElementHandle element_handle;
+  this->AddManagedElement(info->element, &element_handle);
+  info->element_id = element_handle->element_id();
+  return WD_SUCCESS;
+}
+
+LRESULT IECommandExecutor::OnRemoveManagedElement(UINT uMsg,
+                                                  WPARAM wParam,
+                                                  LPARAM lParam,
+                                                  BOOL& bHandled) {
+  ElementInfo* info = reinterpret_cast<ElementInfo*>(lParam);
+  this->RemoveManagedElement(info->element_id);
+  return WD_SUCCESS;
+}
+
 unsigned int WINAPI IECommandExecutor::WaitThreadProc(LPVOID lpParameter) {
   LOG(TRACE) << "Entering IECommandExecutor::WaitThreadProc";
   HWND window_handle = reinterpret_cast<HWND>(lpParameter);
@@ -382,6 +482,13 @@ unsigned int WINAPI IECommandExecutor::WaitThreadProc(LPVOID lpParameter) {
   return 0;
 }
 
+unsigned int WINAPI IECommandExecutor::ScriptWaitThreadProc(LPVOID lpParameter) {
+  LOG(TRACE) << "Entering IECommandExecutor::ScriptWaitThreadProc";
+  HWND window_handle = reinterpret_cast<HWND>(lpParameter);
+  ::Sleep(WAIT_TIME_IN_MILLISECONDS);
+  ::PostMessage(window_handle, WD_SCRIPT_WAIT, NULL, NULL);
+  return 0;
+}
 
 unsigned int WINAPI IECommandExecutor::ThreadProc(LPVOID lpParameter) {
   LOG(TRACE) << "Entering IECommandExecutor::ThreadProc";
@@ -522,6 +629,16 @@ void IECommandExecutor::DispatchCommand() {
           this->wait_timeout_ = clock() + (static_cast<int>(this->page_load_timeout_) / 1000 * CLOCKS_PER_SEC);
         }
         ::PostMessage(this->m_hWnd, WD_WAIT, NULL, NULL);
+      } else {
+        HWND script_executor_handle = browser->script_executor_handle();
+        this->is_waiting_ = script_executor_handle != NULL;
+        if (this->is_waiting_) {
+          if (this->async_script_timeout_ >= 0) {
+            this->wait_timeout_ = clock() + (static_cast<int>(this->async_script_timeout_) / 1000 * CLOCKS_PER_SEC);
+          }
+          ::PostMessage(this->m_hWnd, WD_SCRIPT_WAIT, NULL, NULL);
+          return;
+        }
       }
     } else {
       if (this->current_command_.command_type() != webdriver::CommandType::Quit) {
@@ -677,7 +794,37 @@ int IECommandExecutor::CreateNewBrowser(std::string* error_message) {
 int IECommandExecutor::GetManagedElement(const std::string& element_id,
                                          ElementHandle* element_wrapper) const {
   LOG(TRACE) << "Entering IECommandExecutor::GetManagedElement";
-  return this->managed_elements_->GetManagedElement(element_id, element_wrapper);
+  ElementHandle candidate_wrapper;
+  int result = this->managed_elements_->GetManagedElement(element_id, &candidate_wrapper);
+  if (result != WD_SUCCESS) {
+    LOG(WARN) << "Unable to get managed element, element not found";
+    return result;
+  } else {
+    if (!candidate_wrapper->IsAttachedToDom()) {
+      LOG(WARN) << "Found managed element is no longer valid";
+      this->managed_elements_->RemoveManagedElement(element_id);
+      return EOBSOLETEELEMENT;
+    } else {
+      // If the element is attached to the DOM, validate that its document
+      // is the currently-focused document (via frames).
+      BrowserHandle current_browser;
+      this->GetCurrentBrowser(&current_browser);
+      CComPtr<IHTMLDocument2> focused_doc;
+      current_browser->GetDocument(&focused_doc);
+
+      CComPtr<IDispatch> parent_doc_dispatch;
+      candidate_wrapper->element()->get_document(&parent_doc_dispatch);
+
+      if (focused_doc.IsEqualObject(parent_doc_dispatch)) {
+        *element_wrapper = candidate_wrapper;
+        return WD_SUCCESS;
+      } else {
+        LOG(WARN) << "Found managed element's document is not currently focused";
+      }
+    }
+  }
+
+  return EOBSOLETEELEMENT;
 }
 
 void IECommandExecutor::AddManagedElement(IHTMLElement* element,

cpp/iedriver/IECommandExecutor.h

@@ -42,6 +42,11 @@
 
 namespace webdriver {
 
+struct ElementInfo {
+  std::string element_id;
+  IHTMLElement* element;
+};
+
 // Forward declaration of classes.
 class BrowserFactory;
 class CommandHandlerRepository;
@@ -74,6 +79,10 @@ class IECommandExecutor : public CWindowImpl<IECommandExecutor> {
     MESSAGE_HANDLER(WD_REFRESH_MANAGED_ELEMENTS, OnRefreshManagedElements)
     MESSAGE_HANDLER(WD_HANDLE_UNEXPECTED_ALERTS, OnHandleUnexpectedAlerts)
     MESSAGE_HANDLER(WD_QUIT, OnQuit)
+    MESSAGE_HANDLER(WD_SCRIPT_WAIT, OnScriptWait)
+    MESSAGE_HANDLER(WD_GET_MANAGED_ELEMENT, OnGetManagedElement)
+    MESSAGE_HANDLER(WD_ADD_MANAGED_ELEMENT, OnAddManagedElement)
+    MESSAGE_HANDLER(WD_REMOVE_MANAGED_ELEMENT, OnRemoveManagedElement)
   END_MSG_MAP()
 
   LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
@@ -91,11 +100,16 @@ class IECommandExecutor : public CWindowImpl<IECommandExecutor> {
   LRESULT OnRefreshManagedElements(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
   LRESULT OnHandleUnexpectedAlerts(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
   LRESULT OnQuit(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
+  LRESULT OnScriptWait(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
+  LRESULT OnGetManagedElement(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
+  LRESULT OnAddManagedElement(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
+  LRESULT OnRemoveManagedElement(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
 
   std::string session_id(void) const { return this->session_id_; }
 
   static unsigned int WINAPI ThreadProc(LPVOID lpParameter);
   static unsigned int WINAPI WaitThreadProc(LPVOID lpParameter);
+  static unsigned int WINAPI ScriptWaitThreadProc(LPVOID lpParameter);
 
   std::string current_browser_id(void) const { 
     return this->current_browser_id_; 
@@ -130,6 +144,8 @@ class IECommandExecutor : public CWindowImpl<IECommandExecutor> {
                      const std::string& criteria,
                      Json::Value* found_elements) const;
 
+  HWND window_handle(void) const { return this->m_hWnd; }
+
   unsigned long long implicit_wait_timeout(void) const {
     return this->implicit_wait_timeout_; 
   }

cpp/iedriver/IECommandHandler.cpp

@@ -43,39 +43,7 @@ int IECommandHandler::GetElement(const IECommandExecutor& executor,
                                  const std::string& element_id,
                                  ElementHandle* element_wrapper) {
   LOG(TRACE) << "Entering IECommandHandler::GetElement";
-
-  ElementHandle candidate_wrapper;
-  int result = executor.GetManagedElement(element_id, &candidate_wrapper);
-  if (result != WD_SUCCESS) {
-    LOG(WARN) << "Unable to get managed element, element not found";
-    return ENOSUCHELEMENT;
-  } else {
-    if (!candidate_wrapper->IsAttachedToDom()) {
-      LOG(WARN) << "Found managed element is no longer valid";
-      IECommandExecutor& mutable_executor = const_cast<IECommandExecutor&>(executor);
-      mutable_executor.RemoveManagedElement(element_id);
-      return EOBSOLETEELEMENT;
-    } else {
-      // If the element is attached to the DOM, validate that its document
-      // is the currently-focused document (via frames).
-      BrowserHandle current_browser;
-      executor.GetCurrentBrowser(&current_browser);
-      CComPtr<IHTMLDocument2> focused_doc;
-      current_browser->GetDocument(&focused_doc);
-
-      CComPtr<IDispatch> parent_doc_dispatch;
-      candidate_wrapper->element()->get_document(&parent_doc_dispatch);
-
-      if (focused_doc.IsEqualObject(parent_doc_dispatch)) {
-        *element_wrapper = candidate_wrapper;
-        return WD_SUCCESS;
-      } else {
-        LOG(WARN) << "Found managed element's document is not currently focused";
-      }
-    }
-  }
-
-  return EOBSOLETEELEMENT;
+  return executor.GetManagedElement(element_id, element_wrapper);
 }
 
 Json::Value IECommandHandler::RecreateJsonParameterObject(const ParametersMap& command_parameters) {