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

chrome/test/webdriver/commands/mouse_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/mouse_commands.h"
 
 #include "base/values.h"
 #include "chrome/common/automation_constants.h"
 #include "chrome/test/automation/value_conversion_util.h"
 #include "chrome/test/webdriver/commands/response.h"
 #include "chrome/test/webdriver/webdriver_basic_types.h"
 #include "chrome/test/webdriver/webdriver_element_id.h"
 #include "chrome/test/webdriver/webdriver_error.h"
 #include "chrome/test/webdriver/webdriver_session.h"
 #include "chrome/test/webdriver/webdriver_util.h"
 
 namespace {
 
 const int kLeftButton = 0;
 const int kMiddleButton = 1;
 const int kRightButton = 2;
 
 }  // namespace
 
 namespace webdriver {
 
 MoveAndClickCommand::MoveAndClickCommand(
     const std::vector<std::string>& path_segments,
-    const DictionaryValue* const parameters)
+    DictionaryValue* const parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 MoveAndClickCommand::~MoveAndClickCommand() {}
 
 bool MoveAndClickCommand::DoesPost() {
   return true;
 }
 
 void MoveAndClickCommand::ExecutePost(Response* response) {
   std::string tag_name;
@@ skipping 41 matching lines @@
     if (!error)
       error = session_->MouseMoveAndClick(location, automation::kLeftButton);
   }
   if (error) {
     response->SetError(error);
     return;
   }
 }
 
 HoverCommand::HoverCommand(const std::vector<std::string>& path_segments,
-                           const DictionaryValue* const parameters)
+                           DictionaryValue* const parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 HoverCommand::~HoverCommand() {}
 
 bool HoverCommand::DoesPost() {
   return true;
 }
 
 void HoverCommand::ExecutePost(Response* response) {
   Error* error = NULL;
   Point location;
   error = session_->GetClickableLocation(element, &location);
   if (!error)
     error = session_->MouseMove(location);
   if (error) {
     response->SetError(error);
     return;
   }
 }
 
 DragCommand::DragCommand(const std::vector<std::string>& path_segments,
-                         const DictionaryValue* const parameters)
+                         DictionaryValue* const parameters)
     : WebElementCommand(path_segments, parameters) {}
 
 DragCommand::~DragCommand() {}
 
 bool DragCommand::Init(Response* const response) {
   if (!WebElementCommand::Init(response))
     return false;
 
   if (!GetIntegerParameter("x", &drag_x_) ||
       !GetIntegerParameter("y", &drag_y_)) {
@@ skipping 25 matching lines @@
     error = session_->MouseDrag(drag_from, drag_to);
 
   if (error) {
     response->SetError(error);
     return;
   }
 }
 
 AdvancedMouseCommand::AdvancedMouseCommand(
     const std::vector<std::string>& path_segments,
-    const DictionaryValue* const parameters)
+    DictionaryValue* const parameters)
     : WebDriverCommand(path_segments, parameters) {}
 
 AdvancedMouseCommand::~AdvancedMouseCommand() {}
 
 bool AdvancedMouseCommand::DoesPost() {
   return true;
 }
 
 MoveToCommand::MoveToCommand(
     const std::vector<std::string>& path_segments,
-    const DictionaryValue* const parameters)
+    DictionaryValue* const parameters)
     : AdvancedMouseCommand(path_segments, parameters), has_element_(false),
       has_offset_(false), x_offset_(0), y_offset_(0) {}
 
 MoveToCommand::~MoveToCommand() {}
 
 bool MoveToCommand::Init(Response* const response) {
   if (!AdvancedMouseCommand::Init(response))
     return false;
 
   std::string element_name;
@@ skipping 50 matching lines @@
   }
 
   error = session_->MouseMove(location);
   if (error) {
     response->SetError(error);
     return;
   }
 }
 
 ClickCommand::ClickCommand(const std::vector<std::string>& path_segments,
-                           const DictionaryValue* const parameters)
+                           DictionaryValue* const parameters)
     : AdvancedMouseCommand(path_segments, parameters) {}
 
 ClickCommand::~ClickCommand() {}
 
 bool ClickCommand::Init(Response* const response) {
   if (!AdvancedMouseCommand::Init(response))
     return false;
 
   if (!GetIntegerParameter("button", &button_)) {
     response->SetError(new Error(kBadRequest, "Missing mouse button argument"));
@@ skipping 19 matching lines @@
 
   Error* error = session_->MouseClick(button);
   if (error) {
     response->SetError(error);
     return;
   }
 }
 
 ButtonDownCommand::ButtonDownCommand(
     const std::vector<std::string>& path_segments,
-    const DictionaryValue* const parameters)
+    DictionaryValue* const parameters)
     : AdvancedMouseCommand(path_segments, parameters) {}
 
 ButtonDownCommand::~ButtonDownCommand() {}
 
 void ButtonDownCommand::ExecutePost(Response* const response) {
   session_->MouseButtonDown();
 }
 
 ButtonUpCommand::ButtonUpCommand(const std::vector<std::string>& path_segments,
-                                 const DictionaryValue* const parameters)
+                                 DictionaryValue* const parameters)
     : AdvancedMouseCommand(path_segments, parameters) {}
 
 ButtonUpCommand::~ButtonUpCommand() {}
 
 void ButtonUpCommand::ExecutePost(Response* const response) {
   session_->MouseButtonUp();
 }
 
 DoubleClickCommand::DoubleClickCommand(
     const std::vector<std::string>& path_segments,
-    const DictionaryValue* const parameters)
+    DictionaryValue* const parameters)
     : AdvancedMouseCommand(path_segments, parameters) {}
 
 DoubleClickCommand::~DoubleClickCommand() {}
 
 void DoubleClickCommand::ExecutePost(Response* const response) {
   Error* error = session_->MouseDoubleClick();
   if (error) {
     response->SetError(error);
     return;
   }
 }
 
 }  // namespace webdriver