Run the JSON Schema Compiler's bundle compilation on JSON files. Previously it

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>
@@ skipping 86 matching lines @@
   ExtensionDevToolsClientHost(WebContents* web_contents,
                               const std::string& extension_id,
                               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,
+  void SendMessageToBackend(DebuggerSendCommandFunction* function,
                             const std::string& method,
                             SendCommand::Params::CommandParams* command_params);
 
   // Marks connection as to-be-terminated by the user.
   void MarkAsDismissed();
 
   // DevToolsClientHost interface
   virtual void InspectedContentsClosing() OVERRIDE;
   virtual void DispatchOnInspectorFrontend(const std::string& message) OVERRIDE;
   virtual void ReplacedWithAnotherClient() OVERRIDE;
 
  private:
   void SendDetachedEvent();
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details);
 
   WebContents* web_contents_;
   std::string extension_id_;
   int tab_id_;
   content::NotificationRegistrar registrar_;
   int last_request_id_;
-  typedef std::map<int, scoped_refptr<SendCommandDebuggerFunction> >
+  typedef std::map<int, scoped_refptr<DebuggerSendCommandFunction> >
       PendingRequests;
   PendingRequests pending_requests_;
   ExtensionDevToolsInfoBarDelegate* infobar_delegate_;
   OnDetach::Reason detach_reason_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionDevToolsClientHost);
 };
 
 namespace {
 
@@ skipping 99 matching lines @@
 void ExtensionDevToolsClientHost::ReplacedWithAnotherClient() {
   detach_reason_ = OnDetach::REASON_REPLACED_WITH_DEVTOOLS;
 }
 
 void ExtensionDevToolsClientHost::Close() {
   DevToolsManager::GetInstance()->ClientHostClosing(this);
   delete this;
 }
 
 void ExtensionDevToolsClientHost::SendMessageToBackend(
-    SendCommandDebuggerFunction* function,
+    DebuggerSendCommandFunction* function,
     const std::string& method,
     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 (command_params) {
     protocol_request.Set("params",
                          command_params->additional_properties.DeepCopy());
@@ skipping 73 matching lines @@
     if (dictionary->GetDictionary("params", &params_value))
       params.additional_properties.Swap(params_value);
 
     scoped_ptr<ListValue> args(OnEvent::Create(debuggee, method_name, params));
     scoped_ptr<extensions::Event> event(new extensions::Event(
         keys::kOnEvent, args.Pass()));
     event->restrict_to_profile = profile;
     extensions::ExtensionSystem::Get(profile)->event_router()->
         DispatchEventToExtension(extension_id_, event.Pass());
   } else {
-    SendCommandDebuggerFunction* function = pending_requests_[id];
+    DebuggerSendCommandFunction* function = pending_requests_[id];
     if (!function)
       return;
 
     function->SendResponseBody(dictionary);
     pending_requests_.erase(id);
   }
 }
 
 // static
 ExtensionDevToolsInfoBarDelegate* ExtensionDevToolsInfoBarDelegate::Create(
@@ skipping 93 matching lines @@
       !client_host_->MatchesContentsAndExtensionId(contents_,
                                                    GetExtension()->id())) {
     error_ = ErrorUtils::FormatErrorMessage(
         keys::kNotAttachedError,
         base::IntToString(tab_id_));
     return false;
   }
   return true;
 }
 
-AttachDebuggerFunction::AttachDebuggerFunction() {}
+DebuggerAttachFunction::DebuggerAttachFunction() {}
 
-AttachDebuggerFunction::~AttachDebuggerFunction() {}
+DebuggerAttachFunction::~DebuggerAttachFunction() {}
 
-bool AttachDebuggerFunction::RunImpl() {
+bool DebuggerAttachFunction::RunImpl() {
   scoped_ptr<Attach::Params> params(Attach::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   tab_id_ = params->target.tab_id;
   if (!InitWebContents())
     return false;
 
   if (!webkit_glue::IsInspectorProtocolVersionSupported(
       params->required_version)) {
     error_ = ErrorUtils::FormatErrorMessage(
@@ skipping 15 matching lines @@
   }
 
   new ExtensionDevToolsClientHost(contents_,
                                   GetExtension()->id(),
                                   GetExtension()->name(),
                                   tab_id_);
   SendResponse(true);
   return true;
 }
 
-DetachDebuggerFunction::DetachDebuggerFunction() {}
+DebuggerDetachFunction::DebuggerDetachFunction() {}
 
-DetachDebuggerFunction::~DetachDebuggerFunction() {}
+DebuggerDetachFunction::~DebuggerDetachFunction() {}
 
-bool DetachDebuggerFunction::RunImpl() {
+bool DebuggerDetachFunction::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() {}
+DebuggerSendCommandFunction::DebuggerSendCommandFunction() {}
 
-SendCommandDebuggerFunction::~SendCommandDebuggerFunction() {}
+DebuggerSendCommandFunction::~DebuggerSendCommandFunction() {}
 
-bool SendCommandDebuggerFunction::RunImpl() {
+bool DebuggerSendCommandFunction::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;
 
   client_host_->SendMessageToBackend(this, params->method,
       params->command_params.get());
   return true;
 }
 
-void SendCommandDebuggerFunction::SendResponseBody(
+void DebuggerSendCommandFunction::SendResponseBody(
     DictionaryValue* response) {
   Value* error_body;
   if (response->Get("error", &error_body)) {
     base::JSONWriter::Write(error_body, &error_);
     SendResponse(false);
     return;
   }
 
   DictionaryValue* result_body;
   SendCommand::Results::Result result;
   if (response->GetDictionary("result", &result_body))
     result.additional_properties.Swap(result_body);
 
   results_ = SendCommand::Results::Create(result);
   SendResponse(true);
 }