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/element_commands.h" 6 7 #include <cmath> 8 #include <list> 9 #include <vector> 10 11 #include "base/callback.h" 12 #include "base/files/file_path.h" 13 #include "base/strings/string_split.h" 14 #include "base/strings/stringprintf.h" 15 #include "base/threading/platform_thread.h" 16 #include "base/time/time.h" 17 #include "base/values.h" 18 #include "chrome/test/chromedriver/basic_types.h" 19 #include "chrome/test/chromedriver/chrome/browser_info.h" 20 #include "chrome/test/chromedriver/chrome/chrome.h" 21 #include "chrome/test/chromedriver/chrome/js.h" 22 #include "chrome/test/chromedriver/chrome/status.h" 23 #include "chrome/test/chromedriver/chrome/ui_events.h" 24 #include "chrome/test/chromedriver/chrome/web_view.h" 25 #include "chrome/test/chromedriver/element_util.h" 26 #include "chrome/test/chromedriver/session.h" 27 #include "chrome/test/chromedriver/util.h" 28 #include "third_party/webdriver/atoms.h" 29 30 const int kFlickTouchEventsPerSecond = 30; 31 32 namespace { 33 34 Status SendKeysToElement( 35 Session* session, 36 WebView* web_view, 37 const std::string& element_id, 38 const base::ListValue* key_list) { 39 bool is_displayed = false; 40 bool is_focused = false; 41 base::TimeTicks start_time = base::TimeTicks::Now(); 42 while (true) { 43 Status status = IsElementDisplayed( 44 session, web_view, element_id, true, &is_displayed); 45 if (status.IsError()) 46 return status; 47 if (is_displayed) 48 break; 49 status = IsElementFocused(session, web_view, element_id, &is_focused); 50 if (status.IsError()) 51 return status; 52 if (is_focused) 53 break; 54 if (base::TimeTicks::Now() - start_time >= session->implicit_wait) { 55 return Status(kElementNotVisible); 56 } 57 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100)); 58 } 59 60 bool is_enabled = false; 61 Status status = IsElementEnabled(session, web_view, element_id, &is_enabled); 62 if (status.IsError()) 63 return status; 64 if (!is_enabled) 65 return Status(kInvalidElementState); 66 67 if (!is_focused) { 68 base::ListValue args; 69 args.Append(CreateElement(element_id)); 70 scoped_ptr<base::Value> result; 71 status = web_view->CallFunction( 72 session->GetCurrentFrameId(), kFocusScript, args, &result); 73 if (status.IsError()) 74 return status; 75 } 76 77 return SendKeysOnWindow(web_view, key_list, true, &session->sticky_modifiers); 78 } 79 80 Status ExecuteTouchSingleTapAtom( 81 Session* session, 82 WebView* web_view, 83 const std::string& element_id, 84 const base::DictionaryValue& params, 85 scoped_ptr<base::Value>* value) { 86 base::ListValue args; 87 args.Append(CreateElement(element_id)); 88 return web_view->CallFunction( 89 session->GetCurrentFrameId(), 90 webdriver::atoms::asString(webdriver::atoms::TOUCH_SINGLE_TAP), 91 args, 92 value); 93 } 94 95 } // namespace 96 97 Status ExecuteElementCommand( 98 const ElementCommand& command, 99 Session* session, 100 WebView* web_view, 101 const base::DictionaryValue& params, 102 scoped_ptr<base::Value>* value) { 103 std::string id; 104 if (params.GetString("id", &id) || params.GetString("element", &id)) 105 return command.Run(session, web_view, id, params, value); 106 return Status(kUnknownError, "element identifier must be a string"); 107 } 108 109 Status ExecuteFindChildElement( 110 int interval_ms, 111 Session* session, 112 WebView* web_view, 113 const std::string& element_id, 114 const base::DictionaryValue& params, 115 scoped_ptr<base::Value>* value) { 116 return FindElement( 117 interval_ms, true, &element_id, session, web_view, params, value); 118 } 119 120 Status ExecuteFindChildElements( 121 int interval_ms, 122 Session* session, 123 WebView* web_view, 124 const std::string& element_id, 125 const base::DictionaryValue& params, 126 scoped_ptr<base::Value>* value) { 127 return FindElement( 128 interval_ms, false, &element_id, session, web_view, params, value); 129 } 130 131 Status ExecuteHoverOverElement( 132 Session* session, 133 WebView* web_view, 134 const std::string& element_id, 135 const base::DictionaryValue& params, 136 scoped_ptr<base::Value>* value) { 137 WebPoint location; 138 Status status = GetElementClickableLocation( 139 session, web_view, element_id, &location); 140 if (status.IsError()) 141 return status; 142 143 MouseEvent move_event( 144 kMovedMouseEventType, kNoneMouseButton, location.x, location.y, 145 session->sticky_modifiers, 0); 146 std::list<MouseEvent> events; 147 events.push_back(move_event); 148 status = web_view->DispatchMouseEvents(events, session->GetCurrentFrameId()); 149 if (status.IsOk()) 150 session->mouse_position = location; 151 return status; 152 } 153 154 Status ExecuteClickElement( 155 Session* session, 156 WebView* web_view, 157 const std::string& element_id, 158 const base::DictionaryValue& params, 159 scoped_ptr<base::Value>* value) { 160 std::string tag_name; 161 Status status = GetElementTagName(session, web_view, element_id, &tag_name); 162 if (status.IsError()) 163 return status; 164 if (tag_name == "option") { 165 bool is_toggleable; 166 status = IsOptionElementTogglable( 167 session, web_view, element_id, &is_toggleable); 168 if (status.IsError()) 169 return status; 170 if (is_toggleable) 171 return ToggleOptionElement(session, web_view, element_id); 172 else 173 return SetOptionElementSelected(session, web_view, element_id, true); 174 } else { 175 WebPoint location; 176 status = GetElementClickableLocation( 177 session, web_view, element_id, &location); 178 if (status.IsError()) 179 return status; 180 181 std::list<MouseEvent> events; 182 events.push_back( 183 MouseEvent(kMovedMouseEventType, kNoneMouseButton, 184 location.x, location.y, session->sticky_modifiers, 0)); 185 events.push_back( 186 MouseEvent(kPressedMouseEventType, kLeftMouseButton, 187 location.x, location.y, session->sticky_modifiers, 1)); 188 events.push_back( 189 MouseEvent(kReleasedMouseEventType, kLeftMouseButton, 190 location.x, location.y, session->sticky_modifiers, 1)); 191 status = 192 web_view->DispatchMouseEvents(events, session->GetCurrentFrameId()); 193 if (status.IsOk()) 194 session->mouse_position = location; 195 return status; 196 } 197 } 198 199 Status ExecuteTouchSingleTap( 200 Session* session, 201 WebView* web_view, 202 const std::string& element_id, 203 const base::DictionaryValue& params, 204 scoped_ptr<base::Value>* value) { 205 // Fall back to javascript atom for pre-m30 Chrome. 206 if (session->chrome->GetBrowserInfo()->build_no < 1576) 207 return ExecuteTouchSingleTapAtom( 208 session, web_view, element_id, params, value); 209 210 WebPoint location; 211 Status status = GetElementClickableLocation( 212 session, web_view, element_id, &location); 213 if (status.IsError()) 214 return status; 215 216 std::list<TouchEvent> events; 217 events.push_back( 218 TouchEvent(kTouchStart, location.x, location.y)); 219 events.push_back( 220 TouchEvent(kTouchEnd, location.x, location.y)); 221 return web_view->DispatchTouchEvents(events); 222 } 223 224 Status ExecuteFlick( 225 Session* session, 226 WebView* web_view, 227 const std::string& element_id, 228 const base::DictionaryValue& params, 229 scoped_ptr<base::Value>* value) { 230 WebPoint location; 231 Status status = GetElementClickableLocation( 232 session, web_view, element_id, &location); 233 if (status.IsError()) 234 return status; 235 236 int xoffset, yoffset, speed; 237 if (!params.GetInteger("xoffset", &xoffset)) 238 return Status(kUnknownError, "'xoffset' must be an integer"); 239 if (!params.GetInteger("yoffset", &yoffset)) 240 return Status(kUnknownError, "'yoffset' must be an integer"); 241 if (!params.GetInteger("speed", &speed)) 242 return Status(kUnknownError, "'speed' must be an integer"); 243 if (speed < 1) 244 return Status(kUnknownError, "'speed' must be a positive integer"); 245 246 status = web_view->DispatchTouchEvent( 247 TouchEvent(kTouchStart, location.x, location.y)); 248 if (status.IsError()) 249 return status; 250 251 const double offset = 252 std::sqrt(static_cast<double>(xoffset * xoffset + yoffset * yoffset)); 253 const double xoffset_per_event = 254 (speed * xoffset) / (kFlickTouchEventsPerSecond * offset); 255 const double yoffset_per_event = 256 (speed * yoffset) / (kFlickTouchEventsPerSecond * offset); 257 const int total_events = 258 (offset * kFlickTouchEventsPerSecond) / speed; 259 for (int i = 0; i < total_events; i++) { 260 status = web_view->DispatchTouchEvent( 261 TouchEvent(kTouchMove, 262 location.x + xoffset_per_event * i, 263 location.y + yoffset_per_event * i)); 264 if (status.IsError()) 265 return status; 266 base::PlatformThread::Sleep( 267 base::TimeDelta::FromMilliseconds(1000 / kFlickTouchEventsPerSecond)); 268 } 269 return web_view->DispatchTouchEvent( 270 TouchEvent(kTouchEnd, location.x + xoffset, location.y + yoffset)); 271 } 272 273 Status ExecuteClearElement( 274 Session* session, 275 WebView* web_view, 276 const std::string& element_id, 277 const base::DictionaryValue& params, 278 scoped_ptr<base::Value>* value) { 279 base::ListValue args; 280 args.Append(CreateElement(element_id)); 281 scoped_ptr<base::Value> result; 282 return web_view->CallFunction( 283 session->GetCurrentFrameId(), 284 webdriver::atoms::asString(webdriver::atoms::CLEAR), 285 args, &result); 286 } 287 288 Status ExecuteSendKeysToElement( 289 Session* session, 290 WebView* web_view, 291 const std::string& element_id, 292 const base::DictionaryValue& params, 293 scoped_ptr<base::Value>* value) { 294 const base::ListValue* key_list; 295 if (!params.GetList("value", &key_list)) 296 return Status(kUnknownError, "'value' must be a list"); 297 298 bool is_input = false; 299 Status status = IsElementAttributeEqualToIgnoreCase( 300 session, web_view, element_id, "tagName", "input", &is_input); 301 if (status.IsError()) 302 return status; 303 bool is_file = false; 304 status = IsElementAttributeEqualToIgnoreCase( 305 session, web_view, element_id, "type", "file", &is_file); 306 if (status.IsError()) 307 return status; 308 if (is_input && is_file) { 309 // Compress array into a single string. 310 base::FilePath::StringType paths_string; 311 for (size_t i = 0; i < key_list->GetSize(); ++i) { 312 base::FilePath::StringType path_part; 313 if (!key_list->GetString(i, &path_part)) 314 return Status(kUnknownError, "'value' is invalid"); 315 paths_string.append(path_part); 316 } 317 318 // Separate the string into separate paths, delimited by '\n'. 319 std::vector<base::FilePath::StringType> path_strings; 320 base::SplitString(paths_string, '\n', &path_strings); 321 std::vector<base::FilePath> paths; 322 for (size_t i = 0; i < path_strings.size(); ++i) 323 paths.push_back(base::FilePath(path_strings[i])); 324 325 bool multiple = false; 326 status = IsElementAttributeEqualToIgnoreCase( 327 session, web_view, element_id, "multiple", "true", &multiple); 328 if (status.IsError()) 329 return status; 330 if (!multiple && paths.size() > 1) 331 return Status(kUnknownError, "the element can not hold multiple files"); 332 333 scoped_ptr<base::DictionaryValue> element(CreateElement(element_id)); 334 return web_view->SetFileInputFiles( 335 session->GetCurrentFrameId(), *element, paths); 336 } else { 337 return SendKeysToElement(session, web_view, element_id, key_list); 338 } 339 } 340 341 Status ExecuteSubmitElement( 342 Session* session, 343 WebView* web_view, 344 const std::string& element_id, 345 const base::DictionaryValue& params, 346 scoped_ptr<base::Value>* value) { 347 base::ListValue args; 348 args.Append(CreateElement(element_id)); 349 return web_view->CallFunction( 350 session->GetCurrentFrameId(), 351 webdriver::atoms::asString(webdriver::atoms::SUBMIT), 352 args, 353 value); 354 } 355 356 Status ExecuteGetElementText( 357 Session* session, 358 WebView* web_view, 359 const std::string& element_id, 360 const base::DictionaryValue& params, 361 scoped_ptr<base::Value>* value) { 362 base::ListValue args; 363 args.Append(CreateElement(element_id)); 364 return web_view->CallFunction( 365 session->GetCurrentFrameId(), 366 webdriver::atoms::asString(webdriver::atoms::GET_TEXT), 367 args, 368 value); 369 } 370 371 Status ExecuteGetElementValue( 372 Session* session, 373 WebView* web_view, 374 const std::string& element_id, 375 const base::DictionaryValue& params, 376 scoped_ptr<base::Value>* value) { 377 base::ListValue args; 378 args.Append(CreateElement(element_id)); 379 return web_view->CallFunction( 380 session->GetCurrentFrameId(), 381 "function(elem) { return elem['value'] }", 382 args, 383 value); 384 } 385 386 Status ExecuteGetElementTagName( 387 Session* session, 388 WebView* web_view, 389 const std::string& element_id, 390 const base::DictionaryValue& params, 391 scoped_ptr<base::Value>* value) { 392 base::ListValue args; 393 args.Append(CreateElement(element_id)); 394 return web_view->CallFunction( 395 session->GetCurrentFrameId(), 396 "function(elem) { return elem.tagName.toLowerCase() }", 397 args, 398 value); 399 } 400 401 Status ExecuteIsElementSelected( 402 Session* session, 403 WebView* web_view, 404 const std::string& element_id, 405 const base::DictionaryValue& params, 406 scoped_ptr<base::Value>* value) { 407 base::ListValue args; 408 args.Append(CreateElement(element_id)); 409 return web_view->CallFunction( 410 session->GetCurrentFrameId(), 411 webdriver::atoms::asString(webdriver::atoms::IS_SELECTED), 412 args, 413 value); 414 } 415 416 Status ExecuteIsElementEnabled( 417 Session* session, 418 WebView* web_view, 419 const std::string& element_id, 420 const base::DictionaryValue& params, 421 scoped_ptr<base::Value>* value) { 422 base::ListValue args; 423 args.Append(CreateElement(element_id)); 424 return web_view->CallFunction( 425 session->GetCurrentFrameId(), 426 webdriver::atoms::asString(webdriver::atoms::IS_ENABLED), 427 args, 428 value); 429 } 430 431 Status ExecuteIsElementDisplayed( 432 Session* session, 433 WebView* web_view, 434 const std::string& element_id, 435 const base::DictionaryValue& params, 436 scoped_ptr<base::Value>* value) { 437 base::ListValue args; 438 args.Append(CreateElement(element_id)); 439 return web_view->CallFunction( 440 session->GetCurrentFrameId(), 441 webdriver::atoms::asString(webdriver::atoms::IS_DISPLAYED), 442 args, 443 value); 444 } 445 446 Status ExecuteGetElementLocation( 447 Session* session, 448 WebView* web_view, 449 const std::string& element_id, 450 const base::DictionaryValue& params, 451 scoped_ptr<base::Value>* value) { 452 base::ListValue args; 453 args.Append(CreateElement(element_id)); 454 return web_view->CallFunction( 455 session->GetCurrentFrameId(), 456 webdriver::atoms::asString(webdriver::atoms::GET_LOCATION), 457 args, 458 value); 459 } 460 461 Status ExecuteGetElementLocationOnceScrolledIntoView( 462 Session* session, 463 WebView* web_view, 464 const std::string& element_id, 465 const base::DictionaryValue& params, 466 scoped_ptr<base::Value>* value) { 467 WebPoint location; 468 Status status = ScrollElementIntoView( 469 session, web_view, element_id, &location); 470 if (status.IsError()) 471 return status; 472 value->reset(CreateValueFrom(location)); 473 return Status(kOk); 474 } 475 476 Status ExecuteGetElementSize( 477 Session* session, 478 WebView* web_view, 479 const std::string& element_id, 480 const base::DictionaryValue& params, 481 scoped_ptr<base::Value>* value) { 482 base::ListValue args; 483 args.Append(CreateElement(element_id)); 484 return web_view->CallFunction( 485 session->GetCurrentFrameId(), 486 webdriver::atoms::asString(webdriver::atoms::GET_SIZE), 487 args, 488 value); 489 } 490 491 Status ExecuteGetElementAttribute( 492 Session* session, 493 WebView* web_view, 494 const std::string& element_id, 495 const base::DictionaryValue& params, 496 scoped_ptr<base::Value>* value) { 497 std::string name; 498 if (!params.GetString("name", &name)) 499 return Status(kUnknownError, "missing 'name'"); 500 return GetElementAttribute(session, web_view, element_id, name, value); 501 } 502 503 Status ExecuteGetElementValueOfCSSProperty( 504 Session* session, 505 WebView* web_view, 506 const std::string& element_id, 507 const base::DictionaryValue& params, 508 scoped_ptr<base::Value>* value) { 509 std::string property_name; 510 if (!params.GetString("propertyName", &property_name)) 511 return Status(kUnknownError, "missing 'propertyName'"); 512 std::string property_value; 513 Status status = GetElementEffectiveStyle( 514 session, web_view, element_id, property_name, &property_value); 515 if (status.IsError()) 516 return status; 517 value->reset(new base::StringValue(property_value)); 518 return Status(kOk); 519 } 520 521 Status ExecuteElementEquals( 522 Session* session, 523 WebView* web_view, 524 const std::string& element_id, 525 const base::DictionaryValue& params, 526 scoped_ptr<base::Value>* value) { 527 std::string other_element_id; 528 if (!params.GetString("other", &other_element_id)) 529 return Status(kUnknownError, "'other' must be a string"); 530 value->reset(new base::FundamentalValue(element_id == other_element_id)); 531 return Status(kOk); 532 } 533
