Move base/values.h into the base namespace.

chrome/test/webdriver/session.h

 // 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.
 
 #ifndef CHROME_TEST_WEBDRIVER_SESSION_H_
 #define CHROME_TEST_WEBDRIVER_SESSION_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/threading/thread.h"
 #include "chrome/common/automation_constants.h"
 #include "chrome/test/webdriver/automation.h"
 #include "chrome/test/webdriver/frame_path.h"
 #include "chrome/test/webdriver/web_element_id.h"
 #include "ui/gfx/point.h"
 
 class CommandLine;
-class DictionaryValue;
 class FilePath;
 class GURL;
+
+namespace base {
+class DictionaryValue;
 class ListValue;
 class Value;
-
-namespace base {
 class WaitableEvent;
 }
 
 namespace gfx {
 class Rect;
 class Size;
 }
 
 namespace webdriver {
 
@@ skipping 30 matching lines @@
   // Terminates this session and deletes itself.
   void Terminate();
 
   // Executes the given |script| in the context of the given frame.
   // The |script| should be in the form of a function body
   // (e.g. "return arguments[0]"), where |args| is the list of arguments to
   // pass to the function. The caller is responsible for the script result
   // |value|, which is set only if there is no error.
   Error* ExecuteScript(const FrameId& frame_id,
                        const std::string& script,
-                       const ListValue* const args,
-                       Value** value);
+                       const base::ListValue* const args,
+                       base::Value** value);
 
   // Same as above, but uses the currently targeted window and frame.
   Error* ExecuteScript(const std::string& script,
-                       const ListValue* const args,
-                       Value** value);
+                       const base::ListValue* const args,
+                       base::Value** value);
 
   // Executes given |script| in the context of the given frame.
   // The |script| should be in the form of a function body
   // (e.g. "return arguments[0]"), where |args| is the list of arguments to
   // pass to the function. The caller is responsible for the script result
   // |value|, which is set only if there is no error.
   Error* ExecuteAsyncScript(const FrameId& frame_id,
                             const std::string& script,
-                            const ListValue* const args,
-                            Value** value);
+                            const base::ListValue* const args,
+                            base::Value** value);
 
   // Send the given keys to the given element dictionary. This function takes
   // ownership of |element|.
   Error* SendKeys(const WebElementId& element, const string16& keys);
 
   // Sets the file paths to the file upload control under the given location.
   Error* DragAndDropFilePaths(const gfx::Point& location,
                               const std::vector<FilePath::StringType>& paths);
 
   // Clicks the mouse at the given location using the given button.
   Error* MouseMoveAndClick(const gfx::Point& location,
                            automation::MouseButton button);
   Error* MouseMove(const gfx::Point& location);
   Error* MouseDrag(const gfx::Point& start, const gfx::Point& end);
   Error* MouseClick(automation::MouseButton button);
   Error* MouseButtonDown();
   Error* MouseButtonUp();
   Error* MouseDoubleClick();
 
   Error* NavigateToURL(const std::string& url);
   Error* GoForward();
   Error* GoBack();
   Error* Reload();
   Error* GetURL(std::string* url);
   Error* GetURL(GURL* url);
   Error* GetTitle(std::string* tab_title);
   Error* GetScreenShot(std::string* png);
 
-  Error* GetCookies(const std::string& url, ListValue** cookies);
+  Error* GetCookies(const std::string& url, base::ListValue** cookies);
   bool GetCookiesDeprecated(const GURL& url, std::string* cookies);
   bool GetCookieByNameDeprecated(const GURL& url,
                                  const std::string& cookie_name,
                                  std::string* cookie);
   Error* DeleteCookie(const std::string& url, const std::string& cookie_name);
   bool DeleteCookieDeprecated(const GURL& url, const std::string& cookie_name);
-  Error* SetCookie(const std::string& url, DictionaryValue* cookie_dict);
+  Error* SetCookie(const std::string& url, base::DictionaryValue* cookie_dict);
   bool SetCookieDeprecated(const GURL& url, const std::string& cookie);
 
   // Gets all the currently existing window IDs. Returns true on success.
   Error* GetWindowIds(std::vector<int>* window_ids);
 
   // Switches the window used by default. |name| is either an ID returned by
   // |GetWindowIds| or the name attribute of a DOM window.
   Error* SwitchToWindow(const std::string& name);
 
   // Switches the frame used by default. |name_or_id| is either the name or id
@@ skipping 118 matching lines @@
 
   // Gets the clickable location of the given element. It will be the center
   // location of the element. If the element is not clickable, or if the
   // location cannot be determined, an error will be returned.
   Error* GetClickableLocation(const WebElementId& element,
                               gfx::Point* location);
 
   // Gets the attribute of the given element. If there are no errors, the
   // function sets |value| and the caller takes ownership.
   Error* GetAttribute(const WebElementId& element, const std::string& key,
-                      Value** value);
+                      base::Value** value);
 
   // Waits for all tabs to stop loading. Returns true on success.
   Error* WaitForAllTabsToStopLoading();
 
   const std::string& id() const;
 
   const FrameId& current_target() const;
 
   void set_async_script_timeout(int timeout_ms);
   int async_script_timeout() const;
@@ skipping 17 matching lines @@
   void InitOnSessionThread(const FilePath& browser_exe,
                            const CommandLine& options,
                            Error** error);
   void TerminateOnSessionThread();
 
   // Executes the given |script| in the context of the given frame.
   // Waits for script to finish and parses the response.
   // The caller is responsible for the script result |value|.
   Error* ExecuteScriptAndParseResponse(const FrameId& frame_id,
                                        const std::string& script,
-                                       Value** value);
+                                       base::Value** value);
 
   void SendKeysOnSessionThread(const string16& keys, Error** error);
   Error* SwitchToFrameWithJavaScriptLocatedFrame(
       const std::string& script,
-      ListValue* args);
+      base::ListValue* args);
   Error* FindElementsHelper(const FrameId& frame_id,
                             const WebElementId& root_element,
                             const std::string& locator,
                             const std::string& query,
                             bool find_one,
                             std::vector<WebElementId>* elements);
   Error* GetElementRegionInViewHelper(
       const FrameId& frame_id,
       const WebElementId& element,
       const gfx::Rect& region,
@@ skipping 38 matching lines @@
   bool has_alert_prompt_text_;
 
   DISALLOW_COPY_AND_ASSIGN(Session);
 };
 
 }  // namespace webdriver
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(webdriver::Session);
 
 #endif  // CHROME_TEST_WEBDRIVER_SESSION_H_