Use a more OO approach to customizing extension API bindings in

chrome/renderer/resources/extensions/schema_generated_bindings.js

 // Copyright (c) 2011 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 script contains privileged chrome extension related javascript APIs.
 // It is loaded by pages whose URL has the chrome-extension protocol.
 
 var chrome = chrome || {};
 (function() {
   native function GetChromeHidden();
@@ skipping 620 matching lines @@
     // Setup the ChromeSetting class so we can use it to construct
     // ChromeSetting objects from the API definition.
     setupChromeSetting();
 
     // Ditto ContentSetting.
     setupContentSetting();
 
     // Ditto StorageNamespace.
     setupStorageNamespace();
 
-    // |apiFunctions| is a hash of name -> object that stores the
-    // name & definition of the apiFunction. Custom handling of api functions
-    // is implemented by adding a "handleRequest" function to the object.
-    var apiFunctions = {};
+    // Stores the name and definition of each API function, with methods to
+    // modify their behaviour (such as a custom way to handle requests to the
+    // API, a custom callback, etc).
+    function APIFunctions() {
+      this.apiFunctions_ = {};
+    }
+    APIFunctions.prototype.register = function(apiName, apiFunction) {
+      this.apiFunctions_[apiName] = apiFunction;
+    };
+    APIFunctions.prototype.setProperty =
+        function(apiName, propertyName, customizedFunction) {
+      // TODO(kalman): later, when this is asynchronous and we're only
+      // customizing exactly what we need, these should be held onto until
+      // this api function is registered.
+      if (this.apiFunctions_.hasOwnProperty(apiName))
+        this.apiFunctions_[apiName][propertyName] = customizedFunction;
+    };
+    APIFunctions.prototype.setHandleRequest =
+        function(apiName, customizedFunction) {
+      return this.setProperty(apiName, 'handleRequest', customizedFunction);
+    };
+    APIFunctions.prototype.setUpdateArgumentsPostValidate =
+        function(apiName, customizedFunction) {
+      return this.setProperty(
+        apiName, 'updateArgumentsPostValidate', customizedFunction);
+    };
+    APIFunctions.prototype.setUpdateArgumentsPreValidate =
+        function(apiName, customizedFunction) {
+      return this.setProperty(
+        apiName, 'updateArgumentsPreValidate', customizedFunction);
+    };
+    APIFunctions.prototype.setCustomCallback =
+        function(apiName, customizedFunction) {
+      return this.setProperty(apiName, 'customCallback', customizedFunction);
+    };
+
+    var apiFunctions = new APIFunctions();
 
     // Read api definitions and setup api functions in the chrome namespace.
     // TODO(rafaelw): Consider defining a json schema for an api definition
     //   and validating either here, in a unit_test or both.
     // TODO(rafaelw): Handle synchronous functions.
     // TODO(rafaelw): Consider providing some convenient override points
     //   for api functions that wish to insert themselves into the call.
     var apiDefinitions = GetExtensionAPIDefinition();
     var platform = getPlatform();
 
@@ skipping 42 matching lines @@
         apiDef.functions.forEach(function(functionDef) {
           if (functionDef.name in module ||
               addUnprivilegedAccessGetter(module, functionDef.name,
                                           functionDef.unprivileged)) {
             return;
           }
 
           var apiFunction = {};
           apiFunction.definition = functionDef;
           apiFunction.name = apiDef.namespace + "." + functionDef.name;
-          apiFunctions[apiFunction.name] = apiFunction;
+          apiFunctions.register(apiFunction.name, apiFunction);
 
           module[functionDef.name] = (function() {
             var args = arguments;
             if (this.updateArgumentsPreValidate)
               args = this.updateArgumentsPreValidate.apply(this, args);
             chromeHidden.validate(args, this.definition.parameters);
             if (this.updateArgumentsPostValidate)
               args = this.updateArgumentsPostValidate.apply(this, args);
 
             var retval;
@@ skipping 88 matching lines @@
 
     // getTabContentses is retained for backwards compatibility
     // See http://crbug.com/21433
     chrome.extension.getTabContentses = chrome.extension.getExtensionTabs;
     // TOOD(mihaip): remove this alias once the webstore stops calling
     // beginInstallWithManifest2.
     // See http://crbug.com/100242
     chrome.webstorePrivate.beginInstallWithManifest2 =
         chrome.webstorePrivate.beginInstallWithManifest3;
 
-    apiFunctions["tabs.connect"].handleRequest = function(tabId, connectInfo) {
+    apiFunctions.setHandleRequest("tabs.connect", function(tabId, connectInfo) {
       var name = "";
       if (connectInfo) {
         name = connectInfo.name || name;
       }
       var portId = OpenChannelToTab(tabId, chromeHidden.extensionId, name);
       return chromeHidden.Port.createPort(portId, name);
-    };
+    });
 
-    apiFunctions["tabs.sendRequest"].handleRequest =
+    apiFunctions.setHandleRequest("tabs.sendRequest",
         function(tabId, request, responseCallback) {
       var port = chrome.tabs.connect(tabId,
                                      {name: chromeHidden.kRequestChannel});
       port.postMessage(request);
       port.onDisconnect.addListener(function() {
         // For onDisconnects, we only notify the callback if there was an error.
         if (chrome.extension.lastError && responseCallback)
           responseCallback();
       });
       port.onMessage.addListener(function(response) {
         try {
           if (responseCallback)
             responseCallback(response);
         } finally {
           port.disconnect();
           port = null;
         }
       });
-    };
+    });
 
-    apiFunctions["pageCapture.saveAsMHTML"].customCallback =
+    apiFunctions.setCustomCallback("pageCapture.saveAsMHTML",
       function(name, request, response) {
         var params = chromeHidden.JSON.parse(response);
         var path = params.mhtmlFilePath;
         var size = params.mhtmlFileLength;
 
         if (request.callback)
           request.callback(CreateBlob(path, size));
         request.callback = null;
 
         // Notify the browser. Now that the blob is referenced from JavaScript,
         // the browser can drop its reference to it.
         SendResponseAck(request.id);
-      };
+      });
 
-    apiFunctions["fileBrowserPrivate.requestLocalFileSystem"].customCallback =
+    apiFunctions.setCustomCallback("fileBrowserPrivate.requestLocalFileSystem",
       function(name, request, response) {
         var resp = response ? [chromeHidden.JSON.parse(response)] : [];
         var fs = null;
         if (!resp[0].error)
           fs = GetLocalFileSystem(resp[0].name, resp[0].path);
         if (request.callback)
           request.callback(fs);
         request.callback = null;
-      };
+      });
 
-    apiFunctions["chromePrivate.decodeJPEG"].handleRequest =
+    apiFunctions.setHandleRequest("chromePrivate.decodeJPEG",
       function(jpeg_image) {
         return DecodeJPEG(jpeg_image);
-      };
+      });
 
-    apiFunctions["extension.getViews"].handleRequest = function(properties) {
+    apiFunctions.setHandleRequest("extension.getViews", function(properties) {
       var windowId = -1;
       var type = "ALL";
       if (typeof(properties) != "undefined") {
         if (typeof(properties.type) != "undefined") {
           type = properties.type;
         }
         if (typeof(properties.windowId) != "undefined") {
           windowId = properties.windowId;
         }
       }
       return GetExtensionViews(windowId, type) || null;
-    };
+    });
 
-    apiFunctions["extension.getBackgroundPage"].handleRequest = function() {
+    apiFunctions.setHandleRequest("extension.getBackgroundPage", function() {
       return GetExtensionViews(-1, "BACKGROUND")[0] || null;
-    };
+    });
 
-    apiFunctions["extension.getExtensionTabs"].handleRequest =
+    apiFunctions.setHandleRequest("extension.getExtensionTabs",
         function(windowId) {
       if (typeof(windowId) == "undefined")
         windowId = -1;
       return GetExtensionViews(windowId, "TAB");
-    };
+    });
 
-    apiFunctions["devtools.getTabEvents"].handleRequest = function(tabId) {
+    apiFunctions.setHandleRequest("devtools.getTabEvents", function(tabId) {
       var tabIdProxy = {};
       var functions = ["onPageEvent", "onTabClose"];
       functions.forEach(function(name) {
         // Event disambiguation is handled by name munging.  See
         // chrome/browser/extensions/extension_devtools_events.h for the C++
         // equivalent of this logic.
         tabIdProxy[name] = new chrome.Event("devtools." + tabId + "." + name);
       });
       return tabIdProxy;
-    };
+    });
 
     var canvas;
     function setIconCommon(details, name, parameters, actionType, iconSize,
                            nativeFunction) {
       if ("iconIndex" in details) {
         sendRequest(name, [details], parameters);
       } else if ("imageData" in details) {
         // Verify that this at least looks like an ImageData element.
         // Unfortunately, we cannot use instanceof because the ImageData
         // constructor is not public.
@@ skipping 43 matching lines @@
       }
     }
 
     function setExtensionActionIconCommon(details, name, parameters,
                                           actionType) {
       var EXTENSION_ACTION_ICON_SIZE = 19;
       setIconCommon(details, name, parameters, actionType,
                     EXTENSION_ACTION_ICON_SIZE, SetIconCommon);
     }
 
-    apiFunctions["browserAction.setIcon"].handleRequest = function(details) {
+    apiFunctions.setHandleRequest("browserAction.setIcon", function(details) {
       setExtensionActionIconCommon(
           details, this.name, this.definition.parameters, "browser action");
-    };
+    });
 
-    apiFunctions["pageAction.setIcon"].handleRequest = function(details) {
+    apiFunctions.setHandleRequest("pageAction.setIcon", function(details) {
       setExtensionActionIconCommon(
           details, this.name, this.definition.parameters, "page action");
-    };
+    });
 
-    apiFunctions["experimental.sidebar.setIcon"].handleRequest =
+    apiFunctions.setHandleRequest("experimental.sidebar.setIcon",
         function(details) {
       var SIDEBAR_ICON_SIZE = 16;
       setIconCommon(
           details, this.name, this.definition.parameters, "sidebar",
           SIDEBAR_ICON_SIZE, SetIconCommon);
-    };
+    });
 
