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

chrome/browser/debugger/extension_ports_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.
 
 // Implementation of the ExtensionPortsRemoteService.
 
 // Inspired significantly from debugger_remote_service
 // and ../automation/extension_port_container.
 
 #include "chrome/browser/debugger/extension_ports_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/message_loop.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/profile.h"
 #include "chrome/browser/profile_manager.h"
@@ skipping 116 matching lines @@
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_PORT_DELETED_DEBUG,
       Source<IPC::Message::Sender>(this),
       NotificationService::NoDetails());
 }
 
 void ExtensionPortsRemoteService::HandleMessage(
     const DevToolsRemoteMessage& message) {
   DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_UI);
   const std::string destinationString = 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 52 matching lines @@
       it != openPortIds_.end();
       ++it)
     service_->CloseChannel(*it);
   openPortIds_.clear();
 }
 
 void ExtensionPortsRemoteService::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());
 }
 
 bool ExtensionPortsRemoteService::Send(IPC::Message *message) {
   DCHECK_EQ(MessageLoop::current()->type(), MessageLoop::TYPE_UI);
 
   IPC_BEGIN_MESSAGE_MAP(ExtensionPortsRemoteService, *message)
@@ skipping 30 matching lines @@
 
 void ExtensionPortsRemoteService::OnExtensionMessage(
     const std::string& message, int port_id) {
   LOG(INFO) << "Message event: from port " << port_id
             << ", < " << message << ">";
   // Transpose the information into a JSON message for the external client.
   DictionaryValue content;
   content.SetString(kCommandWide, kOnMessage);
   content.SetInteger(kResultWide, RESULT_OK);
   // Turn the stringified message body back into JSON.
-  Value* data = JSONReader::Read(message, false);
+  Value* data = base::JSONReader::Read(message, false);
   if (!data) {
     NOTREACHED();
     return;
   }
   content.Set(kDataWide, data);
   SendResponse(content, kToolName, IntToString(port_id));
 }
 
 void ExtensionPortsRemoteService::OnExtensionPortDisconnected(int port_id) {
   LOG(INFO) << "Disconnect event for port " << port_id;
@@ skipping 82 matching lines @@
 
 void ExtensionPortsRemoteService::PostMessageCommand(
     int port_id, DictionaryValue* content, DictionaryValue* response) {
   Value* data;
   if (!content->Get(kDataWide, &data)) {
     response->SetInteger(kResultWide, RESULT_PARAMETER_ERROR);
     return;
   }
   std::string message;
   // Stringified the JSON message body.
-  JSONWriter::Write(data, false, &message);
+  base::JSONWriter::Write(data, false, &message);
   LOG(INFO) << "postMessage: port " << port_id
             << ", message: <" << message << ">";
   PortIdSet::iterator portEntry = openPortIds_.find(port_id);
   if (portEntry == openPortIds_.end()) {  // Unknown port ID.
     LOG(INFO) << "unknown port: " << port_id;
     response->SetInteger(kResultWide, RESULT_UNKNOWN_PORT);
     return;
   }
   // Post the message through the ExtensionMessageService.
   DCHECK(service_);
   service_->PostMessageFromRenderer(port_id, message);
   // Confirm to the external client that we sent its message.
   response->SetInteger(kResultWide, RESULT_OK);
 }