Refactor chrome.debugger api to use the JSON schema compiler. Also modified the

chrome/browser/extensions/api/debugger/debugger_api.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.
 
 // Implements the Chrome Extensions Debugger API.
 
 #include "chrome/browser/extensions/api/debugger/debugger_api.h"
 
 #include <map>
 #include <set>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/debugger/debugger_api_constants.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/infobars/infobar.h"
 #include "chrome/browser/infobars/infobar_tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/confirm_infobar_delegate.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_controller_factory.h"
 #include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/extensions/api/debugger.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "content/public/browser/devtools_agent_host_registry.h"
 #include "content/public/browser/devtools_client_host.h"
 #include "content/public/browser/devtools_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_client.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/glue/webkit_glue.h"
 
 using content::DevToolsAgentHost;
 using content::DevToolsAgentHostRegistry;
 using content::DevToolsClientHost;
 using content::DevToolsManager;
 using content::WebContents;
+using extensions::api::debugger::Debuggee;
 
 namespace keys = debugger_api_constants;
+namespace Attach = extensions::api::debugger::Attach;
+namespace Detach = extensions::api::debugger::Detach;
+namespace OnDetach = extensions::api::debugger::OnDetach;
+namespace OnEvent = extensions::api::debugger::OnEvent;
+namespace SendCommand = extensions::api::debugger::SendCommand;
 
 class ExtensionDevToolsInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
   ExtensionDevToolsInfoBarDelegate(
       InfoBarTabHelper* infobar_helper,
       const std::string& client_name);
   virtual ~ExtensionDevToolsInfoBarDelegate();
 
  private:
   // ConfirmInfoBarDelegate:
@@ skipping 15 matching lines @@
                               const std::string& extension_name,
                               int tab_id);
 
   ~ExtensionDevToolsClientHost();
 
   bool MatchesContentsAndExtensionId(WebContents* web_contents,
                                      const std::string& extension_id);
   void Close();
   void SendMessageToBackend(SendCommandDebuggerFunction* function,
                             const std::string& method,
-                            Value* params);
+                            SendCommand::Params::CommandParams* command_params);
 
   // DevToolsClientHost interface
   virtual void InspectedContentsClosing() OVERRIDE;
   virtual void DispatchOnInspectorFrontend(const std::string& message) OVERRIDE;
   virtual void ContentsReplaced(WebContents* web_contents) OVERRIDE;
   virtual void FrameNavigating(const std::string& url) OVERRIDE {}
 
  private:
   void SendDetachedEvent();
 
