Source/WebDriver/Session.cpp

   1 /*
   2  * Copyright (C) 2017 Igalia S.L.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "Session.h"
  28
  29 #include "CommandResult.h"
  30 #include "SessionHost.h"
  31 #include "WebDriverAtoms.h"
  32 #include <wtf/CryptographicallyRandomNumber.h>
  33 #include <wtf/HexNumber.h>
  34 #include <wtf/UUID.h>
  35
  36 namespace WebDriver {
  37
  38 // The web element identifier is a constant defined by the spec in Section 11 Elements.
  39 // https://www.w3.org/TR/webdriver/#elements
  40 static const String webElementIdentifier = ASCIILiteral("element-6066-11e4-a52e-4f735466cecf");
  41
  42 Session::Session(std::unique_ptr<SessionHost>&& host)
  43     : m_host(WTFMove(host))
  44     , m_id(createCanonicalUUIDString())
  45 {
  46 }
  47
  48 Session::~Session()
  49 {
  50 }
  51
  52 const Capabilities& Session::capabilities() const
  53 {
  54     return m_host->capabilities();
  55 }
  56
  57 static std::optional<String> firstWindowHandleInResult(JSON::Value& result)
  58 {
  59     RefPtr<JSON::Array> handles;
  60     if (result.asArray(handles) && handles->length()) {
  61         auto handleValue = handles->get(0);
  62         String handle;
  63         if (handleValue->asString(handle))
  64             return handle;
  65     }
  66     return std::nullopt;
  67 }
  68
  69 void Session::closeAllToplevelBrowsingContexts(const String& toplevelBrowsingContext, Function<void (CommandResult&&)>&& completionHandler)
  70 {
  71     closeTopLevelBrowsingContext(toplevelBrowsingContext, [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
  72         if (result.isError()) {
  73             completionHandler(WTFMove(result));
  74             return;
  75         }
  76         if (auto handle = firstWindowHandleInResult(*result.result())) {
  77             closeAllToplevelBrowsingContexts(handle.value(), WTFMove(completionHandler));
  78             return;
  79         }
  80         completionHandler(CommandResult::success());
  81     });
  82 }
  83
  84 void Session::close(Function<void (CommandResult&&)>&& completionHandler)
  85 {
  86     m_toplevelBrowsingContext = std::nullopt;
  87     getWindowHandles([this, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
  88         if (result.isError()) {
  89             completionHandler(WTFMove(result));
  90             return;
  91         }
  92         if (auto handle = firstWindowHandleInResult(*result.result())) {
  93             closeAllToplevelBrowsingContexts(handle.value(), WTFMove(completionHandler));
  94             return;
  95         }
  96         completionHandler(CommandResult::success());
  97     });
  98 }
  99
 100 void Session::setTimeouts(const Timeouts& timeouts, Function<void (CommandResult&&)>&& completionHandler)
 101 {
 102     if (timeouts.script)
 103         m_timeouts.script = timeouts.script;
 104     if (timeouts.pageLoad)
 105         m_timeouts.pageLoad = timeouts.pageLoad;
 106     if (timeouts.implicit)
 107         m_timeouts.implicit = timeouts.implicit;
 108     completionHandler(CommandResult::success());
 109 }
 110
 111 void Session::switchToTopLevelBrowsingContext(std::optional<String> toplevelBrowsingContext)
 112 {
 113     m_toplevelBrowsingContext = toplevelBrowsingContext;
 114     m_currentBrowsingContext = std::nullopt;
 115 }
 116
 117 void Session::switchToBrowsingContext(std::optional<String> browsingContext)
 118 {
 119     // Automation sends empty strings for main frame.
 120     if (!browsingContext || browsingContext.value().isEmpty())
 121         m_currentBrowsingContext = std::nullopt;
 122     else
 123         m_currentBrowsingContext = browsingContext;
 124 }
 125
 126 std::optional<String> Session::pageLoadStrategyString() const
 127 {
 128     if (!capabilities().pageLoadStrategy)
 129         return std::nullopt;
 130
 131     switch (capabilities().pageLoadStrategy.value()) {
 132     case PageLoadStrategy::None:
 133         return String("None");
 134     case PageLoadStrategy::Normal:
 135         return String("Normal");
 136     case PageLoadStrategy::Eager:
 137         return String("Eager");
 138     }
 139
 140     return std::nullopt;
 141 }
 142
 143 void Session::createTopLevelBrowsingContext(Function<void (CommandResult&&)>&& completionHandler)
 144 {
 145     ASSERT(!m_toplevelBrowsingContext.value());
 146     m_host->startAutomationSession(m_id, [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](std::optional<String> errorMessage) mutable {
 147         if (errorMessage) {
 148             completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError, errorMessage.value()));
 149             return;
 150         }
 151         m_host->sendCommandToBackend(ASCIILiteral("createBrowsingContext"), nullptr, [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) mutable {
 152             if (response.isError || !response.responseObject) {
 153                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
 154                 return;
 155             }
 156             String handle;
 157             if (!response.responseObject->getString(ASCIILiteral("handle"), handle)) {
 158                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 159                 return;
 160             }
 161             switchToTopLevelBrowsingContext(handle);
 162             completionHandler(CommandResult::success());
 163         });
 164     });
 165 }
 166
 167 void Session::handleUserPrompts(Function<void (CommandResult&&)>&& completionHandler)
 168 {
 169     RefPtr<JSON::Object> parameters = JSON::Object::create();
 170     parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
 171     m_host->sendCommandToBackend(ASCIILiteral("isShowingJavaScriptDialog"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) mutable {
 172         if (response.isError || !response.responseObject) {
 173             completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
 174             return;
 175         }
 176         bool isShowingJavaScriptDialog;
 177         if (!response.responseObject->getBoolean("result", isShowingJavaScriptDialog)) {
 178             completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 179             return;
 180         }
 181
 182         if (!isShowingJavaScriptDialog) {
 183             completionHandler(CommandResult::success());
 184             return;
 185         }
 186
 187         handleUnexpectedAlertOpen(WTFMove(completionHandler));
 188     });
 189 }
 190
 191 void Session::handleUnexpectedAlertOpen(Function<void (CommandResult&&)>&& completionHandler)
 192 {
 193     if (!capabilities().unhandledPromptBehavior) {
 194         reportUnexpectedAlertOpen([this, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
 195             dismissAlert([this, errorResult = WTFMove(result), completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
 196                 if (result.isError()) {
 197                     completionHandler(WTFMove(result));
 198                     return;
 199                 }
 200                 completionHandler(WTFMove(errorResult));
 201             });
 202         });
 203         return;
 204     }
 205
 206     switch (capabilities().unhandledPromptBehavior.value()) {
 207     case UnhandledPromptBehavior::Dismiss:
 208         dismissAlert(WTFMove(completionHandler));
 209         break;
 210     case UnhandledPromptBehavior::Accept:
 211         acceptAlert(WTFMove(completionHandler));
 212         break;
 213     case UnhandledPromptBehavior::Ignore:
 214         reportUnexpectedAlertOpen(WTFMove(completionHandler));
 215         break;
 216     }
 217 }
 218
 219 void Session::reportUnexpectedAlertOpen(Function<void (CommandResult&&)>&& completionHandler)
 220 {
 221     getAlertText([this, completionHandler = WTFMove(completionHandler)](CommandResult&& result) {
 222         std::optional<String> alertText;
 223         if (!result.isError()) {
 224             String valueString;
 225             if (result.result()->asString(valueString))
 226                 alertText = valueString;
 227         }
 228         auto errorResult = CommandResult::fail(CommandResult::ErrorCode::UnexpectedAlertOpen);
 229         if (alertText) {
 230             RefPtr<JSON::Object> additonalData = JSON::Object::create();
 231             additonalData->setString(ASCIILiteral("text"), alertText.value());
 232             errorResult.setAdditionalErrorData(WTFMove(additonalData));
 233         }
 234         completionHandler(WTFMove(errorResult));
 235     });
 236 }
 237
 238 void Session::go(const String& url, Function<void (CommandResult&&)>&& completionHandler)
 239 {
 240     if (!m_toplevelBrowsingContext) {
 241         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
 242         return;
 243     }
 244
 245     handleUserPrompts([this, url, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
 246         if (result.isError()) {
 247             completionHandler(WTFMove(result));
 248             return;
 249         }
 250
 251         RefPtr<JSON::Object> parameters = JSON::Object::create();
 252         parameters->setString(ASCIILiteral("handle"), m_toplevelBrowsingContext.value());
 253         parameters->setString(ASCIILiteral("url"), url);
 254         if (m_timeouts.pageLoad)
 255             parameters->setInteger(ASCIILiteral("pageLoadTimeout"), m_timeouts.pageLoad.value().millisecondsAs<int>());
 256         if (auto pageLoadStrategy = pageLoadStrategyString())
 257             parameters->setString(ASCIILiteral("pageLoadStrategy"), pageLoadStrategy.value());
 258         m_host->sendCommandToBackend(ASCIILiteral("navigateBrowsingContext"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
 259             if (response.isError) {
 260                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
 261                 return;
 262             }
 263             switchToBrowsingContext(std::nullopt);
 264             completionHandler(CommandResult::success());
 265         });
 266     });
 267 }
 268
 269 void Session::getCurrentURL(Function<void (CommandResult&&)>&& completionHandler)
 270 {
 271     if (!m_toplevelBrowsingContext) {
 272         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
 273         return;
 274     }
 275
 276     handleUserPrompts([this, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
 277         if (result.isError()) {
 278             completionHandler(WTFMove(result));
 279             return;
 280         }
 281
 282         RefPtr<JSON::Object> parameters = JSON::Object::create();
 283         parameters->setString(ASCIILiteral("handle"), m_toplevelBrowsingContext.value());
 284         m_host->sendCommandToBackend(ASCIILiteral("getBrowsingContext"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
 285             if (response.isError || !response.responseObject) {
 286                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
 287                 return;
 288             }
 289             RefPtr<JSON::Object> browsingContext;
 290             if (!response.responseObject->getObject("context", browsingContext)) {
 291                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 292                 return;
 293             }
 294             String url;
 295             if (!browsingContext->getString("url", url)) {
 296                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 297                 return;
 298             }
 299             completionHandler(CommandResult::success(JSON::Value::create(url)));
 300         });
 301     });
 302 }
 303
 304 void Session::back(Function<void (CommandResult&&)>&& completionHandler)
 305 {
 306     if (!m_toplevelBrowsingContext) {
 307         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
 308         return;
 309     }
 310
 311     handleUserPrompts([this, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
 312         if (result.isError()) {
 313             completionHandler(WTFMove(result));
 314             return;
 315         }
 316         RefPtr<JSON::Object> parameters = JSON::Object::create();
 317         parameters->setString(ASCIILiteral("handle"), m_toplevelBrowsingContext.value());
 318         if (m_timeouts.pageLoad)
 319             parameters->setInteger(ASCIILiteral("pageLoadTimeout"), m_timeouts.pageLoad.value().millisecondsAs<int>());
 320         if (auto pageLoadStrategy = pageLoadStrategyString())
 321             parameters->setString(ASCIILiteral("pageLoadStrategy"), pageLoadStrategy.value());
 322         m_host->sendCommandToBackend(ASCIILiteral("goBackInBrowsingContext"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
 323             if (response.isError) {
 324                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
 325                 return;
 326             }
 327             switchToBrowsingContext(std::nullopt);
 328             completionHandler(CommandResult::success());
 329         });
 330     });
 331 }
 332
 333 void Session::forward(Function<void (CommandResult&&)>&& completionHandler)
 334 {
 335     if (!m_toplevelBrowsingContext) {
 336         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
 337         return;
 338     }
 339
 340     handleUserPrompts([this, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
 341         if (result.isError()) {
 342             completionHandler(WTFMove(result));
 343             return;
 344         }
 345         RefPtr<JSON::Object> parameters = JSON::Object::create();
 346         parameters->setString(ASCIILiteral("handle"), m_toplevelBrowsingContext.value());
 347         if (m_timeouts.pageLoad)
 348             parameters->setInteger(ASCIILiteral("pageLoadTimeout"), m_timeouts.pageLoad.value().millisecondsAs<int>());
 349         if (auto pageLoadStrategy = pageLoadStrategyString())
 350             parameters->setString(ASCIILiteral("pageLoadStrategy"), pageLoadStrategy.value());
 351         m_host->sendCommandToBackend(ASCIILiteral("goForwardInBrowsingContext"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
 352             if (response.isError) {
 353                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
 354                 return;
 355             }
 356             switchToBrowsingContext(std::nullopt);
 357             completionHandler(CommandResult::success());
 358         });
 359     });
 360 }
 361
 362 void Session::refresh(Function<void (CommandResult&&)>&& completionHandler)
 363 {
 364     if (!m_toplevelBrowsingContext) {
 365         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
 366         return;
 367     }
 368
 369     handleUserPrompts([this, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
 370         if (result.isError()) {
 371             completionHandler(WTFMove(result));
 372             return;
 373         }
 374         RefPtr<JSON::Object> parameters = JSON::Object::create();
 375         parameters->setString(ASCIILiteral("handle"), m_toplevelBrowsingContext.value());
 376         if (m_timeouts.pageLoad)
 377             parameters->setInteger(ASCIILiteral("pageLoadTimeout"), m_timeouts.pageLoad.value().millisecondsAs<int>());
 378         if (auto pageLoadStrategy = pageLoadStrategyString())
 379             parameters->setString(ASCIILiteral("pageLoadStrategy"), pageLoadStrategy.value());
 380         m_host->sendCommandToBackend(ASCIILiteral("reloadBrowsingContext"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
 381             if (response.isError) {
 382                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
 383                 return;
 384             }
 385             switchToBrowsingContext(std::nullopt);
 386             completionHandler(CommandResult::success());
 387         });
 388     });
 389 }
 390
 391 void Session::getTitle(Function<void (CommandResult&&)>&& completionHandler)
 392 {
 393     if (!m_toplevelBrowsingContext) {
 394         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
 395         return;
 396     }
 397
 398     handleUserPrompts([this, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
 399         if (result.isError()) {
 400             completionHandler(WTFMove(result));
 401             return;
 402         }
 403         RefPtr<JSON::Object> parameters = JSON::Object::create();
 404         parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
 405         parameters->setString(ASCIILiteral("function"), ASCIILiteral("function() { return document.title; }"));
 406         parameters->setArray(ASCIILiteral("arguments"), JSON::Array::create());
 407         m_host->sendCommandToBackend(ASCIILiteral("evaluateJavaScriptFunction"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
 408             if (response.isError || !response.responseObject) {
 409                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
 410                 return;
 411             }
 412             String valueString;
 413             if (!response.responseObject->getString(ASCIILiteral("result"), valueString)) {
 414                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 415                 return;
 416             }
 417             RefPtr<JSON::Value> resultValue;
 418             if (!JSON::Value::parseJSON(valueString, resultValue)) {
 419                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 420                 return;
 421             }
 422             completionHandler(CommandResult::success(WTFMove(resultValue)));
 423         });
 424     });
 425 }
 426
 427 void Session::getWindowHandle(Function<void (CommandResult&&)>&& completionHandler)
 428 {
 429     if (!m_toplevelBrowsingContext) {
 430         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
 431         return;
 432     }
 433
 434     RefPtr<JSON::Object> parameters = JSON::Object::create();
 435     parameters->setString(ASCIILiteral("handle"), m_toplevelBrowsingContext.value());
 436     m_host->sendCommandToBackend(ASCIILiteral("getBrowsingContext"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
 437         if (response.isError || !response.responseObject) {
 438             completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
 439             return;
 440         }
 441         RefPtr<JSON::Object> browsingContext;
 442         if (!response.responseObject->getObject(ASCIILiteral("context"), browsingContext)) {
 443             completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 444             return;
 445         }
 446         String handle;
 447         if (!browsingContext->getString(ASCIILiteral("handle"), handle)) {
 448             completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 449             return;
 450         }
 451         completionHandler(CommandResult::success(JSON::Value::create(handle)));
 452     });
 453 }
 454
 455 void Session::closeTopLevelBrowsingContext(const String& toplevelBrowsingContext, Function<void (CommandResult&&)>&& completionHandler)
 456 {
 457     RefPtr<JSON::Object> parameters = JSON::Object::create();
 458     parameters->setString(ASCIILiteral("handle"), toplevelBrowsingContext);
 459     m_host->sendCommandToBackend(ASCIILiteral("closeBrowsingContext"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) mutable {
 460         if (!m_host->isConnected()) {
 461             // Closing the browsing context made the browser quit.
 462             completionHandler(CommandResult::success(JSON::Array::create()));
 463             return;
 464         }
 465         if (response.isError) {
 466             completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
 467             return;
 468         }
 469
 470         getWindowHandles([this, completionHandler = WTFMove(completionHandler)](CommandResult&& result) {
 471             if (!m_host->isConnected()) {
 472                 // Closing the browsing context made the browser quit.
 473                 completionHandler(CommandResult::success(JSON::Array::create()));
 474                 return;
 475             }
 476             completionHandler(WTFMove(result));
 477         });
 478     });
 479 }
 480
 481 void Session::closeWindow(Function<void (CommandResult&&)>&& completionHandler)
 482 {
 483     if (!m_toplevelBrowsingContext) {
 484         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
 485         return;
 486     }
 487
 488     handleUserPrompts([this, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
 489         if (result.isError()) {
 490             completionHandler(WTFMove(result));
 491             return;
 492         }
 493         auto toplevelBrowsingContext = std::exchange(m_toplevelBrowsingContext, std::nullopt);
 494         closeTopLevelBrowsingContext(toplevelBrowsingContext.value(), WTFMove(completionHandler));
 495     });
 496 }
 497
 498 void Session::switchToWindow(const String& windowHandle, Function<void (CommandResult&&)>&& completionHandler)
 499 {
 500     RefPtr<JSON::Object> parameters = JSON::Object::create();
 501     parameters->setString(ASCIILiteral("browsingContextHandle"), windowHandle);
 502     m_host->sendCommandToBackend(ASCIILiteral("switchToBrowsingContext"), WTFMove(parameters), [this, protectedThis = makeRef(*this), windowHandle, completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
 503         if (response.isError) {
 504             completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
 505             return;
 506         }
 507         switchToTopLevelBrowsingContext(windowHandle);
 508         completionHandler(CommandResult::success());
 509     });
 510 }
 511
 512 void Session::getWindowHandles(Function<void (CommandResult&&)>&& completionHandler)
 513 {
 514     m_host->sendCommandToBackend(ASCIILiteral("getBrowsingContexts"), JSON::Object::create(), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
 515         if (response.isError || !response.responseObject) {
 516             completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
 517             return;
 518         }
 519         RefPtr<JSON::Array> browsingContextArray;
 520         if (!response.responseObject->getArray(ASCIILiteral("contexts"), browsingContextArray)) {
 521             completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 522             return;
 523         }
 524         RefPtr<JSON::Array> windowHandles = JSON::Array::create();
 525         for (unsigned i = 0; i < browsingContextArray->length(); ++i) {
 526             RefPtr<JSON::Value> browsingContextValue = browsingContextArray->get(i);
 527             RefPtr<JSON::Object> browsingContext;
 528             if (!browsingContextValue->asObject(browsingContext)) {
 529                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 530                 return;
 531             }
 532
 533             String handle;
 534             if (!browsingContext->getString(ASCIILiteral("handle"), handle)) {
 535                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 536                 return;
 537             }
 538
 539             windowHandles->pushString(handle);
 540         }
 541         completionHandler(CommandResult::success(WTFMove(windowHandles)));
 542     });
 543 }
 544
 545 void Session::switchToFrame(RefPtr<JSON::Value>&& frameID, Function<void (CommandResult&&)>&& completionHandler)
 546 {
 547     if (!m_toplevelBrowsingContext) {
 548         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
 549         return;
 550     }
 551
 552     if (frameID->isNull()) {
 553         switchToBrowsingContext(std::nullopt);
 554         completionHandler(CommandResult::success());
 555         return;
 556     }
 557
 558     handleUserPrompts([this, frameID = WTFMove(frameID), completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
 559         if (result.isError()) {
 560             completionHandler(WTFMove(result));
 561             return;
 562         }
 563         RefPtr<JSON::Object> parameters = JSON::Object::create();
 564         parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
 565         if (m_currentBrowsingContext)
 566             parameters->setString(ASCIILiteral("frameHandle"), m_currentBrowsingContext.value());
 567
 568         int frameIndex;
 569         if (frameID->asInteger(frameIndex)) {
 570             if (frameIndex < 0 || frameIndex > USHRT_MAX) {
 571                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchFrame));
 572                 return;
 573             }
 574             parameters->setInteger(ASCIILiteral("ordinal"), frameIndex);
 575         } else {
 576             String frameElementID = extractElementID(*frameID);
 577             if (!frameElementID.isEmpty())
 578                 parameters->setString(ASCIILiteral("nodeHandle"), frameElementID);
 579             else {
 580                 String frameName;
 581                 if (!frameID->asString(frameName)) {
 582                     completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchFrame));
 583                     return;
 584                 }
 585                 parameters->setString(ASCIILiteral("name"), frameName);
 586             }
 587         }
 588
 589         m_host->sendCommandToBackend(ASCIILiteral("resolveChildFrameHandle"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
 590             if (response.isError || !response.responseObject) {
 591                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
 592                 return;
 593             }
 594             String frameHandle;
 595             if (!response.responseObject->getString(ASCIILiteral("result"), frameHandle)) {
 596                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 597                 return;
 598             }
 599             switchToBrowsingContext(frameHandle);
 600             completionHandler(CommandResult::success());
 601         });
 602     });
 603 }
 604
 605 void Session::switchToParentFrame(Function<void (CommandResult&&)>&& completionHandler)
 606 {
 607     if (!m_toplevelBrowsingContext) {
 608         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
 609         return;
 610     }
 611
 612     if (!m_currentBrowsingContext) {
 613         completionHandler(CommandResult::success());
 614         return;
 615     }
 616
 617     handleUserPrompts([this, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
 618         if (result.isError()) {
 619             completionHandler(WTFMove(result));
 620             return;
 621         }
 622         RefPtr<JSON::Object> parameters = JSON::Object::create();
 623         parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
 624         parameters->setString(ASCIILiteral("frameHandle"), m_currentBrowsingContext.value());
 625         m_host->sendCommandToBackend(ASCIILiteral("resolveParentFrameHandle"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
 626             if (response.isError || !response.responseObject) {
 627                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
 628                 return;
 629             }
 630             String frameHandle;
 631             if (!response.responseObject->getString(ASCIILiteral("result"), frameHandle)) {
 632                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 633                 return;
 634             }
 635             switchToBrowsingContext(frameHandle);
 636             completionHandler(CommandResult::success());
 637         });
 638     });
 639 }
 640
 641 void Session::getToplevelBrowsingContextRect(Function<void (CommandResult&&)>&& completionHandler)
 642 {
 643     RefPtr<JSON::Object> parameters = JSON::Object::create();
 644     parameters->setString(ASCIILiteral("handle"), m_toplevelBrowsingContext.value());
 645     m_host->sendCommandToBackend(ASCIILiteral("getBrowsingContext"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
 646         if (response.isError || !response.responseObject) {
 647             completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
 648             return;
 649         }
 650         RefPtr<JSON::Object> browsingContext;
 651         if (!response.responseObject->getObject(ASCIILiteral("context"), browsingContext)) {
 652             completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 653             return;
 654         }
 655         RefPtr<JSON::Object> windowOrigin;
 656         double x, y;
 657         if (!browsingContext->getObject(ASCIILiteral("windowOrigin"), windowOrigin)
 658             || !windowOrigin->getDouble(ASCIILiteral("x"), x)
 659             || !windowOrigin->getDouble(ASCIILiteral("y"), y)) {
 660             completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 661             return;
 662         }
 663         RefPtr<JSON::Object> windowSize;
 664         double width, height;
 665         if (!browsingContext->getObject(ASCIILiteral("windowSize"), windowSize)
 666             || !windowSize->getDouble(ASCIILiteral("width"), width)
 667             || !windowSize->getDouble(ASCIILiteral("height"), width)) {
 668             completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 669             return;
 670         }
 671         auto windowRect = JSON::Object::create();
 672         windowRect->setDouble(ASCIILiteral("x"), x);
 673         windowRect->setDouble(ASCIILiteral("y"), y);
 674         windowRect->setDouble(ASCIILiteral("width"), width);
 675         windowRect->setDouble(ASCIILiteral("height"), height);
 676         completionHandler(CommandResult::success(WTFMove(windowRect)));
 677     });
 678 }
 679
 680 void Session::moveToplevelBrowsingContextWindow(double x, double y, Function<void (CommandResult&&)>&& completionHandler)
 681 {
 682     RefPtr<JSON::Object> parameters = JSON::Object::create();
 683     parameters->setString(ASCIILiteral("handle"), m_toplevelBrowsingContext.value());
 684     RefPtr<JSON::Object> windowOrigin = JSON::Object::create();
 685     windowOrigin->setDouble("x", x);
 686     windowOrigin->setDouble("y", y);
 687     parameters->setObject(ASCIILiteral("origin"), WTFMove(windowOrigin));
 688     m_host->sendCommandToBackend(ASCIILiteral("moveWindowOfBrowsingContext"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
 689         if (response.isError) {
 690             completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
 691             return;
 692         }
 693         completionHandler(CommandResult::success());
 694     });
 695 }
 696
 697 void Session::resizeToplevelBrowsingContextWindow(double width, double height, Function<void (CommandResult&&)>&& completionHandler)
 698 {
 699     RefPtr<JSON::Object> parameters = JSON::Object::create();
 700     parameters->setString(ASCIILiteral("handle"), m_toplevelBrowsingContext.value());
 701     RefPtr<JSON::Object> windowSize = JSON::Object::create();
 702     windowSize->setDouble("width", width);
 703     windowSize->setDouble("height", height);
 704     parameters->setObject(ASCIILiteral("size"), WTFMove(windowSize));
 705     m_host->sendCommandToBackend(ASCIILiteral("resizeWindowOfBrowsingContext"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
 706         if (response.isError) {
 707             completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
 708             return;
 709         }
 710         completionHandler(CommandResult::success());
 711     });
 712 }
 713
 714 void Session::getWindowRect(Function<void (CommandResult&&)>&& completionHandler)
 715 {
 716     if (!m_toplevelBrowsingContext) {
 717         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
 718         return;
 719     }
 720
 721     handleUserPrompts([this, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
 722         if (result.isError()) {
 723             completionHandler(WTFMove(result));
 724             return;
 725         }
 726         getToplevelBrowsingContextRect(WTFMove(completionHandler));
 727     });
 728 }
 729
 730 void Session::setWindowRect(std::optional<double> x, std::optional<double> y, std::optional<double> width, std::optional<double> height, Function<void (CommandResult&&)>&& completionHandler)
 731 {
 732     if (!m_toplevelBrowsingContext) {
 733         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
 734         return;
 735     }
 736
 737     handleUserPrompts([this, x, y, width, height, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
 738         if (result.isError()) {
 739             completionHandler(WTFMove(result));
 740             return;
 741         }
 742
 743         if (width && height)  {
 744             resizeToplevelBrowsingContextWindow(width.value(), height.value(), [this, x, y, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
 745                 if (result.isError()) {
 746                     completionHandler(WTFMove(result));
 747                     return;
 748                 }
 749                 if (!x || !y) {
 750                     getToplevelBrowsingContextRect(WTFMove(completionHandler));
 751                     return;
 752                 }
 753
 754                 moveToplevelBrowsingContextWindow(x.value(), y.value(), [this, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
 755                     if (result.isError()) {
 756                         completionHandler(WTFMove(result));
 757                         return;
 758                     }
 759                     getToplevelBrowsingContextRect(WTFMove(completionHandler));
 760                 });
 761             });
 762             return;
 763         }
 764
 765         if (x && y) {
 766             moveToplevelBrowsingContextWindow(x.value(), y.value(), [this, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
 767                 if (result.isError()) {
 768                     completionHandler(WTFMove(result));
 769                     return;
 770                 }
 771                 getToplevelBrowsingContextRect(WTFMove(completionHandler));
 772             });
 773             return;
 774         }
 775
 776         getToplevelBrowsingContextRect(WTFMove(completionHandler));
 777     });
 778 }
 779
 780 RefPtr<JSON::Object> Session::createElement(RefPtr<JSON::Value>&& value)
 781 {
 782     RefPtr<JSON::Object> valueObject;
 783     if (!value->asObject(valueObject))
 784         return nullptr;
 785
 786     String elementID;
 787     if (!valueObject->getString("session-node-" + m_id, elementID))
 788         return nullptr;
 789
 790     RefPtr<JSON::Object> elementObject = JSON::Object::create();
 791     elementObject->setString(webElementIdentifier, elementID);
 792     return elementObject;
 793 }
 794
 795 RefPtr<JSON::Object> Session::createElement(const String& elementID)
 796 {
 797     RefPtr<JSON::Object> elementObject = JSON::Object::create();
 798     elementObject->setString("session-node-" + m_id, elementID);
 799     return elementObject;
 800 }
 801
 802 RefPtr<JSON::Object> Session::extractElement(JSON::Value& value)
 803 {
 804     String elementID = extractElementID(value);
 805     return !elementID.isEmpty() ? createElement(elementID) : nullptr;
 806 }
 807
 808 String Session::extractElementID(JSON::Value& value)
 809 {
 810     RefPtr<JSON::Object> valueObject;
 811     if (!value.asObject(valueObject))
 812         return emptyString();
 813
 814     String elementID;
 815     if (!valueObject->getString(webElementIdentifier, elementID))
 816         return emptyString();
 817
 818     return elementID;
 819 }
 820
 821 void Session::computeElementLayout(const String& elementID, OptionSet<ElementLayoutOption> options, Function<void (std::optional<Rect>&&, std::optional<Point>&&, bool, RefPtr<JSON::Object>&&)>&& completionHandler)
 822 {
 823     ASSERT(m_toplevelBrowsingContext.value());
 824
 825     RefPtr<JSON::Object> parameters = JSON::Object::create();
 826     parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
 827     parameters->setString(ASCIILiteral("frameHandle"), m_currentBrowsingContext.value_or(emptyString()));
 828     parameters->setString(ASCIILiteral("nodeHandle"), elementID);
 829     parameters->setBoolean(ASCIILiteral("scrollIntoViewIfNeeded"), options.contains(ElementLayoutOption::ScrollIntoViewIfNeeded));
 830     parameters->setString(ASCIILiteral("coordinateSystem"), options.contains(ElementLayoutOption::UseViewportCoordinates) ? ASCIILiteral("LayoutViewport") : ASCIILiteral("Page"));
 831     m_host->sendCommandToBackend(ASCIILiteral("computeElementLayout"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) mutable {
 832         if (response.isError || !response.responseObject) {
 833             completionHandler(std::nullopt, std::nullopt, false, WTFMove(response.responseObject));
 834             return;
 835         }
 836         RefPtr<JSON::Object> rectObject;
 837         if (!response.responseObject->getObject(ASCIILiteral("rect"), rectObject)) {
 838             completionHandler(std::nullopt, std::nullopt, false, nullptr);
 839             return;
 840         }
 841         std::optional<int> elementX;
 842         std::optional<int> elementY;
 843         RefPtr<JSON::Object> elementPosition;
 844         if (rectObject->getObject(ASCIILiteral("origin"), elementPosition)) {
 845             int x, y;
 846             if (elementPosition->getInteger(ASCIILiteral("x"), x) && elementPosition->getInteger(ASCIILiteral("y"), y)) {
 847                 elementX = x;
 848                 elementY = y;
 849             }
 850         }
 851         if (!elementX || !elementY) {
 852             completionHandler(std::nullopt, std::nullopt, false, nullptr);
 853             return;
 854         }
 855         std::optional<int> elementWidth;
 856         std::optional<int> elementHeight;
 857         RefPtr<JSON::Object> elementSize;
 858         if (rectObject->getObject(ASCIILiteral("size"), elementSize)) {
 859             int width, height;
 860             if (elementSize->getInteger(ASCIILiteral("width"), width) && elementSize->getInteger(ASCIILiteral("height"), height)) {
 861                 elementWidth = width;
 862                 elementHeight = height;
 863             }
 864         }
 865         if (!elementWidth || !elementHeight) {
 866             completionHandler(std::nullopt, std::nullopt, false, nullptr);
 867             return;
 868         }
 869         Rect rect = { { elementX.value(), elementY.value() }, { elementWidth.value(), elementHeight.value() } };
 870
 871         bool isObscured;
 872         if (!response.responseObject->getBoolean(ASCIILiteral("isObscured"), isObscured)) {
 873             completionHandler(std::nullopt, std::nullopt, false, nullptr);
 874             return;
 875         }
 876         RefPtr<JSON::Object> inViewCenterPointObject;
 877         if (!response.responseObject->getObject(ASCIILiteral("inViewCenterPoint"), inViewCenterPointObject)) {
 878             completionHandler(rect, std::nullopt, isObscured, nullptr);
 879             return;
 880         }
 881         int inViewCenterPointX, inViewCenterPointY;
 882         if (!inViewCenterPointObject->getInteger(ASCIILiteral("x"), inViewCenterPointX)
 883             || !inViewCenterPointObject->getInteger(ASCIILiteral("y"), inViewCenterPointY)) {
 884             completionHandler(std::nullopt, std::nullopt, isObscured, nullptr);
 885             return;
 886         }
 887         Point inViewCenterPoint = { inViewCenterPointX, inViewCenterPointY };
 888         completionHandler(rect, inViewCenterPoint, isObscured, nullptr);
 889     });
 890 }
 891
 892 void Session::findElements(const String& strategy, const String& selector, FindElementsMode mode, const String& rootElementID, Function<void (CommandResult&&)>&& completionHandler)
 893 {
 894     if (!m_toplevelBrowsingContext) {
 895         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
 896         return;
 897     }
 898
 899     auto implicitWait = m_timeouts.implicit.value_or(0_s);
 900     RefPtr<JSON::Array> arguments = JSON::Array::create();
 901     arguments->pushString(JSON::Value::create(strategy)->toJSONString());
 902     if (rootElementID.isEmpty())
 903         arguments->pushString(JSON::Value::null()->toJSONString());
 904     else
 905         arguments->pushString(createElement(rootElementID)->toJSONString());
 906     arguments->pushString(JSON::Value::create(selector)->toJSONString());
 907     arguments->pushString(JSON::Value::create(mode == FindElementsMode::Single)->toJSONString());
 908     arguments->pushString(JSON::Value::create(implicitWait.milliseconds())->toJSONString());
 909
 910     RefPtr<JSON::Object> parameters = JSON::Object::create();
 911     parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
 912     if (m_currentBrowsingContext)
 913         parameters->setString(ASCIILiteral("frameHandle"), m_currentBrowsingContext.value());
 914     parameters->setString(ASCIILiteral("function"), FindNodesJavaScript);
 915     parameters->setArray(ASCIILiteral("arguments"), WTFMove(arguments));
 916     parameters->setBoolean(ASCIILiteral("expectsImplicitCallbackArgument"), true);
 917     // If there's an implicit wait, use one second more as callback timeout.
 918     if (implicitWait)
 919         parameters->setInteger(ASCIILiteral("callbackTimeout"), Seconds(implicitWait + 1_s).millisecondsAs<int>());
 920
 921     m_host->sendCommandToBackend(ASCIILiteral("evaluateJavaScriptFunction"), WTFMove(parameters), [this, protectedThis = makeRef(*this), mode, completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
 922         if (response.isError || !response.responseObject) {
 923             completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
 924             return;
 925         }
 926         String valueString;
 927         if (!response.responseObject->getString(ASCIILiteral("result"), valueString)) {
 928             completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 929             return;
 930         }
 931         RefPtr<JSON::Value> resultValue;
 932         if (!JSON::Value::parseJSON(valueString, resultValue)) {
 933             completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 934             return;
 935         }
 936
 937         switch (mode) {
 938         case FindElementsMode::Single: {
 939             RefPtr<JSON::Object> elementObject = createElement(WTFMove(resultValue));
 940             if (!elementObject) {
 941                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchElement));
 942                 return;
 943             }
 944             completionHandler(CommandResult::success(WTFMove(elementObject)));
 945             break;
 946         }
 947         case FindElementsMode::Multiple: {
 948             RefPtr<JSON::Array> elementsArray;
 949             if (!resultValue->asArray(elementsArray)) {
 950                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchElement));
 951                 return;
 952             }
 953             RefPtr<JSON::Array> elementObjectsArray = JSON::Array::create();
 954             unsigned elementsArrayLength = elementsArray->length();
 955             for (unsigned i = 0; i < elementsArrayLength; ++i) {
 956                 if (auto elementObject = createElement(elementsArray->get(i)))
 957                     elementObjectsArray->pushObject(WTFMove(elementObject));
 958             }
 959             completionHandler(CommandResult::success(WTFMove(elementObjectsArray)));
 960             break;
 961         }
 962         }
 963     });
 964 }
 965
 966 void Session::getActiveElement(Function<void (CommandResult&&)>&& completionHandler)
 967 {
 968     if (!m_toplevelBrowsingContext) {
 969         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
 970         return;
 971     }
 972
 973     handleUserPrompts([this, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
 974         if (result.isError()) {
 975             completionHandler(WTFMove(result));
 976             return;
 977         }
 978         RefPtr<JSON::Object> parameters = JSON::Object::create();
 979         parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
 980         parameters->setString(ASCIILiteral("function"), ASCIILiteral("function() { return document.activeElement; }"));
 981         parameters->setArray(ASCIILiteral("arguments"), JSON::Array::create());
 982         m_host->sendCommandToBackend(ASCIILiteral("evaluateJavaScriptFunction"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
 983             if (response.isError || !response.responseObject) {
 984                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
 985                 return;
 986             }
 987             String valueString;
 988             if (!response.responseObject->getString(ASCIILiteral("result"), valueString)) {
 989                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 990                 return;
 991             }
 992             RefPtr<JSON::Value> resultValue;
 993             if (!JSON::Value::parseJSON(valueString, resultValue)) {
 994                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
 995                 return;
 996             }
 997             RefPtr<JSON::Object> elementObject = createElement(WTFMove(resultValue));
 998             if (!elementObject) {
 999                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
1000                 return;
1001             }
1002             completionHandler(CommandResult::success(WTFMove(elementObject)));
1003         });
1004     });
1005 }
1006
1007 void Session::isElementSelected(const String& elementID, Function<void (CommandResult&&)>&& completionHandler)
1008 {
1009     if (!m_toplevelBrowsingContext) {
1010         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
1011         return;
1012     }
1013
1014     handleUserPrompts([this, elementID, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
1015         if (result.isError()) {
1016             completionHandler(WTFMove(result));
1017             return;
1018         }
1019         RefPtr<JSON::Array> arguments = JSON::Array::create();
1020         arguments->pushString(createElement(elementID)->toJSONString());
1021         arguments->pushString(JSON::Value::create("selected")->toJSONString());
1022
1023         RefPtr<JSON::Object> parameters = JSON::Object::create();
1024         parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
1025         if (m_currentBrowsingContext)
1026             parameters->setString(ASCIILiteral("frameHandle"), m_currentBrowsingContext.value());
1027         parameters->setString(ASCIILiteral("function"), ElementAttributeJavaScript);
1028         parameters->setArray(ASCIILiteral("arguments"), WTFMove(arguments));
1029         m_host->sendCommandToBackend(ASCIILiteral("evaluateJavaScriptFunction"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
1030             if (response.isError || !response.responseObject) {
1031                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
1032                 return;
1033             }
1034             String valueString;
1035             if (!response.responseObject->getString(ASCIILiteral("result"), valueString)) {
1036                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
1037                 return;
1038             }
1039             RefPtr<JSON::Value> resultValue;
1040             if (!JSON::Value::parseJSON(valueString, resultValue)) {
1041                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
1042                 return;
1043             }
1044             if (resultValue->isNull()) {
1045                 completionHandler(CommandResult::success(JSON::Value::create(false)));
1046                 return;
1047             }
1048             String booleanResult;
1049             if (!resultValue->asString(booleanResult) || booleanResult != "true") {
1050                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
1051                 return;
1052             }
1053             completionHandler(CommandResult::success(JSON::Value::create(true)));
1054         });
1055     });
1056 }
1057
1058 void Session::getElementText(const String& elementID, Function<void (CommandResult&&)>&& completionHandler)
1059 {
1060     if (!m_toplevelBrowsingContext) {
1061         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
1062         return;
1063     }
1064
1065     handleUserPrompts([this, elementID, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
1066         if (result.isError()) {
1067             completionHandler(WTFMove(result));
1068             return;
1069         }
1070         RefPtr<JSON::Array> arguments = JSON::Array::create();
1071         arguments->pushString(createElement(elementID)->toJSONString());
1072
1073         RefPtr<JSON::Object> parameters = JSON::Object::create();
1074         parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
1075         if (m_currentBrowsingContext)
1076             parameters->setString(ASCIILiteral("frameHandle"), m_currentBrowsingContext.value());
1077         // FIXME: Add an atom to properly implement this instead of just using innerText.
1078         parameters->setString(ASCIILiteral("function"), ASCIILiteral("function(element) { return element.innerText.replace(/^[^\\S\\xa0]+|[^\\S\\xa0]+$/g, '') }"));
1079         parameters->setArray(ASCIILiteral("arguments"), WTFMove(arguments));
1080         m_host->sendCommandToBackend(ASCIILiteral("evaluateJavaScriptFunction"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
1081             if (response.isError || !response.responseObject) {
1082                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
1083                 return;
1084             }
1085             String valueString;
1086             if (!response.responseObject->getString(ASCIILiteral("result"), valueString)) {
1087                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
1088                 return;
1089             }
1090             RefPtr<JSON::Value> resultValue;
1091             if (!JSON::Value::parseJSON(valueString, resultValue)) {
1092                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
1093                 return;
1094             }
1095             completionHandler(CommandResult::success(WTFMove(resultValue)));
1096         });
1097     });
1098 }
1099
1100 void Session::getElementTagName(const String& elementID, Function<void (CommandResult&&)>&& completionHandler)
1101 {
1102     if (!m_toplevelBrowsingContext) {
1103         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
1104         return;
1105     }
1106
1107     handleUserPrompts([this, elementID, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
1108         if (result.isError()) {
1109             completionHandler(WTFMove(result));
1110             return;
1111         }
1112         RefPtr<JSON::Array> arguments = JSON::Array::create();
1113         arguments->pushString(createElement(elementID)->toJSONString());
1114
1115         RefPtr<JSON::Object> parameters = JSON::Object::create();
1116         parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
1117         if (m_currentBrowsingContext)
1118             parameters->setString(ASCIILiteral("frameHandle"), m_currentBrowsingContext.value());
1119         parameters->setString(ASCIILiteral("function"), ASCIILiteral("function(element) { return element.tagName.toLowerCase() }"));
1120         parameters->setArray(ASCIILiteral("arguments"), WTFMove(arguments));
1121         m_host->sendCommandToBackend(ASCIILiteral("evaluateJavaScriptFunction"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
1122             if (response.isError || !response.responseObject) {
1123                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
1124                 return;
1125             }
1126             String valueString;
1127             if (!response.responseObject->getString(ASCIILiteral("result"), valueString)) {
1128                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
1129                 return;
1130             }
1131             RefPtr<JSON::Value> resultValue;
1132             if (!JSON::Value::parseJSON(valueString, resultValue)) {
1133                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
1134                 return;
1135             }
1136             completionHandler(CommandResult::success(WTFMove(resultValue)));
1137         });
1138     });
1139 }
1140
1141 void Session::getElementRect(const String& elementID, Function<void (CommandResult&&)>&& completionHandler)
1142 {
1143     if (!m_toplevelBrowsingContext) {
1144         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
1145         return;
1146     }
1147
1148     handleUserPrompts([this, elementID, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
1149         if (result.isError()) {
1150             completionHandler(WTFMove(result));
1151             return;
1152         }
1153         computeElementLayout(elementID, { }, [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](std::optional<Rect>&& rect, std::optional<Point>&&, bool, RefPtr<JSON::Object>&& error) {
1154             if (!rect || error) {
1155                 completionHandler(CommandResult::fail(WTFMove(error)));
1156                 return;
1157             }
1158             RefPtr<JSON::Object> rectObject = JSON::Object::create();
1159             rectObject->setInteger(ASCIILiteral("x"), rect.value().origin.x);
1160             rectObject->setInteger(ASCIILiteral("y"), rect.value().origin.y);
1161             rectObject->setInteger(ASCIILiteral("width"), rect.value().size.width);
1162             rectObject->setInteger(ASCIILiteral("height"), rect.value().size.height);
1163             completionHandler(CommandResult::success(WTFMove(rectObject)));
1164         });
1165     });
1166 }
1167
1168 void Session::isElementEnabled(const String& elementID, Function<void (CommandResult&&)>&& completionHandler)
1169 {
1170     if (!m_toplevelBrowsingContext) {
1171         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
1172         return;
1173     }
1174
1175     handleUserPrompts([this, elementID, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
1176         if (result.isError()) {
1177             completionHandler(WTFMove(result));
1178             return;
1179         }
1180         RefPtr<JSON::Array> arguments = JSON::Array::create();
1181         arguments->pushString(createElement(elementID)->toJSONString());
1182
1183         RefPtr<JSON::Object> parameters = JSON::Object::create();
1184         parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
1185         if (m_currentBrowsingContext)
1186             parameters->setString(ASCIILiteral("frameHandle"), m_currentBrowsingContext.value());
1187         parameters->setString(ASCIILiteral("function"), ASCIILiteral("function(element) { return element.disabled === undefined ? true : !element.disabled }"));
1188         parameters->setArray(ASCIILiteral("arguments"), WTFMove(arguments));
1189         m_host->sendCommandToBackend(ASCIILiteral("evaluateJavaScriptFunction"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
1190             if (response.isError || !response.responseObject) {
1191                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
1192                 return;
1193             }
1194             String valueString;
1195             if (!response.responseObject->getString(ASCIILiteral("result"), valueString)) {
1196                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
1197                 return;
1198             }
1199             RefPtr<JSON::Value> resultValue;
1200             if (!JSON::Value::parseJSON(valueString, resultValue)) {
1201                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
1202                 return;
1203             }
1204             completionHandler(CommandResult::success(WTFMove(resultValue)));
1205         });
1206     });
1207 }
1208
1209 void Session::isElementDisplayed(const String& elementID, Function<void (CommandResult&&)>&& completionHandler)
1210 {
1211     if (!m_toplevelBrowsingContext) {
1212         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
1213         return;
1214     }
1215
1216     handleUserPrompts([this, elementID, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
1217         if (result.isError()) {
1218             completionHandler(WTFMove(result));
1219             return;
1220         }
1221         RefPtr<JSON::Array> arguments = JSON::Array::create();
1222         arguments->pushString(createElement(elementID)->toJSONString());
1223
1224         RefPtr<JSON::Object> parameters = JSON::Object::create();
1225         parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
1226         if (m_currentBrowsingContext)
1227             parameters->setString(ASCIILiteral("frameHandle"), m_currentBrowsingContext.value());
1228         parameters->setString(ASCIILiteral("function"), ElementDisplayedJavaScript);
1229         parameters->setArray(ASCIILiteral("arguments"), WTFMove(arguments));
1230         m_host->sendCommandToBackend(ASCIILiteral("evaluateJavaScriptFunction"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
1231             if (response.isError || !response.responseObject) {
1232                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
1233                 return;
1234             }
1235             String valueString;
1236             if (!response.responseObject->getString(ASCIILiteral("result"), valueString)) {
1237                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
1238                 return;
1239             }
1240             RefPtr<JSON::Value> resultValue;
1241             if (!JSON::Value::parseJSON(valueString, resultValue)) {
1242                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
1243                 return;
1244             }
1245             completionHandler(CommandResult::success(WTFMove(resultValue)));
1246         });
1247     });
1248 }
1249
1250 void Session::getElementAttribute(const String& elementID, const String& attribute, Function<void (CommandResult&&)>&& completionHandler)
1251 {
1252     if (!m_toplevelBrowsingContext) {
1253         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
1254         return;
1255     }
1256
1257     handleUserPrompts([this, elementID, attribute, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
1258         if (result.isError()) {
1259             completionHandler(WTFMove(result));
1260             return;
1261         }
1262         RefPtr<JSON::Array> arguments = JSON::Array::create();
1263         arguments->pushString(createElement(elementID)->toJSONString());
1264         arguments->pushString(JSON::Value::create(attribute)->toJSONString());
1265
1266         RefPtr<JSON::Object> parameters = JSON::Object::create();
1267         parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
1268         if (m_currentBrowsingContext)
1269             parameters->setString(ASCIILiteral("frameHandle"), m_currentBrowsingContext.value());
1270         parameters->setString(ASCIILiteral("function"), ElementAttributeJavaScript);
1271         parameters->setArray(ASCIILiteral("arguments"), WTFMove(arguments));
1272         m_host->sendCommandToBackend(ASCIILiteral("evaluateJavaScriptFunction"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
1273             if (response.isError || !response.responseObject) {
1274                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
1275                 return;
1276             }
1277             String valueString;
1278             if (!response.responseObject->getString(ASCIILiteral("result"), valueString)) {
1279                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
1280                 return;
1281             }
1282             RefPtr<JSON::Value> resultValue;
1283             if (!JSON::Value::parseJSON(valueString, resultValue)) {
1284                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
1285                 return;
1286             }
1287             completionHandler(CommandResult::success(WTFMove(resultValue)));
1288         });
1289     });
1290 }
1291
1292 void Session::waitForNavigationToComplete(Function<void (CommandResult&&)>&& completionHandler)
1293 {
1294     if (!m_toplevelBrowsingContext) {
1295         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
1296         return;
1297     }
1298
1299     RefPtr<JSON::Object> parameters = JSON::Object::create();
1300     parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
1301     if (m_currentBrowsingContext)
1302         parameters->setString(ASCIILiteral("frameHandle"), m_currentBrowsingContext.value());
1303     if (m_timeouts.pageLoad)
1304         parameters->setInteger(ASCIILiteral("pageLoadTimeout"), m_timeouts.pageLoad.value().millisecondsAs<int>());
1305     if (auto pageLoadStrategy = pageLoadStrategyString())
1306         parameters->setString(ASCIILiteral("pageLoadStrategy"), pageLoadStrategy.value());
1307     m_host->sendCommandToBackend(ASCIILiteral("waitForNavigationToComplete"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
1308         if (response.isError) {
1309             auto result = CommandResult::fail(WTFMove(response.responseObject));
1310             if (result.errorCode() == CommandResult::ErrorCode::NoSuchFrame) {
1311                 // Navigation destroyed the current frame, switch to top level browsing context and ignore the error.
1312                 switchToBrowsingContext(std::nullopt);
1313             } else {
1314                 completionHandler(WTFMove(result));
1315                 return;
1316             }
1317         }
1318         completionHandler(CommandResult::success());
1319     });
1320 }
1321
1322 void Session::selectOptionElement(const String& elementID, Function<void (CommandResult&&)>&& completionHandler)
1323 {
1324     RefPtr<JSON::Object> parameters = JSON::Object::create();
1325     parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
1326     parameters->setString(ASCIILiteral("frameHandle"), m_currentBrowsingContext.value_or(emptyString()));
1327     parameters->setString(ASCIILiteral("nodeHandle"), elementID);
1328     m_host->sendCommandToBackend(ASCIILiteral("selectOptionElement"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
1329         if (response.isError) {
1330             completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
1331             return;
1332         }
1333         completionHandler(CommandResult::success());
1334     });
1335 }
1336
1337 void Session::elementClick(const String& elementID, Function<void (CommandResult&&)>&& completionHandler)
1338 {
1339     if (!m_toplevelBrowsingContext) {
1340         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
1341         return;
1342     }
1343
1344     OptionSet<ElementLayoutOption> options = ElementLayoutOption::ScrollIntoViewIfNeeded;
1345     options |= ElementLayoutOption::UseViewportCoordinates;
1346     computeElementLayout(elementID, options, [this, protectedThis = makeRef(*this), elementID, completionHandler = WTFMove(completionHandler)](std::optional<Rect>&& rect, std::optional<Point>&& inViewCenter, bool isObscured, RefPtr<JSON::Object>&& error) mutable {
1347         if (!rect || error) {
1348             completionHandler(CommandResult::fail(WTFMove(error)));
1349             return;
1350         }
1351         if (isObscured) {
1352             completionHandler(CommandResult::fail(CommandResult::ErrorCode::ElementClickIntercepted));
1353             return;
1354         }
1355         if (!inViewCenter) {
1356             completionHandler(CommandResult::fail(CommandResult::ErrorCode::ElementNotInteractable));
1357             return;
1358         }
1359
1360         getElementTagName(elementID, [this, elementID, inViewCenter = WTFMove(inViewCenter), isObscured, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
1361             bool isOptionElement = false;
1362             if (!result.isError()) {
1363                 String tagName;
1364                 if (result.result()->asString(tagName))
1365                     isOptionElement = tagName == "option";
1366             }
1367
1368             Function<void (CommandResult&&)> continueAfterClickFunction = [this, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
1369                 if (result.isError()) {
1370                     completionHandler(WTFMove(result));
1371                     return;
1372                 }
1373
1374                 waitForNavigationToComplete(WTFMove(completionHandler));
1375             };
1376             if (isOptionElement)
1377                 selectOptionElement(elementID, WTFMove(continueAfterClickFunction));
1378             else
1379                 performMouseInteraction(inViewCenter.value().x, inViewCenter.value().y, MouseButton::Left, MouseInteraction::SingleClick, WTFMove(continueAfterClickFunction));
1380         });
1381     });
1382 }
1383
1384 void Session::elementClear(const String& elementID, Function<void (CommandResult&&)>&& completionHandler)
1385 {
1386     if (!m_toplevelBrowsingContext) {
1387         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
1388         return;
1389     }
1390
1391     RefPtr<JSON::Array> arguments = JSON::Array::create();
1392     arguments->pushString(createElement(elementID)->toJSONString());
1393
1394     RefPtr<JSON::Object> parameters = JSON::Object::create();
1395     parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
1396     if (m_currentBrowsingContext)
1397         parameters->setString(ASCIILiteral("frameHandle"), m_currentBrowsingContext.value());
1398     parameters->setString(ASCIILiteral("function"), FormElementClearJavaScript);
1399     parameters->setArray(ASCIILiteral("arguments"), WTFMove(arguments));
1400     m_host->sendCommandToBackend(ASCIILiteral("evaluateJavaScriptFunction"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
1401         if (response.isError) {
1402             completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
1403             return;
1404         }
1405         completionHandler(CommandResult::success());
1406     });
1407 }
1408
1409 String Session::virtualKeyForKeySequence(const String& keySequence, KeyModifier& modifier)
1410 {
1411     // §17.4.2 Keyboard Actions.
1412     // https://www.w3.org/TR/webdriver/#keyboard-actions
1413     modifier = KeyModifier::None;
1414     switch (keySequence[0]) {
1415     case 0xE001U:
1416         return ASCIILiteral("Cancel");
1417     case 0xE002U:
1418         return ASCIILiteral("Help");
1419     case 0xE003U:
1420         return ASCIILiteral("Backspace");
1421     case 0xE004U:
1422         return ASCIILiteral("Tab");
1423     case 0xE005U:
1424         return ASCIILiteral("Clear");
1425     case 0xE006U:
1426         return ASCIILiteral("Return");
1427     case 0xE007U:
1428         return ASCIILiteral("Enter");
1429     case 0xE008U:
1430         modifier = KeyModifier::Shift;
1431         return ASCIILiteral("Shift");
1432     case 0xE009U:
1433         modifier = KeyModifier::Control;
1434         return ASCIILiteral("Control");
1435     case 0xE00AU:
1436         modifier = KeyModifier::Alternate;
1437         return ASCIILiteral("Alternate");
1438     case 0xE00BU:
1439         return ASCIILiteral("Pause");
1440     case 0xE00CU:
1441         return ASCIILiteral("Escape");
1442     case 0xE00DU:
1443         return ASCIILiteral("Space");
1444     case 0xE00EU:
1445         return ASCIILiteral("PageUp");
1446     case 0xE00FU:
1447         return ASCIILiteral("PageDown");
1448     case 0xE010U:
1449         return ASCIILiteral("End");
1450     case 0xE011U:
1451         return ASCIILiteral("Home");
1452     case 0xE012U:
1453         return ASCIILiteral("LeftArrow");
1454     case 0xE013U:
1455         return ASCIILiteral("UpArrow");
1456     case 0xE014U:
1457         return ASCIILiteral("RightArrow");
1458     case 0xE015U:
1459         return ASCIILiteral("DownArrow");
1460     case 0xE016U:
1461         return ASCIILiteral("Insert");
1462     case 0xE017U:
1463         return ASCIILiteral("Delete");
1464     case 0xE018U:
1465         return ASCIILiteral("Semicolon");
1466     case 0xE019U:
1467         return ASCIILiteral("Equals");
1468     case 0xE01AU:
1469         return ASCIILiteral("NumberPad0");
1470     case 0xE01BU:
1471         return ASCIILiteral("NumberPad1");
1472     case 0xE01CU:
1473         return ASCIILiteral("NumberPad2");
1474     case 0xE01DU:
1475         return ASCIILiteral("NumberPad3");
1476     case 0xE01EU:
1477         return ASCIILiteral("NumberPad4");
1478     case 0xE01FU:
1479         return ASCIILiteral("NumberPad5");
1480     case 0xE020U:
1481         return ASCIILiteral("NumberPad6");
1482     case 0xE021U:
1483         return ASCIILiteral("NumberPad7");
1484     case 0xE022U:
1485         return ASCIILiteral("NumberPad8");
1486     case 0xE023U:
1487         return ASCIILiteral("NumberPad9");
1488     case 0xE024U:
1489         return ASCIILiteral("NumberPadMultiply");
1490     case 0xE025U:
1491         return ASCIILiteral("NumberPadAdd");
1492     case 0xE026U:
1493         return ASCIILiteral("NumberPadSeparator");
1494     case 0xE027U:
1495         return ASCIILiteral("NumberPadSubtract");
1496     case 0xE028U:
1497         return ASCIILiteral("NumberPadDecimal");
1498     case 0xE029U:
1499         return ASCIILiteral("NumberPadDivide");
1500     case 0xE031U:
1501         return ASCIILiteral("Function1");
1502     case 0xE032U:
1503         return ASCIILiteral("Function2");
1504     case 0xE033U:
1505         return ASCIILiteral("Function3");
1506     case 0xE034U:
1507         return ASCIILiteral("Function4");
1508     case 0xE035U:
1509         return ASCIILiteral("Function5");
1510     case 0xE036U:
1511         return ASCIILiteral("Function6");
1512     case 0xE037U:
1513         return ASCIILiteral("Function7");
1514     case 0xE038U:
1515         return ASCIILiteral("Function8");
1516     case 0xE039U:
1517         return ASCIILiteral("Function9");
1518     case 0xE03AU:
1519         return ASCIILiteral("Function10");
1520     case 0xE03BU:
1521         return ASCIILiteral("Function11");
1522     case 0xE03CU:
1523         return ASCIILiteral("Function12");
1524     case 0xE03DU:
1525         modifier = KeyModifier::Meta;
1526         return ASCIILiteral("Meta");
1527     default:
1528         break;
1529     }
1530     return String();
1531 }
1532
1533 void Session::elementSendKeys(const String& elementID, Vector<String>&& keys, Function<void (CommandResult&&)>&& completionHandler)
1534 {
1535     if (!m_toplevelBrowsingContext) {
1536         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
1537         return;
1538     }
1539
1540     handleUserPrompts([this, elementID, keys = WTFMove(keys), completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
1541         if (result.isError()) {
1542             completionHandler(WTFMove(result));
1543             return;
1544         }
1545         // FIXME: move this to an atom.
1546         static const char focusScript[] =
1547             "function focus(element) {"
1548             "    var doc = element.ownerDocument || element;"
1549             "    var prevActiveElement = doc.activeElement;"
1550             "    if (element != prevActiveElement && prevActiveElement)"
1551             "        prevActiveElement.blur();"
1552             "    element.focus();"
1553             "    if (element != prevActiveElement && element.value && element.value.length && element.setSelectionRange)"
1554             "        element.setSelectionRange(element.value.length, element.value.length);"
1555             "    if (element != doc.activeElement)"
1556             "        throw new Error('cannot focus element');"
1557             "}";
1558
1559         RefPtr<JSON::Array> arguments = JSON::Array::create();
1560         arguments->pushString(createElement(elementID)->toJSONString());
1561         RefPtr<JSON::Object> parameters = JSON::Object::create();
1562         parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
1563         if (m_currentBrowsingContext)
1564             parameters->setString(ASCIILiteral("frameHandle"), m_currentBrowsingContext.value());
1565         parameters->setString(ASCIILiteral("function"), focusScript);
1566         parameters->setArray(ASCIILiteral("arguments"), WTFMove(arguments));
1567         m_host->sendCommandToBackend(ASCIILiteral("evaluateJavaScriptFunction"), WTFMove(parameters), [this, protectedThis = makeRef(*this), keys = WTFMove(keys), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) mutable {
1568             if (response.isError || !response.responseObject) {
1569                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
1570                 return;
1571             }
1572
1573             unsigned stickyModifiers = 0;
1574             Vector<KeyboardInteraction> interactions;
1575             interactions.reserveInitialCapacity(keys.size());
1576             for (const auto& key : keys) {
1577                 KeyboardInteraction interaction;
1578                 KeyModifier modifier;
1579                 auto virtualKey = virtualKeyForKeySequence(key, modifier);
1580                 if (!virtualKey.isNull()) {
1581                     interaction.key = virtualKey;
1582                     if (modifier != KeyModifier::None) {
1583                         stickyModifiers ^= modifier;
1584                         if (stickyModifiers & modifier)
1585                             interaction.type = KeyboardInteractionType::KeyPress;
1586                         else
1587                             interaction.type = KeyboardInteractionType::KeyRelease;
1588                     }
1589                 } else
1590                     interaction.text = key;
1591                 interactions.uncheckedAppend(WTFMove(interaction));
1592             }
1593
1594             // Reset sticky modifiers if needed.
1595             if (stickyModifiers) {
1596                 if (stickyModifiers & KeyModifier::Shift)
1597                     interactions.append({ KeyboardInteractionType::KeyRelease, std::nullopt, std::optional<String>(ASCIILiteral("Shift")) });
1598                 if (stickyModifiers & KeyModifier::Control)
1599                     interactions.append({ KeyboardInteractionType::KeyRelease, std::nullopt, std::optional<String>(ASCIILiteral("Control")) });
1600                 if (stickyModifiers & KeyModifier::Alternate)
1601                     interactions.append({ KeyboardInteractionType::KeyRelease, std::nullopt, std::optional<String>(ASCIILiteral("Alternate")) });
1602                 if (stickyModifiers & KeyModifier::Meta)
1603                     interactions.append({ KeyboardInteractionType::KeyRelease, std::nullopt, std::optional<String>(ASCIILiteral("Meta")) });
1604             }
1605
1606             performKeyboardInteractions(WTFMove(interactions), WTFMove(completionHandler));
1607         });
1608     });
1609 }
1610
1611 RefPtr<JSON::Value> Session::handleScriptResult(RefPtr<JSON::Value>&& resultValue)
1612 {
1613     RefPtr<JSON::Array> resultArray;
1614     if (resultValue->asArray(resultArray)) {
1615         RefPtr<JSON::Array> returnValueArray = JSON::Array::create();
1616         unsigned resultArrayLength = resultArray->length();
1617         for (unsigned i = 0; i < resultArrayLength; ++i)
1618             returnValueArray->pushValue(handleScriptResult(resultArray->get(i)));
1619         return returnValueArray;
1620     }
1621
1622     if (auto element = createElement(RefPtr<JSON::Value>(resultValue)))
1623         return element;
1624
1625     RefPtr<JSON::Object> resultObject;
1626     if (resultValue->asObject(resultObject)) {
1627         RefPtr<JSON::Object> returnValueObject = JSON::Object::create();
1628         auto end = resultObject->end();
1629         for (auto it = resultObject->begin(); it != end; ++it)
1630             returnValueObject->setValue(it->key, handleScriptResult(WTFMove(it->value)));
1631         return returnValueObject;
1632     }
1633
1634     return resultValue;
1635 }
1636
1637 void Session::executeScript(const String& script, RefPtr<JSON::Array>&& argumentsArray, ExecuteScriptMode mode, Function<void (CommandResult&&)>&& completionHandler)
1638 {
1639     if (!m_toplevelBrowsingContext) {
1640         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
1641         return;
1642     }
1643
1644     handleUserPrompts([this, script, argumentsArray = WTFMove(argumentsArray), mode, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
1645         if (result.isError()) {
1646             completionHandler(WTFMove(result));
1647             return;
1648         }
1649         RefPtr<JSON::Array> arguments = JSON::Array::create();
1650         unsigned argumentsLength = argumentsArray->length();
1651         for (unsigned i = 0; i < argumentsLength; ++i) {
1652             if (auto argument = argumentsArray->get(i)) {
1653                 if (auto element = extractElement(*argument))
1654                     arguments->pushString(element->toJSONString());
1655                 else
1656                     arguments->pushString(argument->toJSONString());
1657             }
1658         }
1659
1660         RefPtr<JSON::Object> parameters = JSON::Object::create();
1661         parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
1662         if (m_currentBrowsingContext)
1663             parameters->setString(ASCIILiteral("frameHandle"), m_currentBrowsingContext.value());
1664         parameters->setString(ASCIILiteral("function"), "function(){" + script + '}');
1665         parameters->setArray(ASCIILiteral("arguments"), WTFMove(arguments));
1666         if (mode == ExecuteScriptMode::Async) {
1667             parameters->setBoolean(ASCIILiteral("expectsImplicitCallbackArgument"), true);
1668             if (m_timeouts.script)
1669                 parameters->setInteger(ASCIILiteral("callbackTimeout"), m_timeouts.script.value().millisecondsAs<int>());
1670         }
1671         m_host->sendCommandToBackend(ASCIILiteral("evaluateJavaScriptFunction"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) mutable {
1672             if (response.isError || !response.responseObject) {
1673                 auto result = CommandResult::fail(WTFMove(response.responseObject));
1674                 if (result.errorCode() == CommandResult::ErrorCode::UnexpectedAlertOpen)
1675                     handleUnexpectedAlertOpen(WTFMove(completionHandler));
1676                 else
1677                     completionHandler(WTFMove(result));
1678                 return;
1679             }
1680             String valueString;
1681             if (!response.responseObject->getString(ASCIILiteral("result"), valueString)) {
1682                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
1683                 return;
1684             }
1685             if (valueString.isEmpty()) {
1686                 completionHandler(CommandResult::success());
1687                 return;
1688             }
1689             RefPtr<JSON::Value> resultValue;
1690             if (!JSON::Value::parseJSON(valueString, resultValue)) {
1691                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
1692                 return;
1693             }
1694             completionHandler(CommandResult::success(handleScriptResult(WTFMove(resultValue))));
1695         });
1696     });
1697 }
1698
1699 void Session::performMouseInteraction(int x, int y, MouseButton button, MouseInteraction interaction, Function<void (CommandResult&&)>&& completionHandler)
1700 {
1701     RefPtr<JSON::Object> parameters = JSON::Object::create();
1702     parameters->setString(ASCIILiteral("handle"), m_toplevelBrowsingContext.value());
1703     RefPtr<JSON::Object> position = JSON::Object::create();
1704     position->setInteger(ASCIILiteral("x"), x);
1705     position->setInteger(ASCIILiteral("y"), y);
1706     parameters->setObject(ASCIILiteral("position"), WTFMove(position));
1707     switch (button) {
1708     case MouseButton::None:
1709         parameters->setString(ASCIILiteral("button"), ASCIILiteral("None"));
1710         break;
1711     case MouseButton::Left:
1712         parameters->setString(ASCIILiteral("button"), ASCIILiteral("Left"));
1713         break;
1714     case MouseButton::Middle:
1715         parameters->setString(ASCIILiteral("button"), ASCIILiteral("Middle"));
1716         break;
1717     case MouseButton::Right:
1718         parameters->setString(ASCIILiteral("button"), ASCIILiteral("Right"));
1719         break;
1720     }
1721     switch (interaction) {
1722     case MouseInteraction::Move:
1723         parameters->setString(ASCIILiteral("interaction"), ASCIILiteral("Move"));
1724         break;
1725     case MouseInteraction::Down:
1726         parameters->setString(ASCIILiteral("interaction"), ASCIILiteral("Down"));
1727         break;
1728     case MouseInteraction::Up:
1729         parameters->setString(ASCIILiteral("interaction"), ASCIILiteral("Up"));
1730         break;
1731     case MouseInteraction::SingleClick:
1732         parameters->setString(ASCIILiteral("interaction"), ASCIILiteral("SingleClick"));
1733         break;
1734     case MouseInteraction::DoubleClick:
1735         parameters->setString(ASCIILiteral("interaction"), ASCIILiteral("DoubleClick"));
1736         break;
1737     }
1738     parameters->setArray(ASCIILiteral("modifiers"), JSON::Array::create());
1739     m_host->sendCommandToBackend(ASCIILiteral("performMouseInteraction"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
1740         if (response.isError) {
1741             completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
1742             return;
1743         }
1744         completionHandler(CommandResult::success());
1745     });
1746 }
1747
1748 void Session::performKeyboardInteractions(Vector<KeyboardInteraction>&& interactions, Function<void (CommandResult&&)>&& completionHandler)
1749 {
1750     RefPtr<JSON::Object> parameters = JSON::Object::create();
1751     parameters->setString(ASCIILiteral("handle"), m_toplevelBrowsingContext.value());
1752     RefPtr<JSON::Array> interactionsArray = JSON::Array::create();
1753     for (const auto& interaction : interactions) {
1754         RefPtr<JSON::Object> interactionObject = JSON::Object::create();
1755         switch (interaction.type) {
1756         case KeyboardInteractionType::KeyPress:
1757             interactionObject->setString(ASCIILiteral("type"), ASCIILiteral("KeyPress"));
1758             break;
1759         case KeyboardInteractionType::KeyRelease:
1760             interactionObject->setString(ASCIILiteral("type"), ASCIILiteral("KeyRelease"));
1761             break;
1762         case KeyboardInteractionType::InsertByKey:
1763             interactionObject->setString(ASCIILiteral("type"), ASCIILiteral("InsertByKey"));
1764             break;
1765         }
1766         if (interaction.key)
1767             interactionObject->setString(ASCIILiteral("key"), interaction.key.value());
1768         if (interaction.text)
1769             interactionObject->setString(ASCIILiteral("text"), interaction.text.value());
1770         interactionsArray->pushObject(WTFMove(interactionObject));
1771     }
1772     parameters->setArray(ASCIILiteral("interactions"), WTFMove(interactionsArray));
1773     m_host->sendCommandToBackend(ASCIILiteral("performKeyboardInteractions"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
1774         if (response.isError) {
1775             completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
1776             return;
1777         }
1778         completionHandler(CommandResult::success());
1779     });
1780 }
1781
1782 static std::optional<Session::Cookie> parseAutomationCookie(const JSON::Object& cookieObject)
1783 {
1784     Session::Cookie cookie;
1785     if (!cookieObject.getString(ASCIILiteral("name"), cookie.name))
1786         return std::nullopt;
1787     if (!cookieObject.getString(ASCIILiteral("value"), cookie.value))
1788         return std::nullopt;
1789
1790     String path;
1791     if (cookieObject.getString(ASCIILiteral("path"), path))
1792         cookie.path = path;
1793     String domain;
1794     if (cookieObject.getString(ASCIILiteral("domain"), domain))
1795         cookie.domain = domain;
1796     bool secure;
1797     if (cookieObject.getBoolean(ASCIILiteral("secure"), secure))
1798         cookie.secure = secure;
1799     bool httpOnly;
1800     if (cookieObject.getBoolean(ASCIILiteral("httpOnly"), httpOnly))
1801         cookie.httpOnly = httpOnly;
1802     bool session = false;
1803     cookieObject.getBoolean(ASCIILiteral("session"), session);
1804     if (!session) {
1805         double expiry;
1806         if (cookieObject.getDouble(ASCIILiteral("expires"), expiry))
1807             cookie.expiry = expiry;
1808     }
1809
1810     return cookie;
1811 }
1812
1813 static RefPtr<JSON::Object> builtAutomationCookie(const Session::Cookie& cookie)
1814 {
1815     RefPtr<JSON::Object> cookieObject = JSON::Object::create();
1816     cookieObject->setString(ASCIILiteral("name"), cookie.name);
1817     cookieObject->setString(ASCIILiteral("value"), cookie.value);
1818     cookieObject->setString(ASCIILiteral("path"), cookie.path.value_or("/"));
1819     cookieObject->setString(ASCIILiteral("domain"), cookie.domain.value_or(emptyString()));
1820     cookieObject->setBoolean(ASCIILiteral("secure"), cookie.secure.value_or(false));
1821     cookieObject->setBoolean(ASCIILiteral("httpOnly"), cookie.httpOnly.value_or(false));
1822     cookieObject->setBoolean(ASCIILiteral("session"), !cookie.expiry);
1823     cookieObject->setDouble(ASCIILiteral("expires"), cookie.expiry.value_or(0));
1824     return cookieObject;
1825 }
1826
1827 static RefPtr<JSON::Object> serializeCookie(const Session::Cookie& cookie)
1828 {
1829     RefPtr<JSON::Object> cookieObject = JSON::Object::create();
1830     cookieObject->setString(ASCIILiteral("name"), cookie.name);
1831     cookieObject->setString(ASCIILiteral("value"), cookie.value);
1832     if (cookie.path)
1833         cookieObject->setString(ASCIILiteral("path"), cookie.path.value());
1834     if (cookie.domain)
1835         cookieObject->setString(ASCIILiteral("domain"), cookie.domain.value());
1836     if (cookie.secure)
1837         cookieObject->setBoolean(ASCIILiteral("secure"), cookie.secure.value());
1838     if (cookie.httpOnly)
1839         cookieObject->setBoolean(ASCIILiteral("httpOnly"), cookie.httpOnly.value());
1840     if (cookie.expiry)
1841         cookieObject->setInteger(ASCIILiteral("expiry"), cookie.expiry.value());
1842     return cookieObject;
1843 }
1844
1845 void Session::getAllCookies(Function<void (CommandResult&&)>&& completionHandler)
1846 {
1847     if (!m_toplevelBrowsingContext) {
1848         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
1849         return;
1850     }
1851
1852     handleUserPrompts([this, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
1853         if (result.isError()) {
1854             completionHandler(WTFMove(result));
1855             return;
1856         }
1857
1858         RefPtr<JSON::Object> parameters = JSON::Object::create();
1859         parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
1860         m_host->sendCommandToBackend(ASCIILiteral("getAllCookies"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) mutable {
1861             if (response.isError || !response.responseObject) {
1862                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
1863                 return;
1864             }
1865             RefPtr<JSON::Array> cookiesArray;
1866             if (!response.responseObject->getArray(ASCIILiteral("cookies"), cookiesArray)) {
1867                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
1868                 return;
1869             }
1870             RefPtr<JSON::Array> cookies = JSON::Array::create();
1871             for (unsigned i = 0; i < cookiesArray->length(); ++i) {
1872                 RefPtr<JSON::Value> cookieValue = cookiesArray->get(i);
1873                 RefPtr<JSON::Object> cookieObject;
1874                 if (!cookieValue->asObject(cookieObject)) {
1875                     completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
1876                     return;
1877                 }
1878
1879                 auto cookie = parseAutomationCookie(*cookieObject);
1880                 if (!cookie) {
1881                     completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
1882                     return;
1883                 }
1884                 cookies->pushObject(serializeCookie(cookie.value()));
1885             }
1886             completionHandler(CommandResult::success(WTFMove(cookies)));
1887         });
1888     });
1889 }
1890
1891 void Session::getNamedCookie(const String& name, Function<void (CommandResult&&)>&& completionHandler)
1892 {
1893     getAllCookies([this, name, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
1894         if (result.isError()) {
1895             completionHandler(WTFMove(result));
1896             return;
1897         }
1898         RefPtr<JSON::Array> cookiesArray;
1899         result.result()->asArray(cookiesArray);
1900         for (unsigned i = 0; i < cookiesArray->length(); ++i) {
1901             RefPtr<JSON::Value> cookieValue = cookiesArray->get(i);
1902             RefPtr<JSON::Object> cookieObject;
1903             cookieValue->asObject(cookieObject);
1904             String cookieName;
1905             cookieObject->getString(ASCIILiteral("name"), cookieName);
1906             if (cookieName == name) {
1907                 completionHandler(CommandResult::success(WTFMove(cookieObject)));
1908                 return;
1909             }
1910         }
1911         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchCookie));
1912     });
1913 }
1914
1915 void Session::addCookie(const Cookie& cookie, Function<void (CommandResult&&)>&& completionHandler)
1916 {
1917     if (!m_toplevelBrowsingContext) {
1918         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
1919         return;
1920     }
1921
1922     handleUserPrompts([this, cookie = builtAutomationCookie(cookie), completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
1923         if (result.isError()) {
1924             completionHandler(WTFMove(result));
1925             return;
1926         }
1927         RefPtr<JSON::Object> parameters = JSON::Object::create();
1928         parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
1929         parameters->setObject(ASCIILiteral("cookie"), WTFMove(cookie));
1930         m_host->sendCommandToBackend(ASCIILiteral("addSingleCookie"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
1931             if (response.isError) {
1932                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
1933                 return;
1934             }
1935             completionHandler(CommandResult::success());
1936         });
1937     });
1938 }
1939
1940 void Session::deleteCookie(const String& name, Function<void (CommandResult&&)>&& completionHandler)
1941 {
1942     if (!m_toplevelBrowsingContext) {
1943         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
1944         return;
1945     }
1946
1947     handleUserPrompts([this, name, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
1948         if (result.isError()) {
1949             completionHandler(WTFMove(result));
1950             return;
1951         }
1952         RefPtr<JSON::Object> parameters = JSON::Object::create();
1953         parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
1954         parameters->setString(ASCIILiteral("cookieName"), name);
1955         m_host->sendCommandToBackend(ASCIILiteral("deleteSingleCookie"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
1956             if (response.isError) {
1957                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
1958                 return;
1959             }
1960             completionHandler(CommandResult::success());
1961         });
1962     });
1963 }
1964
1965 void Session::deleteAllCookies(Function<void (CommandResult&&)>&& completionHandler)
1966 {
1967     if (!m_toplevelBrowsingContext) {
1968         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
1969         return;
1970     }
1971
1972     handleUserPrompts([this, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
1973         if (result.isError()) {
1974             completionHandler(WTFMove(result));
1975             return;
1976         }
1977         RefPtr<JSON::Object> parameters = JSON::Object::create();
1978         parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
1979         m_host->sendCommandToBackend(ASCIILiteral("deleteAllCookies"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
1980             if (response.isError) {
1981                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
1982                 return;
1983             }
1984             completionHandler(CommandResult::success());
1985         });
1986     });
1987 }
1988
1989 void Session::dismissAlert(Function<void (CommandResult&&)>&& completionHandler)
1990 {
1991     if (!m_toplevelBrowsingContext) {
1992         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
1993         return;
1994     }
1995
1996     RefPtr<JSON::Object> parameters = JSON::Object::create();
1997     parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
1998     m_host->sendCommandToBackend(ASCIILiteral("dismissCurrentJavaScriptDialog"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
1999         if (response.isError) {
2000             completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
2001             return;
2002         }
2003         completionHandler(CommandResult::success());
2004     });
2005 }
2006
2007 void Session::acceptAlert(Function<void (CommandResult&&)>&& completionHandler)
2008 {
2009     if (!m_toplevelBrowsingContext) {
2010         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
2011         return;
2012     }
2013
2014     RefPtr<JSON::Object> parameters = JSON::Object::create();
2015     parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
2016     m_host->sendCommandToBackend(ASCIILiteral("acceptCurrentJavaScriptDialog"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
2017         if (response.isError) {
2018             completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
2019             return;
2020         }
2021         completionHandler(CommandResult::success());
2022     });
2023 }
2024
2025 void Session::getAlertText(Function<void (CommandResult&&)>&& completionHandler)
2026 {
2027     if (!m_toplevelBrowsingContext) {
2028         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
2029         return;
2030     }
2031
2032     RefPtr<JSON::Object> parameters = JSON::Object::create();
2033     parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
2034     m_host->sendCommandToBackend(ASCIILiteral("messageOfCurrentJavaScriptDialog"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
2035         if (response.isError || !response.responseObject) {
2036             completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
2037             return;
2038         }
2039         String valueString;
2040         if (!response.responseObject->getString(ASCIILiteral("message"), valueString)) {
2041             completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
2042             return;
2043         }
2044         completionHandler(CommandResult::success(JSON::Value::create(valueString)));
2045     });
2046 }
2047
2048 void Session::sendAlertText(const String& text, Function<void (CommandResult&&)>&& completionHandler)
2049 {
2050     if (!m_toplevelBrowsingContext) {
2051         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
2052         return;
2053     }
2054
2055     RefPtr<JSON::Object> parameters = JSON::Object::create();
2056     parameters->setString(ASCIILiteral("browsingContextHandle"), m_toplevelBrowsingContext.value());
2057     parameters->setString(ASCIILiteral("userInput"), text);
2058     m_host->sendCommandToBackend(ASCIILiteral("setUserInputForCurrentJavaScriptPrompt"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) {
2059         if (response.isError) {
2060             completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
2061             return;
2062         }
2063         completionHandler(CommandResult::success());
2064     });
2065 }
2066
2067 void Session::takeScreenshot(std::optional<String> elementID, std::optional<bool> scrollIntoView, Function<void (CommandResult&&)>&& completionHandler)
2068 {
2069     if (!m_toplevelBrowsingContext) {
2070         completionHandler(CommandResult::fail(CommandResult::ErrorCode::NoSuchWindow));
2071         return;
2072     }
2073
2074     handleUserPrompts([this, elementID, scrollIntoView, completionHandler = WTFMove(completionHandler)](CommandResult&& result) mutable {
2075         if (result.isError()) {
2076             completionHandler(WTFMove(result));
2077             return;
2078         }
2079         RefPtr<JSON::Object> parameters = JSON::Object::create();
2080         parameters->setString(ASCIILiteral("handle"), m_toplevelBrowsingContext.value());
2081         if (m_currentBrowsingContext)
2082             parameters->setString(ASCIILiteral("frameHandle"), m_currentBrowsingContext.value());
2083         if (elementID)
2084             parameters->setString(ASCIILiteral("nodeHandle"), elementID.value());
2085         if (scrollIntoView.value_or(false))
2086             parameters->setBoolean(ASCIILiteral("scrollIntoViewIfNeeded"), true);
2087         m_host->sendCommandToBackend(ASCIILiteral("takeScreenshot"), WTFMove(parameters), [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler)](SessionHost::CommandResponse&& response) mutable {
2088             if (response.isError || !response.responseObject) {
2089                 completionHandler(CommandResult::fail(WTFMove(response.responseObject)));
2090                 return;
2091             }
2092             String data;
2093             if (!response.responseObject->getString(ASCIILiteral("data"), data)) {
2094                 completionHandler(CommandResult::fail(CommandResult::ErrorCode::UnknownError));
2095                 return;
2096             }
2097             completionHandler(CommandResult::success(JSON::Value::create(data)));
2098         });
2099     });
2100 }
2101
2102 } // namespace WebDriver