Added activity logging for ext APIs with custom bindings

chrome/renderer/resources/extensions/binding.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.
 
 require('json_schema');
 require('event_bindings');
 var chrome = requireNative('chrome').GetChrome();
 var chromeHidden = requireNative('chrome_hidden').GetChromeHidden();
 var forEach = require('utils').forEach;
 var GetAvailability = requireNative('v8_context').GetAvailability;
 var logging = requireNative('logging');
 var process = requireNative('process');
 var contextType = process.GetContextType();
 var extensionId = process.GetExtensionId();
 var manifestVersion = process.GetManifestVersion();
 var schemaRegistry = requireNative('schema_registry');
 var schemaUtils = require('schemaUtils');
-var sendRequest = require('sendRequest').sendRequest;
 var utils = require('utils');
+var sendRequestHandler = require('sendRequest');
+var sendRequest = sendRequestHandler.sendRequest;
+var logActivity = requireNative('activityLogger').LogActivity;
 
 // 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() {
+function APIFunctions(namespace) {
   this.apiFunctions_ = {};
   this.unavailableApiFunctions_ = {};
+  this.namespace = namespace;
 }
 
 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 prefix = this.namespace;
+  return this.setHook_(apiName, 'handleRequest',
+    function() {
+      var ret = customizedFunction.apply(this, arguments);
+      // Logs API calls to the Activity Log if it doesn't go through an
+      // ExtensionFunction.
+      if (!sendRequestHandler.getCalledSendRequest())
+        logActivity(extensionId, prefix + "." + apiName,
+            Array.prototype.slice.call(arguments));
+      return ret;
+    });
 };
 
 APIFunctions.prototype.setUpdateArgumentsPostValidate =
     function(apiName, customizedFunction) {
   return this.setHook_(
     apiName, 'updateArgumentsPostValidate', customizedFunction);
 };
 
 APIFunctions.prototype.setUpdateArgumentsPreValidate =
     function(apiName, customizedFunction) {
@@ skipping 52 matching lines @@
 
 function isSchemaNodeSupported(schemaNode, platform, manifestVersion) {
   return isPlatformSupported(schemaNode, platform) &&
       isManifestVersionSupported(schemaNode, manifestVersion);
 }
 
 var platform = getPlatform();
 
 function Binding(schema) {
   this.schema_ = schema;
-  this.apiFunctions_ = new APIFunctions();
+  this.apiFunctions_ = new APIFunctions(schema.namespace);
   this.customEvent_ = null;
   this.customTypes_ = {};
   this.customHooks_ = [];
 };
 
 Binding.create = function(apiName) {
   return new Binding(schemaRegistry.GetSchema(apiName));
 };
 
 Binding.prototype = {
@@ skipping 101 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 (schema.functions) {
+      var doubleLogging = "abcdefg";
       forEach(schema.functions, function(i, functionDef) {
         if (functionDef.name in mod) {
           throw new Error('Function ' + functionDef.name +
                           ' already defined in ' + schema.namespace);
         }
 
         if (!isSchemaNodeSupported(functionDef, platform, manifestVersion)) {
           this.apiFunctions_.registerUnavailable(functionDef.name);
           return;
         }
@@ skipping 23 matching lines @@
 
         mod[functionDef.name] = (function() {
           var args = Array.prototype.slice.call(arguments);
           if (this.updateArgumentsPreValidate)
             args = this.updateArgumentsPreValidate.apply(this, args);
 
           args = schemaUtils.normalizeArgumentsAndValidate(args, this);
           if (this.updateArgumentsPostValidate)
             args = this.updateArgumentsPostValidate.apply(this, args);
 
+          sendRequestHandler.clearCalledSendRequest();
+
           var retval;
           if (this.handleRequest) {
             retval = this.handleRequest.apply(this, args);
           } else {
             var optArgs = {
               customCallback: this.customCallback
             };
             retval = sendRequest(this.name, args,
                                  this.definition.parameters,
                                  optArgs);
           }
+          sendRequestHandler.clearCalledSendRequest();
 
           // Validate return value if defined - only in debug.
           if (chromeHidden.validateCallbacks &&
               this.definition.returns) {
             schemaUtils.validate([retval], [this.definition.returns]);
           }
           return retval;
         }).bind(apiFunction);
       }, this);
     }
@@ skipping 89 matching lines @@
       });
     };
 
     addProperties(mod, schema);
     this.runHooks_(mod);
     return mod;
   }
 };
 
 exports.Binding = Binding;