DevTools: brush up remote debugging browser target: use callbacks, make handlers implementation a m…

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/json/json_reader.h"
 #include "base/json/json_writer.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 "net/server/http_server.h"
 
-namespace content {
-
 namespace {
 
-class NotifierImpl : public DevToolsBrowserTarget::Notifier {
- public:
-  NotifierImpl(
-      base::MessageLoopProxy* message_loop_proxy,
-      net::HttpServer* http_server,
-      int connection_id)
-     : message_loop_proxy_(message_loop_proxy),
-       server_(http_server),
-       connection_id_(connection_id) {
-  }
-
-  virtual ~NotifierImpl() {}
-
-  // DevToolsBrowserTarget::Notifier
-  virtual void Notify(const std::string& data) OVERRIDE {
-    message_loop_proxy_->PostTask(
-        FROM_HERE,
-        base::Bind(&net::HttpServer::SendOverWebSocket,
-                   server_,
-                   connection_id_,
-                   data));
-  }
-
- private:
-  base::MessageLoopProxy* const message_loop_proxy_;
-  net::HttpServer* const server_;
-  const int connection_id_;
-
-  DISALLOW_COPY_AND_ASSIGN(NotifierImpl);
-};
+base::Value* CreateErrorObject(int error_code, const std::string& message) {
+  base::DictionaryValue* error_object = new base::DictionaryValue();
+  error_object->SetInteger("code", error_code);
+  error_object->SetString("message", message);
+  return error_object;
+}
 
 }  // namespace
 
-DevToolsBrowserTarget::Handler::Handler()
-    : notifier_(NULL) {
+namespace content {
+
+DevToolsBrowserTarget::DomainHandler::~DomainHandler() {
 }
 
-DevToolsBrowserTarget::Handler::~Handler() {
+void DevToolsBrowserTarget::DomainHandler::RegisterCommandHandler(
+    const std::string& command,
+    CommandHandler handler) {
+  command_handlers_[command] = handler;
 }
 
-void DevToolsBrowserTarget::Handler::set_notifier(
-    DevToolsBrowserTarget::Notifier* notifier) {
-  notifier_ = notifier;
+DevToolsBrowserTarget::DomainHandler::DomainHandler(const std::string& domain)
+    : domain_(domain) {
 }
 
-DevToolsBrowserTarget::Notifier* DevToolsBrowserTarget::Handler::notifier()
-    const {
-  return notifier_;
+base::DictionaryValue* DevToolsBrowserTarget::DomainHandler::HandleCommand(
+    const std::string& command,
+    const base::DictionaryValue* params,
+    base::Value** error_out) {
+  CommandHandlers::iterator it = command_handlers_.find(command);
+  if (it == command_handlers_.end()) {
+    *error_out = CreateErrorObject(-1, "Invalid method");
+    return NULL;
+  }
+  return (it->second).Run(params, error_out);
+}
+
+void DevToolsBrowserTarget::DomainHandler::SendNotification(
+    const std::string& method,
+    base::DictionaryValue* params,
+    base::Value* error) {
+  notifier_.Run(method, params, error);
 }
 
 DevToolsBrowserTarget::DevToolsBrowserTarget(
     base::MessageLoopProxy* message_loop_proxy,
     net::HttpServer* http_server,
     int connection_id)
-    : notifier_(
-          new NotifierImpl(message_loop_proxy, http_server, connection_id)),
-      connection_id_(connection_id) {
+    : message_loop_proxy_(message_loop_proxy),
+      http_server_(http_server),
+      connection_id_(connection_id),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 }
 
 DevToolsBrowserTarget::~DevToolsBrowserTarget() {
-  for (HandlersMap::iterator i = handlers_.begin(); i != handlers_.end(); ++i)
+  for (DomainHandlerMap::iterator i = handlers_.begin(); i != handlers_.end();
+       ++i)
     delete i->second;
 }
 
-void DevToolsBrowserTarget::RegisterHandler(Handler* handler) {
-  std::string domain = handler->Domain();
+void DevToolsBrowserTarget::RegisterDomainHandler(DomainHandler* handler) {
+  std::string domain = handler->domain();
   DCHECK(handlers_.find(domain) == handlers_.end());
   handlers_[domain] = handler;
-  handler->set_notifier(notifier_.get());
+  handler->set_notifier(Bind(&DevToolsBrowserTarget::SendNotification,
+                             weak_factory_.GetWeakPtr()));
 }
 
 std::string DevToolsBrowserTarget::HandleMessage(const std::string& data) {
   int error_code;
   std::string error_message;
   scoped_ptr<base::Value> command(
       base::JSONReader::ReadAndReturnError(
           data, 0, &error_code, &error_message));
 
   if (!command || !command->IsType(base::Value::TYPE_DICTIONARY))
@@ skipping 19 matching lines @@
   if (pos == std::string::npos)
     return SerializeErrorResponse(
         request_id, CreateErrorObject(-1, "Method unsupported"));
 
   domain = method.substr(0, pos);
   if (domain.empty() || handlers_.find(domain) == handlers_.end())
     return SerializeErrorResponse(
         request_id, CreateErrorObject(-1, "Domain unsupported"));
 
   base::Value* error_object = NULL;
-  base::Value* domain_result = handlers_[domain]->OnProtocolCommand(
+  base::DictionaryValue* domain_result = handlers_[domain]->HandleCommand(
       method, params, &error_object);
 
   if (error_object)
     return SerializeErrorResponse(request_id, error_object);
 
-  if (!domain_result)
-    return SerializeErrorResponse(
-        request_id, CreateErrorObject(-1, "Invalid call"));
+  return SerializeResponse(request_id, domain_result);
+}
 
-  DictionaryValue* response = new DictionaryValue();
-  response->Set("result", domain_result);
-  return SerializeResponse(request_id, response);
+void DevToolsBrowserTarget::SendNotification(const std::string& method,
+                                             DictionaryValue* params,
+                                             Value* error) {
+  scoped_ptr<base::DictionaryValue> response(new base::DictionaryValue());
+  response->SetString("method", method);
+  if (error)
+    response->Set("error", error);
+  else if (params)
+    response->Set("params", params);
+
+  // Serialize response.
+  std::string json_response;
+  base::JSONWriter::Write(response.get(), &json_response);
+
+  message_loop_proxy_->PostTask(
+      FROM_HERE,
+      base::Bind(&net::HttpServer::SendOverWebSocket,
+                 http_server_,
+                 connection_id_,
+                 json_response));
 }
 
 std::string DevToolsBrowserTarget::SerializeErrorResponse(
     int request_id, base::Value* error_object) {
   scoped_ptr<base::DictionaryValue> error_response(new base::DictionaryValue());
   error_response->SetInteger("id", request_id);
   error_response->Set("error", error_object);
   // Serialize response.
   std::string json_response;
   base::JSONWriter::Write(error_response.get(), &json_response);
   return json_response;
 }
 
-base::Value* DevToolsBrowserTarget::CreateErrorObject(
-    int error_code, const std::string& message) {
-  base::DictionaryValue* error_object = new base::DictionaryValue();
-  error_object->SetInteger("code", error_code);
-  error_object->SetString("message", message);
-  return error_object;
-}
-
 std::string DevToolsBrowserTarget::SerializeResponse(
-    int request_id, base::Value* response) {
-  scoped_ptr<base::DictionaryValue> ret(new base::DictionaryValue());
-  ret->SetInteger("id", request_id);
-  ret->Set("response", response);
+    int request_id, base::DictionaryValue* result) {
+  scoped_ptr<base::DictionaryValue> response(new base::DictionaryValue());
+  response->SetInteger("id", request_id);
+  if (result)
+    response->Set("result", result);
 
   // Serialize response.
   std::string json_response;
-  base::JSONWriter::Write(ret.get(), &json_response);
+  base::JSONWriter::Write(response.get(), &json_response);
   return json_response;
 }
 
 }  // namespace content