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"

[Matt Tytel, 2012/07/20 00:41:15]

After we use the json schema compiler for events, i think we can remove all the
Keys from this constants file.

 #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;
 
 namespace keys = debugger_api_constants;
+namespace Attach = extensions::api::debugger::Attach;
+namespace Detach = extensions::api::debugger::Detach;
+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* 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 127 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* 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)

[not at google - send to devlin, 2012/07/19 23:53:47]

params can't be NULL, it's validated to not be, so this check is unnecessary.

I'd make "params" a const& in the constructor.

[mitchellwrosen, 2012/07/20 19:05:17]

Params is optional, so this pointer can be NULL

[Matt Tytel, 2012/07/20 19:09:57]

Maybe rename params to command_params here and other places to avoid the
confusion that I think is happening here.

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

Yep, I misread that. Thanks.

-    protocol_request.Set("params", params->DeepCopy());
+    protocol_request.Set("params", 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()) {
@@ skipping 40 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;

[Matt Tytel, 2012/07/20 00:41:15]

You can use the the json schema compiler here too since we can compile events
now.

     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());
 
     std::string json_args;
     base::JSONWriter::Write(&args, &json_args);
 
     profile->GetExtensionEventRouter()->DispatchEventToExtension(
@@ skipping 36 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(

[not at google - send to devlin, 2012/07/20 00:45:44]

ah, matt is right. you can use the compiler here too, with Result.

I think basically search through for "Value" in this file and chances are it
should use the compiler.

     DictionaryValue* dictionary) {
   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());
   SendResponse(true);
 }