Correct const accessors in base/values.(h|cc)

chrome/test/webdriver/commands/webelement_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/webdriver/commands/webelement_commands.h"
 
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_split.h"
@@ skipping 34 matching lines @@
   // We cannot verify the ID is valid until we execute the command and
   // inject the ID into the in-page cache.
   element = ElementId(path_segments_.at(4));
   return true;
 }
 
 ///////////////////// ElementAttributeCommand ////////////////////
 
 ElementAttributeCommand::ElementAttributeCommand(
     const std::vector<std::string>& path_segments,
-    DictionaryValue* parameters)
+    const DictionaryValue* parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 ElementAttributeCommand::~ElementAttributeCommand() {}
 
 bool ElementAttributeCommand::DoesGet() {
   return true;
 }
 
 void ElementAttributeCommand::ExecuteGet(Response* const response) {
   // There should be at least 7 segments to match
@@ skipping 11 matching lines @@
     return;
   }
 
   response->SetValue(value);
 }
 
 ///////////////////// ElementClearCommand ////////////////////
 
 ElementClearCommand::ElementClearCommand(
     const std::vector<std::string>& path_segments,
-    DictionaryValue* parameters)
+    const DictionaryValue* parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 ElementClearCommand::~ElementClearCommand() {}
 
 bool ElementClearCommand::DoesPost() {
   return true;
 }
 
 void ElementClearCommand::ExecutePost(Response* const response) {
   ListValue args;
   args.Append(element.ToValue());
 
   std::string script = base::StringPrintf(
       "(%s).apply(null, arguments);", atoms::asString(atoms::CLEAR).c_str());
 
   Value* result = NULL;
   Error* error = session_->ExecuteScript(script, &args, &result);
   if (error) {
     response->SetError(error);
     return;
   }
   response->SetValue(result);
 }
 
 ///////////////////// ElementCssCommand ////////////////////
 
 ElementCssCommand::ElementCssCommand(
     const std::vector<std::string>& path_segments,
-    DictionaryValue* parameters)
+    const DictionaryValue* parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 ElementCssCommand::~ElementCssCommand() {}
 
 bool ElementCssCommand::DoesGet() {
   return true;
 }
 
 void ElementCssCommand::ExecuteGet(Response* const response) {
   // There should be at least 7 segments to match
@@ skipping 17 matching lines @@
     response->SetError(error);
     return;
   }
   response->SetValue(result);
 }
 
 ///////////////////// ElementDisplayedCommand ////////////////////
 
 ElementDisplayedCommand::ElementDisplayedCommand(
     const std::vector<std::string>& path_segments,
-    DictionaryValue* parameters)
+    const DictionaryValue* parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 ElementDisplayedCommand::~ElementDisplayedCommand() {}
 
 bool ElementDisplayedCommand::DoesGet() {
   return true;
 }
 
 void ElementDisplayedCommand::ExecuteGet(Response* const response) {
   bool is_displayed;
   Error* error = session_->IsElementDisplayed(
       session_->current_target(), element, false /* ignore_opacity */,
       &is_displayed);
   if (error) {
     response->SetError(error);
     return;
   }
   response->SetValue(Value::CreateBooleanValue(is_displayed));
 }
 
 ///////////////////// ElementEnabledCommand ////////////////////
 
 ElementEnabledCommand::ElementEnabledCommand(
     const std::vector<std::string>& path_segments,
-    DictionaryValue* parameters)
+    const DictionaryValue* parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 ElementEnabledCommand::~ElementEnabledCommand() {}
 
 bool ElementEnabledCommand::DoesGet() {
   return true;
 }
 
 void ElementEnabledCommand::ExecuteGet(Response* const response) {
   ListValue args;
   args.Append(element.ToValue());
 
   std::string script = base::StringPrintf(
       "return (%s).apply(null, arguments);",
       atoms::asString(atoms::IS_ENABLED).c_str());
 
   Value* result = NULL;
   Error* error = session_->ExecuteScript(script, &args, &result);
   if (error) {
     response->SetError(error);
     return;
   }
   response->SetValue(result);
 }
 
 ///////////////////// ElementEqualsCommand ////////////////////
 
 ElementEqualsCommand::ElementEqualsCommand(
     const std::vector<std::string>& path_segments,
-    DictionaryValue* parameters)
+    const DictionaryValue* parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 ElementEqualsCommand::~ElementEqualsCommand() {}
 
 bool ElementEqualsCommand::DoesGet() {
   return true;
 }
 
 void ElementEqualsCommand::ExecuteGet(Response* const response) {
   // There should be at least 7 segments to match
@@ skipping 17 matching lines @@
     response->SetError(error);
     return;
   }
   response->SetValue(result);
 }
 
 ///////////////////// ElementLocationCommand ////////////////////
 
 ElementLocationCommand::ElementLocationCommand(
     const std::vector<std::string>& path_segments,
-    DictionaryValue* parameters)
+    const DictionaryValue* parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 ElementLocationCommand::~ElementLocationCommand() {}
 
 bool ElementLocationCommand::DoesGet() {
   return true;
 }
 
 void ElementLocationCommand::ExecuteGet(Response* const response) {
   std::string script = base::StringPrintf(
       "return (%s).apply(null, arguments);",
       atoms::asString(atoms::GET_LOCATION).c_str());
 
   ListValue args;
   args.Append(element.ToValue());
 
   Value* result = NULL;
   Error* error = session_->ExecuteScript(script, &args, &result);
   if (error) {
     response->SetError(error);
     return;
   }
   response->SetValue(result);
 }
 
 ///////////////////// ElementLocationInViewCommand ////////////////////
 
 ElementLocationInViewCommand::ElementLocationInViewCommand(
     const std::vector<std::string>& path_segments,
-    DictionaryValue* parameters)
+    const DictionaryValue* parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 ElementLocationInViewCommand::~ElementLocationInViewCommand() {}
 
 bool ElementLocationInViewCommand::DoesGet() {
   return true;
 }
 
 void ElementLocationInViewCommand::ExecuteGet(Response* const response) {
   Point location;
   Error* error = session_->GetElementLocationInView(element, &location);
   if (error) {
     response->SetError(error);
     return;
   }
   DictionaryValue* coord_dict = new DictionaryValue();
   coord_dict->SetInteger("x", location.x());
   coord_dict->SetInteger("y", location.y());
   response->SetValue(coord_dict);
 }
 
 ///////////////////// ElementNameCommand ////////////////////
 
 ElementNameCommand::ElementNameCommand(
     const std::vector<std::string>& path_segments,
-    DictionaryValue* parameters)
+    const DictionaryValue* parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 ElementNameCommand::~ElementNameCommand() {}
 
 bool ElementNameCommand::DoesGet() {
   return true;
 }
 
 void ElementNameCommand::ExecuteGet(Response* const response) {
   std::string tag_name;
   Error* error = session_->GetElementTagName(
       session_->current_target(), element, &tag_name);
   if (error) {
     response->SetError(error);
     return;
   }
   response->SetValue(Value::CreateStringValue(tag_name));
 }
 
 ///////////////////// ElementSelectedCommand ////////////////////
 
 ElementSelectedCommand::ElementSelectedCommand(
     const std::vector<std::string>& path_segments,
-    DictionaryValue* parameters)
+    const DictionaryValue* parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 ElementSelectedCommand::~ElementSelectedCommand() {}
 
 bool ElementSelectedCommand::DoesGet() {
   return true;
 }
 
 bool ElementSelectedCommand::DoesPost() {
   return true;
@@ skipping 16 matching lines @@
   if (error) {
     response->SetError(error);
     return;
   }
 }
 
 ///////////////////// ElementSizeCommand ////////////////////
 
 ElementSizeCommand::ElementSizeCommand(
     const std::vector<std::string>& path_segments,
-    DictionaryValue* parameters)
+    const DictionaryValue* parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 ElementSizeCommand::~ElementSizeCommand() {}
 
 bool ElementSizeCommand::DoesGet() {
   return true;
 }
 
 void ElementSizeCommand::ExecuteGet(Response* const response) {
   Size size;
   Error* error = session_->GetElementSize(
       session_->current_target(), element, &size);
   if (error) {
     response->SetError(error);
     return;
   }
   DictionaryValue* dict = new DictionaryValue();
   dict->SetInteger("width", size.width());
   dict->SetInteger("height", size.height());
   response->SetValue(dict);
 }
 
 ///////////////////// ElementSubmitCommand ////////////////////
 
 ElementSubmitCommand::ElementSubmitCommand(
     const std::vector<std::string>& path_segments,
-    DictionaryValue* parameters)
+    const DictionaryValue* parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 ElementSubmitCommand::~ElementSubmitCommand() {}
 
 bool ElementSubmitCommand::DoesPost() {
   return true;
 }
 
 void ElementSubmitCommand::ExecutePost(Response* const response) {
   std::string script = base::StringPrintf(
       "(%s).apply(null, arguments);", atoms::asString(atoms::SUBMIT).c_str());
 
   ListValue args;
   args.Append(element.ToValue());
 
   Value* result = NULL;
   Error* error = session_->ExecuteScript(script, &args, &result);
   if (error) {
     response->SetError(error);
     return;
   }
   response->SetValue(result);
 }
 
 ///////////////////// ElementToggleCommand ////////////////////
 
 ElementToggleCommand::ElementToggleCommand(
     const std::vector<std::string>& path_segments,
-    DictionaryValue* parameters)
+    const DictionaryValue* parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 ElementToggleCommand::~ElementToggleCommand() {}
 
 bool ElementToggleCommand::DoesPost() {
   return true;
 }
 
 void ElementToggleCommand::ExecutePost(Response* const response) {
   std::string script = base::StringPrintf(
       "return (%s).apply(null, arguments);",
       atoms::asString(atoms::CLICK).c_str());
 
   ListValue args;
   args.Append(element.ToValue());
 
   Value* result = NULL;
   Error* error = session_->ExecuteScript(script, &args, &result);
   if (error) {
     response->SetError(error);
     return;
   }
   response->SetValue(result);
 }
 
 ///////////////////// ElementValueCommand ////////////////////
 
 ElementValueCommand::ElementValueCommand(
     const std::vector<std::string>& path_segments,
-    DictionaryValue* parameters)
+    const DictionaryValue* parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 ElementValueCommand::~ElementValueCommand() {}
 
 bool ElementValueCommand::DoesGet() {
   return true;
 }
 
 bool ElementValueCommand::DoesPost() {
   return true;
@@ skipping 63 matching lines @@
   if (scoped_value->GetAsString(&actual_value)) {
     *result = LowerCaseEqualsASCII(actual_value, value.c_str());
   } else {
     // Note we do not handle converting a number to a string.
     *result = false;
   }
   return NULL;
 }
 
 Error* ElementValueCommand::DragAndDropFilePaths() const {
-  ListValue* path_list;
+  const ListValue* path_list;
   if (!GetListParameter("value", &path_list))
     return new Error(kBadRequest, "Missing or invalid 'value' parameter");
 
   // Compress array into single string.
   FilePath::StringType paths_string;
   for (size_t i = 0; i < path_list->GetSize(); ++i) {
     FilePath::StringType path_part;
     if (!path_list->GetString(i, &path_part)) {
       return new Error(
           kBadRequest,
@@ skipping 27 matching lines @@
 
   Point location;
   error = session_->GetClickableLocation(element, &location);
   if (error)
     return error;
 
   return session_->DragAndDropFilePaths(location, paths);
 }
 
 Error* ElementValueCommand::SendKeys() const {
-  ListValue* key_list;
+  const ListValue* key_list;
   if (!GetListParameter("value", &key_list)) {
     return new Error(kBadRequest, "Missing or invalid 'value' parameter");
   }
 
   // Flatten the given array of strings into one.
   string16 keys;
   Error* error = FlattenStringArray(key_list, &keys);
   if (error)
     return error;
 
   return session_->SendKeys(element, keys);
 }
 
 ///////////////////// ElementTextCommand ////////////////////
 
 ElementTextCommand::ElementTextCommand(
     const std::vector<std::string>& path_segments,
-    DictionaryValue* parameters)
+    const DictionaryValue* parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 ElementTextCommand::~ElementTextCommand() {}
 
 bool ElementTextCommand::DoesGet() {
   return true;
 }
 
 void ElementTextCommand::ExecuteGet(Response* const response) {
   Value* unscoped_result = NULL;
@@ skipping 12 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