-    apiFunctions["contextMenus.create"].handleRequest =
+    apiFunctions.setHandleRequest("contextMenus.create",
         function() {
       var args = arguments;
       var id = GetNextContextMenuId();
       args[0].generatedId = id;
       sendRequest(this.name, args, this.definition.parameters,
                   {customCallback: this.customCallback});
       return id;
-    };
+    });
 
-    apiFunctions["omnibox.setDefaultSuggestion"].handleRequest =
+    apiFunctions.setHandleRequest("omnibox.setDefaultSuggestion",
         function(details) {
       var parseResult = parseOmniboxDescription(details.description);
       sendRequest(this.name, [parseResult], this.definition.parameters);
-    };
+    });
 
-    apiFunctions["webRequest.addEventListener"].handleRequest =
+    apiFunctions.setHandleRequest("webRequest.addEventListener",
         function() {
       var args = Array.prototype.slice.call(arguments);
       sendRequest(this.name, args, this.definition.parameters,
                   {forIOThread: true});
-    };
+    });
 
-    apiFunctions["webRequest.eventHandled"].handleRequest =
+    apiFunctions.setHandleRequest("webRequest.eventHandled",
         function() {
       var args = Array.prototype.slice.call(arguments);
       sendRequest(this.name, args, this.definition.parameters,
                   {forIOThread: true});
-    };
+    });
 
