Unify logic of stack trace generation for extension errors

extensions/renderer/resources/binding.js

 // Copyright 2014 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.
 
 var Event = require('event_bindings').Event;
 var forEach = require('utils').forEach;
 var GetAvailability = requireNative('v8_context').GetAvailability;
 var getExtensionStackTrace =
     require('uncaught_exception_handler').getExtensionStackTrace;
 var lastError = require('lastError');
@@ skipping 28 matching lines @@
 // than throwing Errors.
 APIFunctions.prototype.registerUnavailable = function(apiName) {
   this.unavailableApiFunctions_[apiName] = apiName;
 };
 
 APIFunctions.prototype.setHook_ =
     function(apiName, propertyName, customizedFunction) {
   if ($Object.hasOwnProperty(this.unavailableApiFunctions_, apiName))
     return;
   if (!$Object.hasOwnProperty(this.apiFunctions_, apiName))
-    throw new Error('Tried to set hook for unknown API "' + apiName + '"');
+    throw new $Error.self(
+        'Tried to set hook for unknown API "' + apiName + '"');
   this.apiFunctions_[apiName][propertyName] = customizedFunction;
 };
 
 APIFunctions.prototype.setHandleRequest =
     function(apiName, customizedFunction) {
   var prefix = this.namespace;
   return this.setHook_(apiName, 'handleRequest',
     function() {
       var ret = $Function.apply(customizedFunction, this, arguments);
       // Logs API calls to the Activity Log if it doesn't go through an
@@ skipping 69 matching lines @@
   for (var i = 0; i < platforms.length; i++) {
     if ($RegExp.test(platforms[i][0], navigator.appVersion)) {
       return platforms[i][1];
     }
   }
   return "unknown";
 }
 
 function isPlatformSupported(schemaNode, platform) {
   return !schemaNode.platforms ||
-      schemaNode.platforms.indexOf(platform) > -1;
+      $Array.indexOf(schemaNode.platforms, platform) > -1;
 }
 
 function isManifestVersionSupported(schemaNode, manifestVersion) {
   return !schemaNode.maximumManifestVersion ||
       manifestVersion <= schemaNode.maximumManifestVersion;
 }
 
 function isSchemaNodeSupported(schemaNode, platform, manifestVersion) {
   return isPlatformSupported(schemaNode, platform) &&
       isManifestVersionSupported(schemaNode, manifestVersion);
@@ skipping 131 matching lines @@
     function isSchemaAccessAllowed(itemSchema) {
       return (contextType == 'BLESSED_EXTENSION') ||
              schema.unprivileged ||
              itemSchema.unprivileged;
     };
 
     // Setup Functions.
     if (schema.functions) {
       $Array.forEach(schema.functions, function(functionDef) {
         if (functionDef.name in mod) {
-          throw new Error('Function ' + functionDef.name +
+          throw new $Error.self('Function ' + functionDef.name +
                           ' already defined in ' + schema.namespace);
         }
 
         if (!isSchemaNodeSupported(functionDef, platform, manifestVersion)) {
           this.apiFunctions_.registerUnavailable(functionDef.name);
           return;
         }
 
         var apiFunction = {};
         apiFunction.definition = functionDef;
         apiFunction.name = schema.namespace + '.' + functionDef.name;
 
         if (!GetAvailability(apiFunction.name).is_available ||
             (checkUnprivileged && !isSchemaAccessAllowed(functionDef))) {
           this.apiFunctions_.registerUnavailable(functionDef.name);
           return;
         }
 
         // TODO(aa): It would be best to run this in a unit test, but in order
         // to do that we would need to better factor this code so that it
         // doesn't depend on so much v8::Extension machinery.
         if (logging.DCHECK_IS_ON() &&
             schemaUtils.isFunctionSignatureAmbiguous(apiFunction.definition)) {
-          throw new Error(
+          throw new $Error.self(
               apiFunction.name + ' has ambiguous optional arguments. ' +
               'To implement custom disambiguation logic, add ' +
               '"allowAmbiguousOptionalArguments" to the function\'s schema.');
         }
 
         this.apiFunctions_.register(functionDef.name, apiFunction);
 
         mod[functionDef.name] = $Function.bind(function() {
           var args = $Array.slice(arguments);
           if (this.updateArgumentsPreValidate)
@@ skipping 26 matching lines @@
             schemaUtils.validate([retval], [this.definition.returns]);
           return retval;
         }, apiFunction);
       }, this);
     }
 
     // Setup Events
     if (schema.events) {
       $Array.forEach(schema.events, function(eventDef) {
         if (eventDef.name in mod) {
-          throw new Error('Event ' + eventDef.name +
+          throw new $Error.self('Event ' + eventDef.name +
                           ' already defined in ' + schema.namespace);

[not at google - send to devlin, 2014/08/19 16:45:54]

Fix indentation.

         }
         if (!isSchemaNodeSupported(eventDef, platform, manifestVersion))
           return;
 
         var eventName = schema.namespace + "." + eventDef.name;
         if (!GetAvailability(eventName).is_available ||
             (checkUnprivileged && !isSchemaAccessAllowed(eventDef))) {
           return;
         }
 
@@ skipping 49 matching lines @@
             // not as an array), so we have to fake calling |new| on the
             // constructor.
             value = { __proto__: constructor.prototype };
             $Function.apply(constructor, value, args);
             // Recursively add properties.
             addProperties(value, propertyDef);
           } else if (type === 'object') {
             // Recursively add properties.
             addProperties(value, propertyDef);
           } else if (type !== 'string') {
-            throw new Error('NOT IMPLEMENTED (extension_api.json error): ' +
+            throw new $Error.self(
+                'NOT IMPLEMENTED (extension_api.json error): ' +
                 'Cannot parse values for type "' + type + '"');
           }
           m[propertyName] = value;
         }
       });
     };
 
     addProperties(mod, schema);
 
     // This generate() call is considered successful if any functions,
@@ skipping 28 matching lines @@
                     availability.message);
       return;
     }
 
     this.runHooks_(mod);
     return mod;
   }
 };
 
 exports.Binding = Binding;