Introduce intercepting and handling devtools messages in the renderer.

content/browser/devtools/devtools_browser_target.cc

 // Copyright (c) 2012 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.
 
 #include "content/browser/devtools/devtools_browser_target.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "base/values.h"
-#include "content/browser/devtools/devtools_protocol.h"
 #include "net/server/http_server.h"
 
 namespace content {
 
-DevToolsBrowserTarget::DomainHandler::~DomainHandler() {
-}
-
-void DevToolsBrowserTarget::DomainHandler::RegisterCommandHandler(
-    const std::string& command,
-    CommandHandler handler) {
-  command_handlers_[command] = handler;
-}
-
-DevToolsBrowserTarget::DomainHandler::DomainHandler(const std::string& domain)
-    : domain_(domain) {
-}
-
-scoped_ptr<DevToolsProtocol::Response>
-DevToolsBrowserTarget::DomainHandler::HandleCommand(
-    DevToolsProtocol::Command* command) {
-  CommandHandlers::iterator it = command_handlers_.find(command->method());
-  if (it == command_handlers_.end()) {
-    return command->NoSuchMethodErrorResponse();
-  }
-  return (it->second).Run(command);
-}
-
-void DevToolsBrowserTarget::DomainHandler::SendNotification(
-    const std::string& method,
-    base::DictionaryValue* params) {
-  notifier_.Run(method, params);
-}
-
 DevToolsBrowserTarget::DevToolsBrowserTarget(
     base::MessageLoopProxy* message_loop_proxy,
     net::HttpServer* http_server,
     int connection_id)
     : message_loop_proxy_(message_loop_proxy),
       http_server_(http_server),
       connection_id_(connection_id),
+      handlers_deleter_(&handlers_),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 }
 
 DevToolsBrowserTarget::~DevToolsBrowserTarget() {
-  for (DomainHandlerMap::iterator i = handlers_.begin(); i != handlers_.end();
-       ++i)
-    delete i->second;
 }
 
-void DevToolsBrowserTarget::RegisterDomainHandler(DomainHandler* handler) {
-  std::string domain = handler->domain();
+void DevToolsBrowserTarget::RegisterDomainHandler(
+    const std::string& domain,
+    DevToolsProtocol::Handler* handler) {
   DCHECK(handlers_.find(domain) == handlers_.end());
   handlers_[domain] = handler;
-  handler->set_notifier(Bind(&DevToolsBrowserTarget::SendNotification,
-                             weak_factory_.GetWeakPtr()));
+  handler->SetNotifier(base::Bind(&DevToolsBrowserTarget::OnNotification,
+                                  weak_factory_.GetWeakPtr()));
 }
 
 std::string DevToolsBrowserTarget::HandleMessage(const std::string& data) {
   std::string error_response;
   scoped_ptr<DevToolsProtocol::Command> command(
       DevToolsProtocol::ParseCommand(data, &error_response));
-  if (!command.get())
+  if (!command)
     return error_response;
 
-  if (handlers_.find(command->domain()) == handlers_.end()) {
-    scoped_ptr<DevToolsProtocol::Response> response(
-        command->NoSuchMethodErrorResponse());
-    return response->Serialize();
-  }
+  if (handlers_.find(command->domain()) == handlers_.end())
+    return command->NoSuchMethodErrorResponse()->Serialize();
 
   scoped_ptr<DevToolsProtocol::Response> response(
       handlers_[command->domain()]->HandleCommand(command.get()));
-
+  if (!response)
+    return command->NoSuchMethodErrorResponse()->Serialize();
   return response->Serialize();
 }
 
-void DevToolsBrowserTarget::SendNotification(const std::string& method,
-                                             DictionaryValue* params) {
-  DevToolsProtocol::Notification notification(method, params);
+void DevToolsBrowserTarget::OnNotification(const std::string& message) {
   message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&net::HttpServer::SendOverWebSocket,
                  http_server_,
                  connection_id_,
-                 notification.Serialize()));
+                 message));
 }
 
 }  // namespace content