-    apiFunctions["webRequest.handlerBehaviorChanged"].
-        handleRequest = function() {
+    apiFunctions.setHandleRequest("webRequest.handlerBehaviorChanged",
+        function() {
       var args = Array.prototype.slice.call(arguments);
       sendRequest(this.name, args, this.definition.parameters,
                   {forIOThread: true});
-    };
+    });
 
-    apiFunctions["contextMenus.create"].customCallback =
+    apiFunctions.setCustomCallback("contextMenus.create",
         function(name, request, response) {
       if (chrome.extension.lastError) {
         return;
       }
 
       var id = request.args[0].generatedId;
 
       // Set up the onclick handler if we were passed one in the request.
       var onclick = request.args.length ? request.args[0].onclick : null;
       if (onclick) {
         chromeHidden.contextMenus.ensureListenerSetup();
         chromeHidden.contextMenus.handlers[id] = onclick;
       }
-    };
+    });
 
-    apiFunctions["contextMenus.remove"].customCallback =
+    apiFunctions.setCustomCallback("contextMenus.remove",
         function(name, request, response) {
       if (chrome.extension.lastError) {
         return;
       }
       var id = request.args[0];
       delete chromeHidden.contextMenus.handlers[id];
-    };
+    });
 
-    apiFunctions["contextMenus.update"].customCallback =
+    apiFunctions.setCustomCallback("contextMenus.update",
         function(name, request, response) {
       if (chrome.extension.lastError) {
         return;
       }
       var id = request.args[0];
       if (request.args[1].onclick) {
         chromeHidden.contextMenus.handlers[id] = request.args[1].onclick;
       }
-    };
+    });
 
