[DevTools] Scope common protocol infrastructure under Protocol namespace in a separate module.

third_party/WebKit/Source/devtools/front_end/protocol/HostedMode.js

 // Copyright (c) 2015 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.
 
-// This should be executed immediately after InspectorBackend and InspectorBackendCommands
+// This should be executed immediately after Protocol and InspectorBackendCommands
 
-WebInspector.InspectorBackendHostedMode = {};
+var HostedMode = {};

[caseq, 2016/10/26 23:43:20]

nit: naming a namespace "...Mode" is somewhat weird -- perhaps
HostedModeSupport?

 
-WebInspector.InspectorBackendHostedMode.loadFromJSONIfNeeded = function()
+HostedMode.loadFromJSONIfNeeded = function()
 {
-    if (InspectorBackend.isInitialized())
+    if (Protocol.isInitialized())
         return;
 
     for (var url of Object.keys(Runtime.cachedResources)) {
         if (url.indexOf("protocol.json") !== -1) {
             var protocol = Runtime.cachedResources[url];
-            var code = WebInspector.InspectorBackendHostedMode.generateCommands(JSON.parse(protocol));
+            var code = HostedMode.generateCommands(JSON.parse(protocol));
             eval(code);
         }
     }
 };
 
 /**
+ * @param {string} s
+ * @return {string}
+ */
+HostedMode.toTitleCase = function(s)

[caseq, 2016/10/26 23:43:20]

..._toTitleCase(), i.e. private?

+{
+    return s.substring(0, 1).toUpperCase() + s.substring(1);
+};
+
+/**
  * @param {*} schema
  * @return {string}
  */
-WebInspector.InspectorBackendHostedMode.generateCommands = function(schema)
+HostedMode.generateCommands = function(schema)
 {
     var jsTypes = { integer: "number", array: "object" };
     var rawTypes = {};
     var result = [];
 
     var domains = schema["domains"] || [];
     for (var i = 0; i < domains.length; ++i) {
         var domain = domains[i];
         for (var j = 0; domain.types && j < domain.types.length; ++j) {
             var type = domain.types[j];
             rawTypes[domain.domain + "." + type.id] = jsTypes[type.type] || type.type;
         }
     }
 
     function toUpperCase(groupIndex, group0, group1)
     {
         return [group0, group1][groupIndex].toUpperCase();
     }
     function generateEnum(enumName, items)
     {
         var members = [];
         for (var m = 0; m < items.length; ++m) {
             var value = items[m];
             var name = value;
             var prefix = "";
             if (name[0] === "-") {
                 prefix = "Negative";
                 name = name.substring(1);
             }
-            name = name.replace(/-(\w)/g, toUpperCase.bind(null, 1)).toTitleCase();
+            name = HostedMode.toTitleCase(name.replace(/-(\w)/g, toUpperCase.bind(null, 1)));
             name = name.replace(/HTML|XML|WML|API/ig, toUpperCase.bind(null, 0));
             members.push(prefix + name + ": \"" + value + "\"");
         }
-        return "InspectorBackend.registerEnum(\"" + enumName + "\", {" + members.join(", ") + "});";
+        return "Protocol.registerEnum(\"" + enumName + "\", {" + members.join(", ") + "});";
     }
 
     for (var i = 0; i < domains.length; ++i) {
         var domain = domains[i];
 
         var types = domain["types"] || [];
         for (var j = 0; j < types.length; ++j) {
             var type = types[j];
             if ((type["type"] === "string") && type["enum"])
                 result.push(generateEnum(domain.domain + "." + type.id, type["enum"]));
             else if (type["type"] === "object") {
                 var properties = type["properties"] || [];
                 for (var k = 0; k < properties.length; ++k) {
                     var property = properties[k];
                     if ((property["type"] === "string") && property["enum"])
-                        result.push(generateEnum(domain.domain + "." + type.id + property["name"].toTitleCase(), property["enum"]));
+                        result.push(generateEnum(domain.domain + "." + type.id + HostedMode.toTitleCase(property["name"]), property["enum"]));
                 }
             }
         }
 
         var commands = domain["commands"] || [];
         for (var j = 0; j < commands.length; ++j) {
             var command = commands[j];
             var parameters = command["parameters"];
             var paramsText = [];
             for (var k = 0; parameters && k < parameters.length; ++k) {
@@ skipping 14 matching lines @@
                 paramsText.push(text);
             }
 
             var returnsText = [];
             var returns = command["returns"] || [];
             for (var k = 0; k < returns.length; ++k) {
                 var parameter = returns[k];
                 returnsText.push("\"" + parameter.name + "\"");
             }
             var hasErrorData = String(Boolean(command.error));
-            result.push("InspectorBackend.registerCommand(\"" + domain.domain + "." + command.name + "\", [" + paramsText.join(", ") + "], [" + returnsText.join(", ") + "], " + hasErrorData + ");");
+            result.push("Protocol.registerCommand(\"" + domain.domain + "." + command.name + "\", [" + paramsText.join(", ") + "], [" + returnsText.join(", ") + "], " + hasErrorData + ");");
         }
 
         for (var j = 0; domain.events && j < domain.events.length; ++j) {
             var event = domain.events[j];
             var paramsText = [];
             for (var k = 0; event.parameters && k < event.parameters.length; ++k) {
                 var parameter = event.parameters[k];
                 paramsText.push("\"" + parameter.name + "\"");
             }
-            result.push("InspectorBackend.registerEvent(\"" + domain.domain + "." + event.name + "\", [" + paramsText.join(", ") + "]);");
+            result.push("Protocol.registerEvent(\"" + domain.domain + "." + event.name + "\", [" + paramsText.join(", ") + "]);");
         }
     }
     return result.join("\n");
 };
 
-WebInspector.InspectorBackendHostedMode.loadFromJSONIfNeeded();
+HostedMode.loadFromJSONIfNeeded();