Move the json-related files into a separate json directory. This hopefully al...

chrome/browser/debugger/debugger_remote_service.cc

 // Copyright (c) 2009 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 contains implementations of the DebuggerRemoteService methods,
 // defines DebuggerRemoteService and DebuggerRemoteServiceCommand constants.
 
 #include "chrome/browser/debugger/debugger_remote_service.h"
 
-#include "base/json_reader.h"
-#include "base/json_writer.h"
+#include "base/json/json_reader.h"
+#include "base/json/json_writer.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/debugger/devtools_protocol_handler.h"
 #include "chrome/browser/debugger/devtools_remote_message.h"
 #include "chrome/browser/debugger/inspectable_tab_proxy.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/devtools_messages.h"
 #include "chrome/common/render_messages.h"
@@ skipping 36 matching lines @@
 DebuggerRemoteService::~DebuggerRemoteService() {}
 
 // This method handles the V8Debugger tool commands which are
 // retrieved from the request "command" field. If an operation result
 // is ready off-hand (synchronously), it is sent back to the remote debugger.
 // Otherwise the corresponding response is received through IPC from the
 // V8 debugger via DevToolsClientHost.
 void DebuggerRemoteService::HandleMessage(
     const DevToolsRemoteMessage& message) {
   const std::string destination = message.destination();
-  scoped_ptr<Value> request(JSONReader::Read(message.content(), true));
+  scoped_ptr<Value> request(base::JSONReader::Read(message.content(), true));
   if (request.get() == NULL) {
     // Bad JSON
     NOTREACHED();
     return;
   }
   DictionaryValue* content;
   if (!request->IsType(Value::TYPE_DICTIONARY)) {
     NOTREACHED();  // Broken protocol :(
     return;
   }
@@ skipping 43 matching lines @@
 void DebuggerRemoteService::OnConnectionLost() {
   delegate_->inspectable_tab_proxy()->OnRemoteDebuggerDetached();
 }
 
 // Sends a JSON response to the remote debugger using |response| as content,
 // |tool| and |destination| as the respective header values.
 void DebuggerRemoteService::SendResponse(const Value& response,
                                          const std::string& tool,
                                          const std::string& destination) {
   std::string response_content;
-  JSONWriter::Write(&response, false, &response_content);
+  base::JSONWriter::Write(&response, false, &response_content);
   scoped_ptr<DevToolsRemoteMessage> response_message(
       DevToolsRemoteMessageBuilder::instance().Create(tool,
                                                       destination,
                                                       response_content));
   delegate_->Send(*response_message.get());
 }
 
 // Gets a TabContents instance corresponding to the |tab_uid| using the
 // InspectableTabProxy controllers map, or NULL if none found.
 TabContents* DebuggerRemoteService::ToTabContents(int32 tab_uid) {
@@ skipping 154 matching lines @@
   DevToolsClientHost* client_host =
       manager->GetDevToolsClientHostFor(tab_contents->render_view_host());
   if (client_host == NULL) {
     // tab_uid is not being debugged (Attach has not been invoked)
     response->SetInteger(kResultWide, RESULT_ILLEGAL_TAB_STATE);
     return true;
   }
   std::string v8_command;
   DictionaryValue* v8_command_value;
   content->GetDictionary(kDataWide, &v8_command_value);
-  JSONWriter::Write(v8_command_value, false, &v8_command);
+  base::JSONWriter::Write(v8_command_value, false, &v8_command);
   manager->ForwardToDevToolsAgent(
       client_host, DevToolsAgentMsg_DebuggerCommand(v8_command));
   // Do not send the response right now, as the JSON will be received from
   // the V8 debugger asynchronously.
   return false;
 }
 
 // Sends the immediate "evaluate Javascript" command to the V8 debugger.
 // The evaluation result is not sent back to the client as this command
 // is in fact needed to invoke processing of queued debugger commands.
@@ skipping 19 matching lines @@
     return true;
   }
   std::wstring javascript;
   content->GetString(kDataWide, &javascript);
   render_view_host->Send(
       new ViewMsg_ScriptEvalRequest(render_view_host->routing_id(),
                                     L"",
                                     javascript));
   return false;
 }