-    apiFunctions["contextMenus.removeAll"].customCallback =
+    apiFunctions.setCustomCallback("contextMenus.removeAll",
         function(name, request, response) {
       if (chrome.extension.lastError) {
         return;
       }
       chromeHidden.contextMenus.handlers = {};
-    };
+    });
 
-    apiFunctions["tabs.captureVisibleTab"].updateArgumentsPreValidate =
+    apiFunctions.setUpdateArgumentsPreValidate("tabs.captureVisibleTab",
         function() {
       // Old signature:
       //    captureVisibleTab(int windowId, function callback);
       // New signature:
       //    captureVisibleTab(int windowId, object details, function callback);
       //
       // TODO(skerner): The next step to omitting optional arguments is the
       // replacement of this code with code that matches arguments by type.
       // Once this is working for captureVisibleTab() it can be enabled for
       // the rest of the API. See crbug/29215 .
       if (arguments.length == 2 && typeof(arguments[1]) == "function") {
         // If the old signature is used, add a null details object.
         newArgs = [arguments[0], null, arguments[1]];
       } else {
         newArgs = arguments;
       }
       return newArgs;
-    };
+    });
 
-    apiFunctions["omnibox.sendSuggestions"].updateArgumentsPostValidate =
+    apiFunctions.setUpdateArgumentsPostValidate("omnibox.sendSuggestions",
         function(requestId, userSuggestions) {
       var suggestions = [];
       for (var i = 0; i < userSuggestions.length; i++) {
         var parseResult = parseOmniboxDescription(
             userSuggestions[i].description);
         parseResult.content = userSuggestions[i].content;
         suggestions.push(parseResult);
       }
       return [requestId, suggestions];
-    };
+    });
 
-    apiFunctions["tts.speak"].handleRequest = function() {
+    apiFunctions.setHandleRequest("tts.speak", function() {
       var args = arguments;
       if (args.length > 1 && args[1] && args[1].onEvent) {
         var id = GetNextTtsEventId();
         args[1].srcId = id;
         chromeHidden.tts.handlers[id] = args[1].onEvent;
       }
       sendRequest(this.name, args, this.definition.parameters);
       return id;
-    };
+    });
 
-    apiFunctions["experimental.socket.create"].handleRequest = function() {
+    apiFunctions.setHandleRequest("experimental.socket.create", function() {
       var args = arguments;
       if (args.length > 1 && args[1] && args[1].onEvent) {
         var id = GetNextSocketEventId();
         args[1].srcId = id;
         chromeHidden.socket.handlers[id] = args[1].onEvent;
       }
       sendRequest(this.name, args, this.definition.parameters);
       return id;
-    };
+    });
 
     if (chrome.test) {
       chrome.test.getApiDefinitions = GetExtensionAPIDefinition;
     }
 
     setupHiddenContextMenuEvent(extensionId);
     setupInputEvents();
     setupOmniboxEvents();
     setupPageActionEvents(extensionId);
     setupSocketEvents();
     setupTtsEvents();
   });
 
+  // TODO(kalman): these should all be unnecessary steps if we design the
+  // APIFunctions class correctly.
+
   if (!chrome.experimental)
     chrome.experimental = {};
 
   if (!chrome.experimental.accessibility)
     chrome.experimental.accessibility = {};
 
   if (!chrome.experimental.speechInput)
     chrome.experimental.speechInput = {};
 
   if (!chrome.experimental.socket)
     chrome.experimental.socket = {};
 
   if (!chrome.tts)
     chrome.tts = {};
 
   if (!chrome.ttsEngine)
     chrome.ttsEngine = {};
 
   if (!chrome.experimental.downloads)
     chrome.experimental.downloads = {};
 })();