File upload API in chromedriver

chrome/test/webdriver/commands/webelement_commands.cc

 // Copyright (c) 2011 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/webdriver/commands/webelement_commands.h"
 
+#include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/third_party/icu/icu_utf.h"
 #include "base/values.h"
 #include "chrome/test/webdriver/commands/response.h"
 #include "chrome/test/webdriver/session.h"
 #include "chrome/test/webdriver/webdriver_error.h"
 #include "third_party/webdriver/atoms.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/size.h"
 
@@ skipping 40 matching lines @@
 }
 
 void ElementAttributeCommand::ExecuteGet(Response* const response) {
   // There should be at least 7 segments to match
   // "/session/$session/element/$id/attribute/$name"
   if (path_segments_.size() < 7) {
     response->SetError(new Error(kBadRequest, "Path segments is less than 7"));
     return;
   }
 
-  std::string script = base::StringPrintf(
-      "return (%s).apply(null, arguments);", atoms::GET_ATTRIBUTE);
-
-  ListValue args;
-  args.Append(element.ToValue());
-  args.Append(Value::CreateStringValue(path_segments_.at(6)));
-
-  Value* result = NULL;
-  Error* error = session_->ExecuteScript(script, &args, &result);
+  const std::string key = path_segments_.at(6);
+  Value* value;
+  Error* error = session_->GetAttribute(element, key, &value);
   if (error) {
     response->SetError(error);
     return;
   }
-  response->SetValue(result);
+
+  response->SetValue(value);
 }
 
 ///////////////////// ElementClearCommand ////////////////////
 
 ElementClearCommand::ElementClearCommand(
     const std::vector<std::string>& path_segments,
     DictionaryValue* parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 ElementClearCommand::~ElementClearCommand() {}
@@ skipping 399 matching lines @@
   if (!result->IsType(Value::TYPE_STRING) &&
       !result->IsType(Value::TYPE_NULL)) {
     response->SetError(new Error(
         kUnknownError, "Result is not string or null type"));
     return;
   }
   response->SetValue(result.release());
 }
 
 void ElementValueCommand::ExecutePost(Response* const response) {
+  bool is_input = false;
+  Error* error = HasAttributeWithLowerCaseValueASCII("tagName", "input",
+                                                     &is_input);
+  if (error) {
+    response->SetError(error);
+    return;
+  }
+
+  bool is_file = false;
+  error = HasAttributeWithLowerCaseValueASCII("type", "file", &is_file);
+  if (error) {
+    response->SetError(error);
+    return;
+  }
+
+  // If the element is a file upload control, set the file paths to the element.
+  // Otherwise send the value to the element as key input.
+  if (is_input && is_file) {
+    error = DragAndDropFilePaths();
+  } else {
+    error = SendKeys();
+  }
+
+  if (error) {
+    response->SetError(error);
+    return;
+  }
+}
+
+Error* ElementValueCommand::HasAttributeWithLowerCaseValueASCII(
+    const std::string& key, const std::string& value, bool* result) const {
+  Value* unscoped_value = NULL;
+  Error* error = session_->GetAttribute(element, key, &unscoped_value);
+  scoped_ptr<Value> scoped_value(unscoped_value);
+  unscoped_value = NULL;
+
+  if (error) {
+    return error;
+  }
+
+  std::string actual_value;
+  if (!scoped_value->GetAsString(&actual_value)) {
+    return new Error(kUnknownError,
+                     StringPrintf("Attribute '%s' did not have a string value",

[kkania, 2011/06/07 15:12:04]

base::StringPrintf is preferred

[nodchip, 2011/06/08 02:37:19]

Done.

+                                  key.c_str()));
+  }
+
+  *result = LowerCaseEqualsASCII(actual_value, value.c_str());
+  return NULL;
+}
+
+Error* ElementValueCommand::DragAndDropFilePaths() const {
+  ListValue* path_list;
+  if (!GetListParameter("value", &path_list)) {
+    return new Error(kBadRequest, "Missing or invalid 'value' parameter");
+  }
+
+  std::vector<std::string> paths;
+  for (size_t i = 0; i < path_list->GetSize(); ++i) {
+    FilePath::StringType path;
+    if (!path_list->GetString(i, &path)) {
+      return new Error(kBadRequest,
+                       StringPrintf("%zd-th element in 'value' is not string",

[kkania, 2011/06/07 15:12:04]

The style guide says use %"PRIuS" for size_t
(http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=64-bit...),
include base/format_macros.h

How about base::StringPrintf("'value' list item #%" PRIuS " is not a string", i
+ 1)

[nodchip, 2011/06/08 02:37:19]

Done.

+                                    i));
+    }
+
+    if (!file_util::PathExists(FilePath(path))) {

[kkania, 2011/06/07 15:12:04]

Does the spec actually disallow non-existent file paths?

[nodchip, 2011/06/08 02:37:19]

There are no spec about file uploading in the official spec. IEDriver
unofficially supports the stuff. In IEDriver, if the file does not exits, the
file dialog would show an error dialog. (I have not tested, though.) I'm not
sure what is the best behavior when the file does not exist.

On 2011/06/07 15:12:04, kkania wrote:

+      return new Error(kBadRequest,
+                       StringPrintf("'%s' does not exist on the file system",

[kkania, 2011/06/07 15:12:04]

base::

[nodchip, 2011/06/08 02:37:19]

Done.

+                                    path.c_str()));
+    }
+
+    paths.push_back(path);
+  }
+
+  gfx::Point location;
+  Error* error = session_->GetClickableLocation(element, &location);
+  if (error) {
+    return error;
+  }
+
+  return session_->DragAndDropFilePaths(location, paths);
+}
+
+Error* ElementValueCommand::SendKeys() const {
   ListValue* key_list;
   if (!GetListParameter("value", &key_list)) {
-    response->SetError(new Error(
-        kBadRequest, "Missing or invalid 'value' parameter"));
-    return;
+    return new Error(kBadRequest, "Missing or invalid 'value' parameter");
   }
+
   // Flatten the given array of strings into one.
   string16 keys;
   for (size_t i = 0; i < key_list->GetSize(); ++i) {
     string16 keys_list_part;
     key_list->GetString(i, &keys_list_part);
     for (size_t j = 0; j < keys_list_part.size(); ++j) {
       if (CBU16_IS_SURROGATE(keys_list_part[j])) {
-        response->SetError(new Error(
-            kBadRequest, "ChromeDriver only supports characters in the BMP"));
-        return;
+        return new Error(kBadRequest,
+                         "ChromeDriver only supports characters in the BMP");
       }
     }
     keys.append(keys_list_part);
   }
 
-  Error* error = session_->SendKeys(element, keys);
-  if (error)
-    response->SetError(error);
+  return session_->SendKeys(element, keys);
 }
 
 ///////////////////// ElementTextCommand ////////////////////
 
 ElementTextCommand::ElementTextCommand(
     const std::vector<std::string>& path_segments,
     DictionaryValue* parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 ElementTextCommand::~ElementTextCommand() {}
@@ skipping 18 matching lines @@
     return;
   }
   if (!result->IsType(Value::TYPE_STRING)) {
     response->SetError(new Error(kUnknownError, "Result is not string type"));
     return;
   }
   response->SetValue(result.release());
 }
 
 }  // namespace webdriver