Added activity logging for ext APIs with custom bindings

chrome/renderer/resources/extensions/schema_generated_bindings.js

 // 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.
 
 // Generates the chrome.* API bindings from a list of schemas.
 
   // TODO(battre): cleanup the usage of packages everywhere, as described here
   // http://codereview.chromium.org/10392008/diff/38/chrome/renderer/resources/extensions/schema_generated_bindings.js
 
   require('json_schema');
   require('event_bindings');
   var GetExtensionAPIDefinition =
       requireNative('apiDefinitions').GetExtensionAPIDefinition;
   var sendRequest = require('sendRequest').sendRequest;
   var utils = require('utils');
   var chromeHidden = requireNative('chrome_hidden').GetChromeHidden();
   var schemaUtils = require('schemaUtils');
+  var logActivity = requireNative('activityLogger').LogActivity;
 
   // The object to generate the bindings for "internal" APIs in, so that
   // extensions can't directly call them (without access to chromeHidden),
   // but are still needed for internal mechanisms of extensions (e.g. events).
   //
   // This is distinct to the "*Private" APIs which are controlled via
   // having strict permissions and aren't generated *anywhere* unless needed.
   var internalAPIs = {};
   chromeHidden.internalAPIs = internalAPIs;
 
   // 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 = {};
     this._unavailableApiFunctions = {};
+    this.extensionId = "unknown";
   }
   APIFunctions.prototype.register = function(apiName, apiFunction) {
     this._apiFunctions[apiName] = apiFunction;
   };
   // Registers a function as existing but not available, meaning that calls to
   // the set* methods that reference this function should be ignored rather
   // than throwing Errors.
   APIFunctions.prototype.registerUnavailable = function(apiName) {
     this._unavailableApiFunctions[apiName] = apiName;
   };
   APIFunctions.prototype._setHook =
       function(apiName, propertyName, customizedFunction) {
     if (this._unavailableApiFunctions.hasOwnProperty(apiName))
       return;
     if (!this._apiFunctions.hasOwnProperty(apiName))
       throw new Error('Tried to set hook for unknown API "' + apiName + '"');
     this._apiFunctions[apiName][propertyName] = customizedFunction;
   };
   APIFunctions.prototype.setHandleRequest =
       function(apiName, customizedFunction) {
-    return this._setHook(apiName, 'handleRequest', customizedFunction);
+    var ext_id = this.extensionId;
+    return this._setHook(apiName, 'handleRequest',
+      function() {
+        logActivity(ext_id, apiName,

[Matt Perry, 2013/03/14 20:32:31]

Unfortunately, some APIs that use setHandleRequest still use the
ExtensionFunction machinery too. This will double-count those. See for example
https://code.google.com/p/chromium/codesearch#chromium/src/chrome/renderer/re...

Anything that calls sendRequest is using an ExtensionFunction.

I can think of a few ideas. From the hacky:
- Have sendRequest set a global variable, and only log if that var is not set.

to the slightly better but still ugly:
- Add a setHandleRequestLocally (or something) for APIs that don't call
sendRequest, and only log from there. There's no good way to enforce they don't
call sendRequest, though.

Do you have any ideas?

[felt, 2013/03/15 00:04:47]

Good catch.  OK, I did a version of the second one.  I added a boolean argument
to setHandleRequest. If the extra arg is false or missing, it logs; if it's
true, it doesn't log.  This has two properties:

(1) Someone who is copying code to use setHandleRequest will see the boolean. If
we made a new method like setHandleRequestDontLog, people might not see it.
(2) If I missed an invocation to setHandleRequest, or someone in the future
forgets the boolean, we don't start missing log entries; instead, the worst case
is that an event gets logged twice.


On 2013/03/14 20:32:31, Matt Perry wrote:

+            Array.prototype.slice.call(arguments));
+        return customizedFunction.apply(this, arguments);
+      });
   };
   APIFunctions.prototype.setUpdateArgumentsPostValidate =
       function(apiName, customizedFunction) {
     return this._setHook(
       apiName, 'updateArgumentsPostValidate', customizedFunction);
   };
   APIFunctions.prototype.setUpdateArgumentsPreValidate =
       function(apiName, customizedFunction) {
     return this._setHook(
       apiName, 'updateArgumentsPreValidate', customizedFunction);
@@ skipping 185 matching lines @@
       function addUnprivilegedAccessGetter(mod, name) {
         mod.__defineGetter__(name, function() {
           throw new Error(
               '"' + name + '" can only be used in extension processes. See ' +
               'the content scripts documentation for more details.');
         });
       }
 
       // Setup Functions.
       if (apiDef.functions) {
+        apiFunctions.extensionId = extensionId;
         apiDef.functions.forEach(function(functionDef) {
           if (functionDef.name in mod) {
             throw new Error('Function ' + functionDef.name +
                             ' already defined in ' + apiDef.namespace);
           }
 
           var apiFunctionName = apiDef.namespace + "." + functionDef.name;
 
           if (!isSchemaNodeSupported(functionDef, platform, manifestVersion)) {
             apiFunctions.registerUnavailable(apiFunctionName);
@@ skipping 158 matching lines @@
       hook({
         apiFunctions: new NamespacedAPIFunctions(apiDef.namespace,
                                                  apiFunctions),
         apiDefinitions: apiDefinitions,
       }, extensionId, contextType);
     });
 
     if (chrome.test)
       chrome.test.getApiDefinitions = GetExtensionAPIDefinition;
   });