Overhaul JSON Schema Compiler to support a number of features required to

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 158 matching lines @@
       if (rvh && WebContents::FromRenderViewHost(rvh) == contents)
         return static_cast<ExtensionDevToolsClientHost*>(*it);
     }
     return NULL;
   }
 
  private:
   std::set<DevToolsClientHost*> client_hosts_;
 };
 
+scoped_ptr<base::DictionaryValue> ValueMapToDictionary(
+    const std::map<std::string, linked_ptr<base::Value> >& values) {
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+  for (std::map<std::string, linked_ptr<base::Value> >::const_iterator it =
+           values.begin();
+       it != values.end(); ++it) {
+    dict->SetWithoutPathExpansion(it->first, it->second->DeepCopy());
+  }
+  return dict.Pass();
+}
+
+std::map<std::string, linked_ptr<base::Value> > DictionaryToValueMap(
+    const base::DictionaryValue& dict) {
+  std::map<std::string, linked_ptr<base::Value> > values;
+  for (DictionaryValue::Iterator it(dict); it.HasNext(); it.Advance())
+    values[it.key()] = make_linked_ptr(it.value().DeepCopy());
+  return values;
+}
+
 }  // namespace
 
 ExtensionDevToolsClientHost::ExtensionDevToolsClientHost(
     WebContents* web_contents,
     const std::string& extension_id,
     const std::string& extension_name,
     int tab_id)
     : web_contents_(web_contents),
       extension_id_(extension_id),
       tab_id_(tab_id),
@@ skipping 63 matching lines @@
 void ExtensionDevToolsClientHost::SendMessageToBackend(
     SendCommandDebuggerFunction* 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());
+    protocol_request.Set(
+        "params",
+        ValueMapToDictionary(command_params->additional_properties).release());
   }
 
   std::string json_args;
   base::JSONWriter::Write(&protocol_request, &json_args);
   DevToolsManager::GetInstance()->DispatchOnInspectorBackend(this, json_args);
 }
 
 void ExtensionDevToolsClientHost::MarkAsDismissed() {
   detach_reason_ = OnDetach::REASON_CANCELED_BY_USER;
 }
@@ skipping 54 matching lines @@
     std::string method_name;
     if (!dictionary->GetString("method", &method_name))
       return;
 
     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);
+      params.additional_properties = DictionaryToValueMap(*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];
     if (!function)
@@ skipping 187 matching lines @@
   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);
+    result.additional_properties = DictionaryToValueMap(*result_body);
 
   results_ = SendCommand::Results::Create(result);
   SendResponse(true);
 }