[chromedriver] Implement commands: findChildElement, findChildElements.

chrome/test/chromedriver/commands.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/test/chromedriver/commands.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/rand_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/test/chromedriver/chrome.h"
 #include "chrome/test/chromedriver/chrome_launcher.h"
 #include "chrome/test/chromedriver/session.h"
 #include "chrome/test/chromedriver/status.h"
 #include "third_party/webdriver/atoms.h"
 
 namespace {
 
 Status FindElementByJs(
+    int interval_ms,
     bool only_one,
+    bool has_root_element,
     Session* session,
     const base::DictionaryValue& params,
     scoped_ptr<base::Value>* value) {
   std::string strategy;
   if (!params.GetString("using", &strategy))
     return Status(kUnknownError, "'using' must be a string");
   std::string target;
   if (!params.GetString("value", &target))
     return Status(kUnknownError, "'value' must be a string");
-
-  if (strategy == "class name")
-    strategy = "className";
-  else if (strategy == "css selector")
-    strategy = "css";
-  else if (strategy == "link text")
-    strategy = "linkText";
-  else if (strategy == "partial link text")
-    strategy = "partialLinkText";
-  else if (strategy == "tag name")
-    strategy = "tagName";
+  std::string root_element;
+  if (has_root_element && !params.GetString("id", &root_element))
+    return Status(kUnknownError, "'id' of root element must be a string");
 
   std::string script;
   if (only_one)
     script = webdriver::atoms::asString(webdriver::atoms::FIND_ELEMENT);
   else
     script = webdriver::atoms::asString(webdriver::atoms::FIND_ELEMENTS);
   scoped_ptr<base::DictionaryValue> locator(new base::DictionaryValue());
   locator->SetString(strategy, target);
   base::ListValue arguments;
   arguments.Append(locator.release());
+  if (has_root_element) {
+    scoped_ptr<base::DictionaryValue> id(new base::DictionaryValue());
+    id->SetString("ELEMENT", root_element);
+    arguments.Append(id.release());
+  }
 
   base::Time start_time = base::Time::Now();
   while (true) {
     scoped_ptr<base::Value> temp;
     Status status = session->chrome->CallFunction(
         session->frame, script, arguments, &temp);
     if (status.IsError())
       return status;
 
     if (!temp->IsType(base::Value::TYPE_NULL)) {
@@ skipping 14 matching lines @@
 
     if ((base::Time::Now() - start_time).InMilliseconds() >=
         session->implicit_wait) {
       if (only_one) {
         return Status(kNoSuchElement);
       } else {
         value->reset(new base::ListValue());
         return Status(kOk);
       }
     }
-    base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(50));
+    base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(interval_ms));
   }
 
   return Status(kUnknownError);
 }
 
 }  // namespace
 
 Status ExecuteNewSession(
     SessionMap* session_map,
     ChromeLauncher* launcher,
@@ skipping 137 matching lines @@
       "    return document.title;"
       "  else"
       "    return document.URL;"
       "}";
   base::ListValue args;
   return session->chrome->CallFunction(
       session->frame, kGetTitleScript, args, value);
 }
 
 Status ExecuteFindElement(
+    int interval_ms,
     Session* session,
     const base::DictionaryValue& params,
     scoped_ptr<base::Value>* value) {
-  return FindElementByJs(true, session, params, value);
+  return FindElementByJs(interval_ms, true, false, session, params, value);
 }
 
 Status ExecuteFindElements(
+    int interval_ms,
     Session* session,
     const base::DictionaryValue& params,
     scoped_ptr<base::Value>* value) {
-  return FindElementByJs(false, session, params, value);
+  return FindElementByJs(interval_ms, false, false, session, params, value);
+}
+
+Status ExecuteFindChildElement(
+    int interval_ms,
+    Session* session,
+    const base::DictionaryValue& params,
+    scoped_ptr<base::Value>* value) {
+  return FindElementByJs(interval_ms, true, true, session, params, value);
+}
+
+Status ExecuteFindChildElements(
+    int interval_ms,
+    Session* session,
+    const base::DictionaryValue& params,
+    scoped_ptr<base::Value>* value) {
+  return FindElementByJs(interval_ms, false, true, session, params, value);
 }
 
 Status ExecuteSetTimeout(
     Session* session,
     const base::DictionaryValue& params,
     scoped_ptr<base::Value>* value) {
   int ms;
   if (!params.GetInteger("ms", &ms) || ms < 0)
     return Status(kUnknownError, "'ms' must be a non-negative integer");
   std::string type;
   if (!params.GetString("type", &type))
     return Status(kUnknownError, "'type' must be a string");
   if (type == "implicit")
     session->implicit_wait = ms;
   else if (type == "script")
     session->script_timeout = ms;
   else if (type == "page load")
     session->page_load_timeout = ms;
   else
     return Status(kUnknownError, "unknown type of timeout:" + type);
   return Status(kOk);
 }