1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/test/chromedriver/window_commands.h" 6 7 #include <list> 8 #include <string> 9 10 #include "base/callback.h" 11 #include "base/strings/string_number_conversions.h" 12 #include "base/strings/stringprintf.h" 13 #include "base/threading/platform_thread.h" 14 #include "base/time/time.h" 15 #include "base/values.h" 16 #include "chrome/test/chromedriver/basic_types.h" 17 #include "chrome/test/chromedriver/chrome/automation_extension.h" 18 #include "chrome/test/chromedriver/chrome/chrome.h" 19 #include "chrome/test/chromedriver/chrome/chrome_desktop_impl.h" 20 #include "chrome/test/chromedriver/chrome/devtools_client.h" 21 #include "chrome/test/chromedriver/chrome/geoposition.h" 22 #include "chrome/test/chromedriver/chrome/javascript_dialog_manager.h" 23 #include "chrome/test/chromedriver/chrome/js.h" 24 #include "chrome/test/chromedriver/chrome/status.h" 25 #include "chrome/test/chromedriver/chrome/ui_events.h" 26 #include "chrome/test/chromedriver/chrome/web_view.h" 27 #include "chrome/test/chromedriver/element_util.h" 28 #include "chrome/test/chromedriver/session.h" 29 #include "chrome/test/chromedriver/util.h" 30 31 namespace { 32 33 Status GetMouseButton(const base::DictionaryValue& params, 34 MouseButton* button) { 35 int button_num; 36 if (!params.GetInteger("button", &button_num)) { 37 button_num = 0; // Default to left mouse button. 38 } else if (button_num < 0 || button_num > 2) { 39 return Status(kUnknownError, 40 base::StringPrintf("invalid button: %d", button_num)); 41 } 42 *button = static_cast<MouseButton>(button_num); 43 return Status(kOk); 44 } 45 46 Status GetUrl(WebView* web_view, const std::string& frame, std::string* url) { 47 scoped_ptr<base::Value> value; 48 base::ListValue args; 49 Status status = web_view->CallFunction( 50 frame, "function() { return document.URL; }", args, &value); 51 if (status.IsError()) 52 return status; 53 if (!value->GetAsString(url)) 54 return Status(kUnknownError, "javascript failed to return the url"); 55 return Status(kOk); 56 } 57 58 struct Cookie { 59 Cookie(const std::string& name, 60 const std::string& value, 61 const std::string& domain, 62 const std::string& path, 63 double expiry, 64 bool secure, 65 bool session) 66 : name(name), value(value), domain(domain), path(path), expiry(expiry), 67 secure(secure), session(session) {} 68 69 std::string name; 70 std::string value; 71 std::string domain; 72 std::string path; 73 double expiry; 74 bool secure; 75 bool session; 76 }; 77 78 base::DictionaryValue* CreateDictionaryFrom(const Cookie& cookie) { 79 base::DictionaryValue* dict = new base::DictionaryValue(); 80 dict->SetString("name", cookie.name); 81 dict->SetString("value", cookie.value); 82 if (!cookie.domain.empty()) 83 dict->SetString("domain", cookie.domain); 84 if (!cookie.path.empty()) 85 dict->SetString("path", cookie.path); 86 if (!cookie.session) 87 dict->SetDouble("expiry", cookie.expiry); 88 dict->SetBoolean("secure", cookie.secure); 89 return dict; 90 } 91 92 Status GetVisibleCookies(WebView* web_view, 93 std::list<Cookie>* cookies) { 94 scoped_ptr<base::ListValue> internal_cookies; 95 Status status = web_view->GetCookies(&internal_cookies); 96 if (status.IsError()) 97 return status; 98 std::list<Cookie> cookies_tmp; 99 for (size_t i = 0; i < internal_cookies->GetSize(); ++i) { 100 base::DictionaryValue* cookie_dict; 101 if (!internal_cookies->GetDictionary(i, &cookie_dict)) 102 return Status(kUnknownError, "DevTools returns a non-dictionary cookie"); 103 104 std::string name; 105 cookie_dict->GetString("name", &name); 106 std::string value; 107 cookie_dict->GetString("value", &value); 108 std::string domain; 109 cookie_dict->GetString("domain", &domain); 110 std::string path; 111 cookie_dict->GetString("path", &path); 112 double expiry = 0; 113 cookie_dict->GetDouble("expires", &expiry); 114 expiry /= 1000; // Convert from millisecond to second. 115 bool session = false; 116 cookie_dict->GetBoolean("session", &session); 117 bool secure = false; 118 cookie_dict->GetBoolean("secure", &secure); 119 120 cookies_tmp.push_back( 121 Cookie(name, value, domain, path, expiry, secure, session)); 122 } 123 cookies->swap(cookies_tmp); 124 return Status(kOk); 125 } 126 127 Status ScrollCoordinateInToView( 128 Session* session, WebView* web_view, int x, int y, int* offset_x, 129 int* offset_y) { 130 scoped_ptr<base::Value> value; 131 base::ListValue args; 132 args.AppendInteger(x); 133 args.AppendInteger(y); 134 Status status = web_view->CallFunction( 135 std::string(), 136 "function(x, y) {" 137 " if (x < window.pageXOffset ||" 138 " x >= window.pageXOffset + window.innerWidth ||" 139 " y < window.pageYOffset ||" 140 " y >= window.pageYOffset + window.innerHeight) {" 141 " window.scrollTo(x - window.innerWidth/2, y - window.innerHeight/2);" 142 " }" 143 " return {" 144 " view_x: Math.floor(window.pageXOffset)," 145 " view_y: Math.floor(window.pageYOffset)," 146 " view_width: Math.floor(window.innerWidth)," 147 " view_height: Math.floor(window.innerHeight)};" 148 "}", 149 args, 150 &value); 151 if (!status.IsOk()) 152 return status; 153 base::DictionaryValue* view_attrib; 154 value->GetAsDictionary(&view_attrib); 155 int view_x, view_y, view_width, view_height; 156 view_attrib->GetInteger("view_x", &view_x); 157 view_attrib->GetInteger("view_y", &view_y); 158 view_attrib->GetInteger("view_width", &view_width); 159 view_attrib->GetInteger("view_height", &view_height); 160 *offset_x = x - view_x; 161 *offset_y = y - view_y; 162 if (*offset_x < 0 || *offset_x >= view_width || *offset_y < 0 || 163 *offset_y >= view_height) 164 return Status(kUnknownError, "Failed to scroll coordinate into view"); 165 return Status(kOk); 166 } 167 168 Status ExecuteTouchEvent( 169 Session* session, WebView* web_view, TouchEventType type, 170 const base::DictionaryValue& params) { 171 int x, y; 172 if (!params.GetInteger("x", &x)) 173 return Status(kUnknownError, "'x' must be an integer"); 174 if (!params.GetInteger("y", &y)) 175 return Status(kUnknownError, "'y' must be an integer"); 176 int relative_x = x; 177 int relative_y = y; 178 Status status = ScrollCoordinateInToView( 179 session, web_view, x, y, &relative_x, &relative_y); 180 if (!status.IsOk()) 181 return status; 182 std::list<TouchEvent> events; 183 events.push_back( 184 TouchEvent(type, relative_x, relative_y)); 185 return web_view->DispatchTouchEvents(events); 186 } 187 188 } // namespace 189 190 Status ExecuteWindowCommand( 191 const WindowCommand& command, 192 Session* session, 193 const base::DictionaryValue& params, 194 scoped_ptr<base::Value>* value) { 195 WebView* web_view = NULL; 196 Status status = session->GetTargetWindow(&web_view); 197 if (status.IsError()) 198 return status; 199 200 status = web_view->ConnectIfNecessary(); 201 if (status.IsError()) 202 return status; 203 204 status = web_view->HandleReceivedEvents(); 205 if (status.IsError()) 206 return status; 207 208 if (web_view->GetJavaScriptDialogManager()->IsDialogOpen()) 209 return Status(kUnexpectedAlertOpen); 210 211 Status nav_status(kOk); 212 for (int attempt = 0; attempt < 2; attempt++) { 213 if (attempt == 1) { 214 if (status.code() == kNoSuchExecutionContext) 215 // Switch to main frame and retry command if subframe no longer exists. 216 session->SwitchToTopFrame(); 217 else 218 break; 219 } 220 nav_status = web_view->WaitForPendingNavigations( 221 session->GetCurrentFrameId(), session->page_load_timeout, true); 222 if (nav_status.IsError()) 223 return nav_status; 224 225 status = command.Run(session, web_view, params, value); 226 } 227 228 nav_status = web_view->WaitForPendingNavigations( 229 session->GetCurrentFrameId(), session->page_load_timeout, true); 230 231 if (status.IsOk() && nav_status.IsError() && 232 nav_status.code() != kUnexpectedAlertOpen) 233 return nav_status; 234 if (status.code() == kUnexpectedAlertOpen) 235 return Status(kOk); 236 return status; 237 } 238 239 Status ExecuteGet( 240 Session* session, 241 WebView* web_view, 242 const base::DictionaryValue& params, 243 scoped_ptr<base::Value>* value) { 244 std::string url; 245 if (!params.GetString("url", &url)) 246 return Status(kUnknownError, "'url' must be a string"); 247 return web_view->Load(url); 248 } 249 250 Status ExecuteExecuteScript( 251 Session* session, 252 WebView* web_view, 253 const base::DictionaryValue& params, 254 scoped_ptr<base::Value>* value) { 255 std::string script; 256 if (!params.GetString("script", &script)) 257 return Status(kUnknownError, "'script' must be a string"); 258 if (script == ":takeHeapSnapshot") { 259 return web_view->TakeHeapSnapshot(value); 260 } else { 261 const base::ListValue* args; 262 if (!params.GetList("args", &args)) 263 return Status(kUnknownError, "'args' must be a list"); 264 265 return web_view->CallFunction(session->GetCurrentFrameId(), 266 "function(){" + script + "}", *args, value); 267 } 268 } 269 270 Status ExecuteExecuteAsyncScript( 271 Session* session, 272 WebView* web_view, 273 const base::DictionaryValue& params, 274 scoped_ptr<base::Value>* value) { 275 std::string script; 276 if (!params.GetString("script", &script)) 277 return Status(kUnknownError, "'script' must be a string"); 278 const base::ListValue* args; 279 if (!params.GetList("args", &args)) 280 return Status(kUnknownError, "'args' must be a list"); 281 282 return web_view->CallUserAsyncFunction( 283 session->GetCurrentFrameId(), "function(){" + script + "}", *args, 284 session->script_timeout, value); 285 } 286 287 Status ExecuteSwitchToFrame( 288 Session* session, 289 WebView* web_view, 290 const base::DictionaryValue& params, 291 scoped_ptr<base::Value>* value) { 292 const base::Value* id; 293 if (!params.Get("id", &id)) 294 return Status(kUnknownError, "missing 'id'"); 295 296 if (id->IsType(base::Value::TYPE_NULL)) { 297 session->SwitchToTopFrame(); 298 return Status(kOk); 299 } 300 301 std::string script; 302 base::ListValue args; 303 const base::DictionaryValue* id_dict; 304 if (id->GetAsDictionary(&id_dict)) { 305 script = "function(elem) { return elem; }"; 306 args.Append(id_dict->DeepCopy()); 307 } else { 308 script = 309 "function(xpath) {" 310 " return document.evaluate(xpath, document, null, " 311 " XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;" 312 "}"; 313 std::string xpath = "(/html/body//iframe|/html/frameset/frame)"; 314 std::string id_string; 315 int id_int; 316 if (id->GetAsString(&id_string)) { 317 xpath += base::StringPrintf( 318 "[@name=\"%s\" or @id=\"%s\"]", id_string.c_str(), id_string.c_str()); 319 } else if (id->GetAsInteger(&id_int)) { 320 xpath += base::StringPrintf("[%d]", id_int + 1); 321 } else { 322 return Status(kUnknownError, "invalid 'id'"); 323 } 324 args.Append(new base::StringValue(xpath)); 325 } 326 std::string frame; 327 Status status = web_view->GetFrameByFunction( 328 session->GetCurrentFrameId(), script, args, &frame); 329 if (status.IsError()) 330 return status; 331 332 scoped_ptr<base::Value> result; 333 status = web_view->CallFunction( 334 session->GetCurrentFrameId(), script, args, &result); 335 if (status.IsError()) 336 return status; 337 const base::DictionaryValue* element; 338 if (!result->GetAsDictionary(&element)) 339 return Status(kUnknownError, "fail to locate the sub frame element"); 340 341 std::string chrome_driver_id = GenerateId(); 342 const char* kSetFrameIdentifier = 343 "function(frame, id) {" 344 " frame.setAttribute('cd_frame_id_', id);" 345 "}"; 346 base::ListValue new_args; 347 new_args.Append(element->DeepCopy()); 348 new_args.AppendString(chrome_driver_id); 349 result.reset(NULL); 350 status = web_view->CallFunction( 351 session->GetCurrentFrameId(), kSetFrameIdentifier, new_args, &result); 352 if (status.IsError()) 353 return status; 354 session->SwitchToSubFrame(frame, chrome_driver_id); 355 return Status(kOk); 356 } 357 358 Status ExecuteGetTitle( 359 Session* session, 360 WebView* web_view, 361 const base::DictionaryValue& params, 362 scoped_ptr<base::Value>* value) { 363 const char* kGetTitleScript = 364 "function() {" 365 " if (document.title)" 366 " return document.title;" 367 " else" 368 " return document.URL;" 369 "}"; 370 base::ListValue args; 371 return web_view->CallFunction(std::string(), kGetTitleScript, args, value); 372 } 373 374 Status ExecuteGetPageSource( 375 Session* session, 376 WebView* web_view, 377 const base::DictionaryValue& params, 378 scoped_ptr<base::Value>* value) { 379 const char* kGetPageSource = 380 "function() {" 381 " return new XMLSerializer().serializeToString(document);" 382 "}"; 383 base::ListValue args; 384 return web_view->CallFunction( 385 session->GetCurrentFrameId(), kGetPageSource, args, value); 386 } 387 388 Status ExecuteFindElement( 389 int interval_ms, 390 Session* session, 391 WebView* web_view, 392 const base::DictionaryValue& params, 393 scoped_ptr<base::Value>* value) { 394 return FindElement(interval_ms, true, NULL, session, web_view, params, value); 395 } 396 397 Status ExecuteFindElements( 398 int interval_ms, 399 Session* session, 400 WebView* web_view, 401 const base::DictionaryValue& params, 402 scoped_ptr<base::Value>* value) { 403 return FindElement( 404 interval_ms, false, NULL, session, web_view, params, value); 405 } 406 407 Status ExecuteGetCurrentUrl( 408 Session* session, 409 WebView* web_view, 410 const base::DictionaryValue& params, 411 scoped_ptr<base::Value>* value) { 412 std::string url; 413 Status status = GetUrl(web_view, session->GetCurrentFrameId(), &url); 414 if (status.IsError()) 415 return status; 416 value->reset(new base::StringValue(url)); 417 return Status(kOk); 418 } 419 420 Status ExecuteGoBack( 421 Session* session, 422 WebView* web_view, 423 const base::DictionaryValue& params, 424 scoped_ptr<base::Value>* value) { 425 return web_view->EvaluateScript( 426 std::string(), "window.history.back();", value); 427 } 428 429 Status ExecuteGoForward( 430 Session* session, 431 WebView* web_view, 432 const base::DictionaryValue& params, 433 scoped_ptr<base::Value>* value) { 434 return web_view->EvaluateScript( 435 std::string(), "window.history.forward();", value); 436 } 437 438 Status ExecuteRefresh( 439 Session* session, 440 WebView* web_view, 441 const base::DictionaryValue& params, 442 scoped_ptr<base::Value>* value) { 443 return web_view->Reload(); 444 } 445 446 Status ExecuteMouseMoveTo( 447 Session* session, 448 WebView* web_view, 449 const base::DictionaryValue& params, 450 scoped_ptr<base::Value>* value) { 451 std::string element_id; 452 bool has_element = params.GetString("element", &element_id); 453 int x_offset = 0; 454 int y_offset = 0; 455 bool has_offset = params.GetInteger("xoffset", &x_offset) && 456 params.GetInteger("yoffset", &y_offset); 457 if (!has_element && !has_offset) 458 return Status(kUnknownError, "at least an element or offset should be set"); 459 460 WebPoint location; 461 if (has_element) { 462 Status status = ScrollElementIntoView( 463 session, web_view, element_id, &location); 464 if (status.IsError()) 465 return status; 466 } else { 467 location = session->mouse_position; 468 } 469 470 if (has_offset) { 471 location.Offset(x_offset, y_offset); 472 } else { 473 WebSize size; 474 Status status = GetElementSize(session, web_view, element_id, &size); 475 if (status.IsError()) 476 return status; 477 location.Offset(size.width / 2, size.height / 2); 478 } 479 480 std::list<MouseEvent> events; 481 events.push_back( 482 MouseEvent(kMovedMouseEventType, kNoneMouseButton, 483 location.x, location.y, session->sticky_modifiers, 0)); 484 Status status = 485 web_view->DispatchMouseEvents(events, session->GetCurrentFrameId()); 486 if (status.IsOk()) 487 session->mouse_position = location; 488 return status; 489 } 490 491 Status ExecuteMouseClick( 492 Session* session, 493 WebView* web_view, 494 const base::DictionaryValue& params, 495 scoped_ptr<base::Value>* value) { 496 MouseButton button; 497 Status status = GetMouseButton(params, &button); 498 if (status.IsError()) 499 return status; 500 std::list<MouseEvent> events; 501 events.push_back( 502 MouseEvent(kPressedMouseEventType, button, 503 session->mouse_position.x, session->mouse_position.y, 504 session->sticky_modifiers, 1)); 505 events.push_back( 506 MouseEvent(kReleasedMouseEventType, button, 507 session->mouse_position.x, session->mouse_position.y, 508 session->sticky_modifiers, 1)); 509 return web_view->DispatchMouseEvents(events, session->GetCurrentFrameId()); 510 } 511 512 Status ExecuteMouseButtonDown( 513 Session* session, 514 WebView* web_view, 515 const base::DictionaryValue& params, 516 scoped_ptr<base::Value>* value) { 517 MouseButton button; 518 Status status = GetMouseButton(params, &button); 519 if (status.IsError()) 520 return status; 521 std::list<MouseEvent> events; 522 events.push_back( 523 MouseEvent(kPressedMouseEventType, button, 524 session->mouse_position.x, session->mouse_position.y, 525 session->sticky_modifiers, 1)); 526 return web_view->DispatchMouseEvents(events, session->GetCurrentFrameId()); 527 } 528 529 Status ExecuteMouseButtonUp( 530 Session* session, 531 WebView* web_view, 532 const base::DictionaryValue& params, 533 scoped_ptr<base::Value>* value) { 534 MouseButton button; 535 Status status = GetMouseButton(params, &button); 536 if (status.IsError()) 537 return status; 538 std::list<MouseEvent> events; 539 events.push_back( 540 MouseEvent(kReleasedMouseEventType, button, 541 session->mouse_position.x, session->mouse_position.y, 542 session->sticky_modifiers, 1)); 543 return web_view->DispatchMouseEvents(events, session->GetCurrentFrameId()); 544 } 545 546 Status ExecuteMouseDoubleClick( 547 Session* session, 548 WebView* web_view, 549 const base::DictionaryValue& params, 550 scoped_ptr<base::Value>* value) { 551 MouseButton button; 552 Status status = GetMouseButton(params, &button); 553 if (status.IsError()) 554 return status; 555 std::list<MouseEvent> events; 556 events.push_back( 557 MouseEvent(kPressedMouseEventType, button, 558 session->mouse_position.x, session->mouse_position.y, 559 session->sticky_modifiers, 2)); 560 events.push_back( 561 MouseEvent(kReleasedMouseEventType, button, 562 session->mouse_position.x, session->mouse_position.y, 563 session->sticky_modifiers, 2)); 564 return web_view->DispatchMouseEvents(events, session->GetCurrentFrameId()); 565 } 566 567 Status ExecuteTouchDown( 568 Session* session, 569 WebView* web_view, 570 const base::DictionaryValue& params, 571 scoped_ptr<base::Value>* value) { 572 return ExecuteTouchEvent(session, web_view, kTouchStart, params); 573 } 574 575 Status ExecuteTouchUp( 576 Session* session, 577 WebView* web_view, 578 const base::DictionaryValue& params, 579 scoped_ptr<base::Value>* value) { 580 return ExecuteTouchEvent(session, web_view, kTouchEnd, params); 581 } 582 583 Status ExecuteTouchMove( 584 Session* session, 585 WebView* web_view, 586 const base::DictionaryValue& params, 587 scoped_ptr<base::Value>* value) { 588 return ExecuteTouchEvent(session, web_view, kTouchMove, params); 589 } 590 591 Status ExecuteGetActiveElement( 592 Session* session, 593 WebView* web_view, 594 const base::DictionaryValue& params, 595 scoped_ptr<base::Value>* value) { 596 return GetActiveElement(session, web_view, value); 597 } 598 599 Status ExecuteSendKeysToActiveElement( 600 Session* session, 601 WebView* web_view, 602 const base::DictionaryValue& params, 603 scoped_ptr<base::Value>* value) { 604 const base::ListValue* key_list; 605 if (!params.GetList("value", &key_list)) 606 return Status(kUnknownError, "'value' must be a list"); 607 return SendKeysOnWindow( 608 web_view, key_list, false, &session->sticky_modifiers); 609 } 610 611 Status ExecuteGetAppCacheStatus( 612 Session* session, 613 WebView* web_view, 614 const base::DictionaryValue& params, 615 scoped_ptr<base::Value>* value) { 616 return web_view->EvaluateScript( 617 session->GetCurrentFrameId(), 618 "applicationCache.status", 619 value); 620 } 621 622 Status ExecuteIsBrowserOnline( 623 Session* session, 624 WebView* web_view, 625 const base::DictionaryValue& params, 626 scoped_ptr<base::Value>* value) { 627 return web_view->EvaluateScript( 628 session->GetCurrentFrameId(), 629 "navigator.onLine", 630 value); 631 } 632 633 Status ExecuteGetStorageItem( 634 const char* storage, 635 Session* session, 636 WebView* web_view, 637 const base::DictionaryValue& params, 638 scoped_ptr<base::Value>* value) { 639 std::string key; 640 if (!params.GetString("key", &key)) 641 return Status(kUnknownError, "'key' must be a string"); 642 base::ListValue args; 643 args.Append(new base::StringValue(key)); 644 return web_view->CallFunction( 645 session->GetCurrentFrameId(), 646 base::StringPrintf("function(key) { return %s[key]; }", storage), 647 args, 648 value); 649 } 650 651 Status ExecuteGetStorageKeys( 652 const char* storage, 653 Session* session, 654 WebView* web_view, 655 const base::DictionaryValue& params, 656 scoped_ptr<base::Value>* value) { 657 const char script[] = 658 "var keys = [];" 659 "for (var key in %s) {" 660 " keys.push(key);" 661 "}" 662 "keys"; 663 return web_view->EvaluateScript( 664 session->GetCurrentFrameId(), 665 base::StringPrintf(script, storage), 666 value); 667 } 668 669 Status ExecuteSetStorageItem( 670 const char* storage, 671 Session* session, 672 WebView* web_view, 673 const base::DictionaryValue& params, 674 scoped_ptr<base::Value>* value) { 675 std::string key; 676 if (!params.GetString("key", &key)) 677 return Status(kUnknownError, "'key' must be a string"); 678 std::string storage_value; 679 if (!params.GetString("value", &storage_value)) 680 return Status(kUnknownError, "'value' must be a string"); 681 base::ListValue args; 682 args.Append(new base::StringValue(key)); 683 args.Append(new base::StringValue(storage_value)); 684 return web_view->CallFunction( 685 session->GetCurrentFrameId(), 686 base::StringPrintf("function(key, value) { %s[key] = value; }", storage), 687 args, 688 value); 689 } 690 691 Status ExecuteRemoveStorageItem( 692 const char* storage, 693 Session* session, 694 WebView* web_view, 695 const base::DictionaryValue& params, 696 scoped_ptr<base::Value>* value) { 697 std::string key; 698 if (!params.GetString("key", &key)) 699 return Status(kUnknownError, "'key' must be a string"); 700 base::ListValue args; 701 args.Append(new base::StringValue(key)); 702 return web_view->CallFunction( 703 session->GetCurrentFrameId(), 704 base::StringPrintf("function(key) { %s.removeItem(key) }", storage), 705 args, 706 value); 707 } 708 709 Status ExecuteClearStorage( 710 const char* storage, 711 Session* session, 712 WebView* web_view, 713 const base::DictionaryValue& params, 714 scoped_ptr<base::Value>* value) { 715 return web_view->EvaluateScript( 716 session->GetCurrentFrameId(), 717 base::StringPrintf("%s.clear()", storage), 718 value); 719 } 720 721 Status ExecuteGetStorageSize( 722 const char* storage, 723 Session* session, 724 WebView* web_view, 725 const base::DictionaryValue& params, 726 scoped_ptr<base::Value>* value) { 727 return web_view->EvaluateScript( 728 session->GetCurrentFrameId(), 729 base::StringPrintf("%s.length", storage), 730 value); 731 } 732 733 Status ExecuteScreenshot( 734 Session* session, 735 WebView* web_view, 736 const base::DictionaryValue& params, 737 scoped_ptr<base::Value>* value) { 738 Status status = session->chrome->ActivateWebView(web_view->GetId()); 739 if (status.IsError()) 740 return status; 741 742 std::string screenshot; 743 if (session->chrome->GetAsDesktop() && !session->force_devtools_screenshot) { 744 AutomationExtension* extension = NULL; 745 status = 746 session->chrome->GetAsDesktop()->GetAutomationExtension(&extension); 747 if (status.IsError()) 748 return status; 749 status = extension->CaptureScreenshot(&screenshot); 750 // If the screenshot was forbidden, fallback to DevTools. 751 if (status.code() == kForbidden) 752 status = web_view->CaptureScreenshot(&screenshot); 753 } else { 754 status = web_view->CaptureScreenshot(&screenshot); 755 } 756 if (status.IsError()) 757 return status; 758 759 value->reset(new base::StringValue(screenshot)); 760 return Status(kOk); 761 } 762 763 Status ExecuteGetCookies( 764 Session* session, 765 WebView* web_view, 766 const base::DictionaryValue& params, 767 scoped_ptr<base::Value>* value) { 768 std::list<Cookie> cookies; 769 Status status = GetVisibleCookies(web_view, &cookies); 770 if (status.IsError()) 771 return status; 772 scoped_ptr<base::ListValue> cookie_list(new base::ListValue()); 773 for (std::list<Cookie>::const_iterator it = cookies.begin(); 774 it != cookies.end(); ++it) { 775 cookie_list->Append(CreateDictionaryFrom(*it)); 776 } 777 value->reset(cookie_list.release()); 778 return Status(kOk); 779 } 780 781 Status ExecuteAddCookie( 782 Session* session, 783 WebView* web_view, 784 const base::DictionaryValue& params, 785 scoped_ptr<base::Value>* value) { 786 const base::DictionaryValue* cookie; 787 if (!params.GetDictionary("cookie", &cookie)) 788 return Status(kUnknownError, "missing 'cookie'"); 789 base::ListValue args; 790 args.Append(cookie->DeepCopy()); 791 scoped_ptr<base::Value> result; 792 return web_view->CallFunction( 793 session->GetCurrentFrameId(), kAddCookieScript, args, &result); 794 } 795 796 Status ExecuteDeleteCookie( 797 Session* session, 798 WebView* web_view, 799 const base::DictionaryValue& params, 800 scoped_ptr<base::Value>* value) { 801 std::string name; 802 if (!params.GetString("name", &name)) 803 return Status(kUnknownError, "missing 'name'"); 804 base::DictionaryValue params_url; 805 scoped_ptr<base::Value> value_url; 806 std::string url; 807 Status status = GetUrl(web_view, session->GetCurrentFrameId(), &url); 808 if (status.IsError()) 809 return status; 810 return web_view->DeleteCookie(name, url); 811 } 812 813 Status ExecuteDeleteAllCookies( 814 Session* session, 815 WebView* web_view, 816 const base::DictionaryValue& params, 817 scoped_ptr<base::Value>* value) { 818 std::list<Cookie> cookies; 819 Status status = GetVisibleCookies(web_view, &cookies); 820 if (status.IsError()) 821 return status; 822 823 if (!cookies.empty()) { 824 base::DictionaryValue params_url; 825 scoped_ptr<base::Value> value_url; 826 std::string url; 827 status = GetUrl(web_view, session->GetCurrentFrameId(), &url); 828 if (status.IsError()) 829 return status; 830 for (std::list<Cookie>::const_iterator it = cookies.begin(); 831 it != cookies.end(); ++it) { 832 status = web_view->DeleteCookie(it->name, url); 833 if (status.IsError()) 834 return status; 835 } 836 } 837 838 return Status(kOk); 839 } 840 841 Status ExecuteSetLocation( 842 Session* session, 843 WebView* web_view, 844 const base::DictionaryValue& params, 845 scoped_ptr<base::Value>* value) { 846 const base::DictionaryValue* location = NULL; 847 Geoposition geoposition; 848 if (!params.GetDictionary("location", &location) || 849 !location->GetDouble("latitude", &geoposition.latitude) || 850 !location->GetDouble("longitude", &geoposition.longitude)) 851 return Status(kUnknownError, "missing or invalid 'location'"); 852 if (location->HasKey("accuracy") && 853 !location->GetDouble("accuracy", &geoposition.accuracy)) { 854 return Status(kUnknownError, "invalid 'accuracy'"); 855 } else { 856 // |accuracy| is not part of the WebDriver spec yet, so if it is not given 857 // default to 100 meters accuracy. 858 geoposition.accuracy = 100; 859 } 860 861 Status status = web_view->OverrideGeolocation(geoposition); 862 if (status.IsOk()) 863 session->overridden_geoposition.reset(new Geoposition(geoposition)); 864 return status; 865 } 866 867 Status ExecuteTakeHeapSnapshot( 868 Session* session, 869 WebView* web_view, 870 const base::DictionaryValue& params, 871 scoped_ptr<base::Value>* value) { 872 return web_view->TakeHeapSnapshot(value); 873 } 874
