Move base/values.h into the base namespace.

content/browser/webui/web_ui.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 CONTENT_BROWSER_WEBUI_WEB_UI_H_
 #define CONTENT_BROWSER_WEBUI_WEB_UI_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/callback_old.h"
 #include "base/compiler_specific.h"
 #include "base/string16.h"
 #include "content/common/page_transition_types.h"
 #include "ipc/ipc_channel.h"
 
-class DictionaryValue;
 class WebUIMessageHandler;
 class GURL;
-class ListValue;
 class Profile;
 class RenderViewHost;
 class TabContents;
+
+namespace base {
+class DictionaryValue;
+class ListValue;
 class Value;
+}
 
 // A WebUI sets up the datasources and message handlers for a given HTML-based
 // UI.
 //
 // NOTE: If you're creating a new WebUI for Chrome code, make sure you extend
 // ChromeWebUI.
 class WebUI : public IPC::Channel::Listener {
  public:
   explicit WebUI(TabContents* contents);
   virtual ~WebUI();
 
   // IPC message handling.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
   virtual void OnWebUISend(const GURL& source_url,
                            const std::string& message,
-                           const ListValue& args);
+                           const base::ListValue& args);
 
   // Called by RenderViewHost when the RenderView is first created. This is
   // *not* called for every page load because in some cases
   // RenderViewHostManager will reuse RenderView instances. In those cases,
   // RenderViewReused will be called instead.
   virtual void RenderViewCreated(RenderViewHost* render_view_host) {}
 
   // Called by RenderViewHostManager when a RenderView is reused to display a
   // page.
   virtual void RenderViewReused(RenderViewHost* render_view_host) {}
 
   // Called when this becomes the active WebUI instance for a re-used
   // RenderView; this is the point at which this WebUI instance will receive
   // DOM messages instead of the previous WebUI instance.
   //
   // If a WebUI instance has code that is usually triggered from a JavaScript
   // onload handler, this should be overridden to check to see if the web page's
   // DOM is still intact (e.g., due to a back/forward navigation that remains
   // within the same page), and if so trigger that code manually since onload
   // won't be run in that case.
   virtual void DidBecomeActiveForReusedRenderView() {}
 
   // Used by WebUIMessageHandlers.
-  typedef Callback1<const ListValue*>::Type MessageCallback;
+  typedef Callback1<const base::ListValue*>::Type MessageCallback;
   void RegisterMessageCallback(const std::string& message,
                                MessageCallback* callback);
 
   // Returns true if the favicon should be hidden for the current tab.
   bool hide_favicon() const {
     return hide_favicon_;
   }
 
   // Returns true if the location bar should be focused by default rather than
   // the page contents. Some pages will want to use this to encourage the user
@@ skipping 36 matching lines @@
   }
 
   // Call a Javascript function by sending its name and arguments down to
   // the renderer.  This is asynchronous; there's no way to get the result
   // of the call, and should be thought of more like sending a message to
   // the page.
   // All function names in WebUI must consist of only ASCII characters.
   // There are variants for calls with more arguments.
   void CallJavascriptFunction(const std::string& function_name);
   void CallJavascriptFunction(const std::string& function_name,
-                              const Value& arg);
+                              const base::Value& arg);
   void CallJavascriptFunction(const std::string& function_name,
-                              const Value& arg1,
-                              const Value& arg2);
+                              const base::Value& arg1,
+                              const base::Value& arg2);
   void CallJavascriptFunction(const std::string& function_name,
-                              const Value& arg1,
-                              const Value& arg2,
-                              const Value& arg3);
+                              const base::Value& arg1,
+                              const base::Value& arg2,
+                              const base::Value& arg3);
   void CallJavascriptFunction(const std::string& function_name,
-                              const Value& arg1,
-                              const Value& arg2,
-                              const Value& arg3,
-                              const Value& arg4);
+                              const base::Value& arg1,
+                              const base::Value& arg2,
+                              const base::Value& arg3,
+                              const base::Value& arg4);
   void CallJavascriptFunction(const std::string& function_name,
-                              const std::vector<const Value*>& args);
+                              const std::vector<const base::Value*>& args);
 
   // May be overridden by WebUI's which do not have a tab contents.
   // TODO(estade): removing this Profile dependency is predicated on reworking
   // TabContents's Profile ownership.
   virtual Profile* GetProfile() const;
 
   // May be overridden by WebUI's which do not have a tab contents.
   virtual RenderViewHost* GetRenderViewHost() const;
 
   TabContents* tab_contents() const { return tab_contents_; }
 
   // An opaque identifier used to identify a WebUI. This can only be compared to
   // kNoWebUI or other WebUI types. See GetWebUIType.
   typedef void* TypeID;
 
   // A special WebUI type that signifies that a given page would not use the
   // Web UI system.
   static const TypeID kNoWebUI;
 
   // Returns JavaScript code that, when executed, calls the function specified
   // by |function_name| with the arguments specified in |arg_list|.
-  static string16 GetJavascriptCall(const std::string& function_name,
-                                    const std::vector<const Value*>& arg_list);
+  static string16 GetJavascriptCall(
+      const std::string& function_name,
+      const std::vector<const base::Value*>& arg_list);
 
  protected:
   void AddMessageHandler(WebUIMessageHandler* handler);
 
   // Execute a string of raw Javascript on the page.  Overridable for
   // testing purposes.
   virtual void ExecuteJavascript(const string16& javascript);
 
   // Options that may be overridden by individual Web UI implementations. The
   // bool options default to false. See the public getters for more information.
@@ skipping 31 matching lines @@
   virtual ~WebUIMessageHandler();
 
   // Attaches |this| to |web_ui| in order to handle messages from it.  Declared
   // virtual so that subclasses can do special init work as soon as the web_ui
   // is provided.  Returns |this| for convenience.
   virtual WebUIMessageHandler* Attach(WebUI* web_ui);
 
  protected:
   // Adds "url" and "title" keys on incoming dictionary, setting title
   // as the url as a fallback on empty title.
-  static void SetURLAndTitle(DictionaryValue* dictionary,
+  static void SetURLAndTitle(base::DictionaryValue* dictionary,
                              string16 title,
                              const GURL& gurl);
 
   // This is where subclasses specify which messages they'd like to handle.
   virtual void RegisterMessages() = 0;
 
   // Extract an integer value from a list Value.
-  bool ExtractIntegerValue(const ListValue* value, int* out_int);
+  bool ExtractIntegerValue(const base::ListValue* value, int* out_int);
 
   // Extract a string value from a list Value.
-  string16 ExtractStringValue(const ListValue* value);
+  string16 ExtractStringValue(const base::ListValue* value);
 
   WebUI* web_ui_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebUIMessageHandler);
 };
 
 #endif  // CONTENT_BROWSER_WEBUI_WEB_UI_H_