Move base/values.h into the base namespace.

content/browser/debugger/debugger_remote_service.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.
 
 // This file declares the DebuggerRemoteServiceCommand struct and the
 // DebuggerRemoteService class which handles commands directed to the
 // "V8Debugger" tool.
 #ifndef CONTENT_BROWSER_DEBUGGER_DEBUGGER_REMOTE_SERVICE_H_
 #define CONTENT_BROWSER_DEBUGGER_DEBUGGER_REMOTE_SERVICE_H_
 #pragma once
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "content/browser/debugger/devtools_remote.h"
 
 class DevToolsProtocolHandler;
 class DevToolsRemoteMessage;
+class TabContents;
+
+namespace base {
 class DictionaryValue;
 class Value;
-class TabContents;
+}
 
 // Contains constants for DebuggerRemoteService tool protocol commands
 // (V8-related only).
 struct DebuggerRemoteServiceCommand {
   static const std::string kAttach;
   static const std::string kDetach;
   static const std::string kDebuggerCommand;
   static const std::string kEvaluateJavascript;
   static const std::string kFrameNavigate;  // navigation event
   static const std::string kTabClosed;  // tab closing event
@@ skipping 19 matching lines @@
   // Handles a tab closing event.
   void TabClosed(int32 tab_uid);
 
   // Detaches the remote debugger from the tab specified by |destination|.
   // It is public so that we can detach from the tab on the remote debugger
   // connection loss.
   // If |response| is not NULL, the operation result will be written
   // as the "result" field in |response|, otherwise the result
   // will not be propagated back to the caller.
   void DetachFromTab(const std::string& destination,
-                     DictionaryValue* response);
+                     base::DictionaryValue* response);
 
   // DevToolsRemoteListener interface.
 
   // Processes |message| from the remote debugger, where the tool is
   // "V8Debugger". Either sends the reply immediately or waits for an
   // asynchronous response from the V8 debugger.
   virtual void HandleMessage(const DevToolsRemoteMessage& message);
 
   // Gets invoked on the remote debugger [socket] connection loss.
   // Notifies the InspectableTabProxy of the remote debugger detachment.
@@ skipping 10 matching lines @@
     RESULT_UNKNOWN_TAB,
     RESULT_DEBUGGER_ERROR,
     RESULT_UNKNOWN_COMMAND
   } Result;
 
   virtual ~DebuggerRemoteService();
 
   // Attaches a remote debugger to the tab specified by |destination|.
   // Writes the attachment result (one of Result enum values) into |response|.
   void AttachToTab(const std::string& destination,
-                   DictionaryValue* response);
+                   base::DictionaryValue* response);
 
   // Retrieves a WebContents instance for the specified |tab_uid|
   // or NULL if no such tab is found or no WebContents instance
   // corresponds to that tab.
   TabContents* ToTabContents(int32 tab_uid);
 
   // Sends a JSON message with the |response| to the remote debugger.
   // |tool| and |destination| are used as the respective header values.
-  void SendResponse(const Value& response,
+  void SendResponse(const base::Value& response,
                     const std::string& tool,
                     const std::string& destination);
 
   // Redirects a V8 debugger command from |content| to a V8 debugger associated
   // with the |tab_uid| and writes the result into |response| if it becomes
   // known immediately.
   bool DispatchDebuggerCommand(int tab_uid,
-                               DictionaryValue* content,
-                               DictionaryValue* response);
+                               base::DictionaryValue* content,
+                               base::DictionaryValue* response);
 
   // Redirects a Javascript evaluation command from |content| to
   // a V8 debugger associated with the |tab_uid| and writes the result
   // into |response| if it becomes known immediately.
   bool DispatchEvaluateJavascript(int tab_uid,
-                                  DictionaryValue* content,
-                                  DictionaryValue* response);
+                                  base::DictionaryValue* content,
+                                  base::DictionaryValue* response);
 
   // The delegate is used to get an InspectableTabProxy instance.
   DevToolsProtocolHandler* delegate_;
   DISALLOW_COPY_AND_ASSIGN(DebuggerRemoteService);
 };
 
 #endif  // CONTENT_BROWSER_DEBUGGER_DEBUGGER_REMOTE_SERVICE_H_