@@ skipping 10 matching lines @@
   typedef std::map<int, scoped_refptr<SendCommandDebuggerFunction> >
       PendingRequests;
   PendingRequests pending_requests_;
   ExtensionDevToolsInfoBarDelegate* infobar_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionDevToolsClientHost);
 };
 
 namespace {
 
-static Value* CreateDebuggeeId(int tab_id) {
-  DictionaryValue* debuggeeId = new DictionaryValue();
-  debuggeeId->SetInteger(keys::kTabIdKey, tab_id);
-  return debuggeeId;
-}
-
 class AttachedClientHosts {
  public:
   AttachedClientHosts() {}
 
   // Returns the singleton instance of this class
   static AttachedClientHosts* GetInstance() {
     return Singleton<AttachedClientHosts>::get();
   }
 
   void Add(ExtensionDevToolsClientHost* client_host) {
@@ skipping 91 matching lines @@
 }
 
 void ExtensionDevToolsClientHost::Close() {
   DevToolsManager::GetInstance()->ClientHostClosing(this);
   delete this;
 }
 
 void ExtensionDevToolsClientHost::SendMessageToBackend(
     SendCommandDebuggerFunction* function,
     const std::string& method,
-    Value* params) {
+    SendCommand::Params::CommandParams* command_params) {
   DictionaryValue protocol_request;
   int request_id = ++last_request_id_;
   pending_requests_[request_id] = function;
   protocol_request.SetInteger("id", request_id);
   protocol_request.SetString("method", method);
-  if (params)
-    protocol_request.Set("params", params->DeepCopy());
+  if (command_params) {
+    protocol_request.Set("params",
+                         command_params->additional_properties.DeepCopy());
+  }
 
   std::string json_args;
   base::JSONWriter::Write(&protocol_request, &json_args);
   DevToolsManager::GetInstance()->DispatchOnInspectorBackend(this, json_args);
 }
 
 void ExtensionDevToolsClientHost::SendDetachedEvent() {
   Profile* profile =
       Profile::FromBrowserContext(web_contents_->GetBrowserContext());
   if (profile != NULL && profile->GetExtensionEventRouter()) {
-    ListValue args;
-    args.Append(CreateDebuggeeId(tab_id_));
+    Debuggee debuggee;
+    debuggee.tab_id = tab_id_;
 
+    scoped_ptr<base::ListValue> args(OnDetach::Create(debuggee));

[not at google - send to devlin, 2012/07/23 13:56:23]

It occurs to me that we could get json schema compiler to generate a CreateJson
method or something, then all this boilerplate would go away...

I mean, every event method basically calls ToJson on the created result
eventually, anyway.

[mitchellwrosen, 2012/07/23 17:30:20]

Good thought. With events landed perhaps that should be the next major change

     std::string json_args;
-    base::JSONWriter::Write(&args, &json_args);
+    base::JSONWriter::Write(args.get(), &json_args);
 
     profile->GetExtensionEventRouter()->DispatchEventToExtension(
         extension_id_, keys::kOnDetach, json_args, profile, GURL());
   }
 }
 
 void ExtensionDevToolsClientHost::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
@@ skipping 25 matching lines @@
   if (!result->IsType(Value::TYPE_DICTIONARY))
     return;
   DictionaryValue* dictionary = static_cast<DictionaryValue*>(result.get());
 
   int id;
   if (!dictionary->GetInteger("id", &id)) {
     std::string method_name;
     if (!dictionary->GetString("method", &method_name))
       return;
 
-    ListValue args;
-    args.Append(CreateDebuggeeId(tab_id_));
-    args.Append(Value::CreateStringValue(method_name));
-    Value* params_value;
-    if (dictionary->Get("params", &params_value))
-      args.Append(params_value->DeepCopy());
+    Debuggee debuggee;
+    debuggee.tab_id = tab_id_;
 
+    OnEvent::Params params;
+    DictionaryValue* params_value;
+    if (dictionary->GetDictionary("params", &params_value))
+      params.additional_properties.Swap(params_value);
+
+    scoped_ptr<ListValue> args(OnEvent::Create(debuggee, method_name, params));
     std::string json_args;
-    base::JSONWriter::Write(&args, &json_args);
+    base::JSONWriter::Write(args.get(), &json_args);
 
     profile->GetExtensionEventRouter()->DispatchEventToExtension(
         extension_id_, keys::kOnEvent, json_args, profile, GURL());
   } else {
     SendCommandDebuggerFunction* function = pending_requests_[id];
     if (!function)
       return;
 
     function->SendResponseBody(dictionary);
     pending_requests_.erase(id);
@@ skipping 28 matching lines @@
                                     UTF8ToUTF16(client_name_));
 }
 
 DebuggerFunction::DebuggerFunction()
     : contents_(0),
       tab_id_(0),
       client_host_(0) {
 }
 
 bool DebuggerFunction::InitTabContents() {
-  Value* debuggee;
-  EXTENSION_FUNCTION_VALIDATE(args_->Get(0, &debuggee));
-
-  DictionaryValue* dict = static_cast<DictionaryValue*>(debuggee);
-  EXTENSION_FUNCTION_VALIDATE(dict->GetInteger(keys::kTabIdKey, &tab_id_));
-
   // Find the TabContents that contains this tab id.
   contents_ = NULL;
   TabContents* tab_contents = NULL;
   bool result = ExtensionTabUtil::GetTabById(
       tab_id_, profile(), include_incognito(), NULL, NULL, &tab_contents, NULL);
   if (!result || !tab_contents) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         keys::kNoTabError,
         base::IntToString(tab_id_));
     return false;
@@ skipping 27 matching lines @@
     return false;
   }
   return true;
 }
 
 AttachDebuggerFunction::AttachDebuggerFunction() {}
 
 AttachDebuggerFunction::~AttachDebuggerFunction() {}
 
 bool AttachDebuggerFunction::RunImpl() {
+  scoped_ptr<Attach::Params> params(Attach::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
+  tab_id_ = params->target.tab_id;
   if (!InitTabContents())
     return false;
 
-  std::string version;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &version));
-
-  if (!webkit_glue::IsInspectorProtocolVersionSupported(version)) {
+  if (!webkit_glue::IsInspectorProtocolVersionSupported(
+      params->required_version)) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         keys::kProtocolVersionNotSupportedError,
-        version);
+        params->required_version);
     return false;
   }
 
   DevToolsAgentHost* agent = DevToolsAgentHostRegistry::GetDevToolsAgentHost(
       contents_->GetRenderViewHost());
   DevToolsClientHost* client_host = DevToolsManager::GetInstance()->
       GetDevToolsClientHostFor(agent);
 
   if (client_host != NULL) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         keys::kAlreadyAttachedError,
         base::IntToString(tab_id_));
     return false;
   }
 
   new ExtensionDevToolsClientHost(contents_,
                                   GetExtension()->id(),
                                   GetExtension()->name(),
                                   tab_id_);
   SendResponse(true);
   return true;
 }
 
 DetachDebuggerFunction::DetachDebuggerFunction() {}
 
 DetachDebuggerFunction::~DetachDebuggerFunction() {}
 
 bool DetachDebuggerFunction::RunImpl() {
+  scoped_ptr<Detach::Params> params(Detach::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
+
+  tab_id_ = params->target.tab_id;
   if (!InitClientHost())
     return false;
 
   client_host_->Close();
   SendResponse(true);
   return true;
 }
 
 SendCommandDebuggerFunction::SendCommandDebuggerFunction() {}
 
 SendCommandDebuggerFunction::~SendCommandDebuggerFunction() {}
 
 bool SendCommandDebuggerFunction::RunImpl() {
+  scoped_ptr<SendCommand::Params> params(SendCommand::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get());
 
+  tab_id_ = params->target.tab_id;
   if (!InitClientHost())
     return false;
 
-  std::string method;
-  EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &method));
-
-  Value *params;
-  if (!args_->Get(2, &params))
-    params = NULL;
-
-  client_host_->SendMessageToBackend(this, method, params);
+  client_host_->SendMessageToBackend(this, params->method,
+      params->command_params.get());
   return true;
 }
 
 void SendCommandDebuggerFunction::SendResponseBody(
     DictionaryValue* dictionary) {

[not at google - send to devlin, 2012/07/23 13:56:23]

s/dictionary/response/

[mitchellwrosen, 2012/07/23 17:30:20]

Done.

   Value* error_body;
   if (dictionary->Get("error", &error_body)) {
     base::JSONWriter::Write(error_body, &error_);
     SendResponse(false);
     return;
   }
 
-  Value* result_body;
-  if (dictionary->Get("result", &result_body))
-    SetResult(result_body->DeepCopy());
-  else
-    SetResult(new DictionaryValue());
+  DictionaryValue* result_body;
+  SendCommand::Results::Result result;
+  if (dictionary->GetDictionary("result", &result_body))
+    result.additional_properties.Swap(result_body);
+
+  results_ = SendCommand::Results::Create(result);
   SendResponse(true);
 }