Unify logic of stack trace generation for extension errors

extensions/renderer/resources/uncaught_exception_handler.js

Index: extensions/renderer/resources/uncaught_exception_handler.js
diff --git a/extensions/renderer/resources/uncaught_exception_handler.js b/extensions/renderer/resources/uncaught_exception_handler.js
index a3709b58f3c0f6c0e9de5d31e88e2381c5e167c5..7e0725f03499464096c8a228a9f079f41308d743 100644
--- a/extensions/renderer/resources/uncaught_exception_handler.js
+++ b/extensions/renderer/resources/uncaught_exception_handler.js
@@ -4,18 +4,99 @@
 
 // Handles uncaught exceptions thrown by extensions. By default this is to
 // log an error message, but tests may override this behaviour.
-
 var handler = function(message, e) {
   console.error(message);
 };
 
-// |message| The message associated with the error.
-// |e|       The object that was thrown.
-exports.handle = function(message, e) {
+/**
+ * Append the error description and stack trace to |message|.
+ *
+ * @param {string} message - The prefix of the error message.
+ * @param {Error|*} e - The thrown error object. This object is potentially
+ *   unsafe, because it could be generated by an extension.
+ * @param {string=} stackTrace - The stack trace to be appended to the error
+ *   message. This stack trace must not include stack frames of |e.stack|.

[not at google - send to devlin, 2014/08/18 23:13:11]

Why can't it include stack frames of |e.stack|?

[robwu, 2014/08/18 23:27:18]

The stack traces are concatenated. If the stack traces overlap, then it looks
confusing to the developer.

Imagine

var message = 'Message';
var e = new Error('Some error');
var stackTrace = new Error().stack;

Then the result of formatErrorMessage would be:

Message: Some error
<identical stack trace>
<identical stack trace>

[not at google - send to devlin, 2014/08/18 23:39:16]

Ah I understand. Perhaps "priorStackTrace" or similar, then?

[robwu, 2014/08/19 14:21:54]

Done.

+ * @return {string} The formatted error message.
+ */
+function formatErrorMessage(message, e, stackTrace) {
+  // Append ": [error message]"
+  if (e) {
+    try {
+      // Append the toString() representation of |e| to the message. For
+      // instances of Error, it looks like "Error: <message>".
+      message += ': ' + e;
+    } catch (e) {
+      // This could be triggered by
+      // throw {toString: function() { throw 'Haha' } };
+      message += ': (cannot get error message)';
+    }
+  }
+
+  var stack;
+  try {
+    // If the stack was set, use it.
+    // |e.stack| could be void in the following common example:
+    // throw "Error message";
+    stack = $String.self(e && e.stack);
+  } catch (e) {}
+
+  // If a stack is not provided, capture a stack trace.
+  if (!stackTrace && !stack)
+    stack = getStackTrace();
+
+  stack = filterExtensionStackTrace(stack);
+  if (stack)
+    message += '\n' + stack;
+
+  // If an asynchronouse stack trace was set, append it.
+  if (stackTrace)
+    message += '\n' + stackTrace;
+
+  return message;
+}
+
+function filterExtensionStackTrace(stack) {
+  if (!stack)
+    return '';
+  // Remove stack frames in the stack trace that weren't associated with the
+  // extension, to not confuse extension developers with internal details.
+  stack = $String.split(stack, '\n');
+  stack = $Array.filter(stack, function(line) {
+    return line.indexOf('chrome-extension://') >= 0;
+  });
+  return $Array.join(stack, '\n');
+}
+
+// Get a local reference to the captureStackTrace method to prevent extension
+// code from interfering with our method.
+var captureStackTrace = Error.captureStackTrace;
+function getStackTrace() {
+  var e = {};
+  captureStackTrace(e, getStackTrace);
+  return e.stack;
+}
+
+function getExtensionStackTrace() {
+  return filterExtensionStackTrace(getStackTrace());
+}
+
+/**
+ * Formats the error message and invokes the error handler.
+ *
+ * @param {string} message - Error message prefix.
+ * @param {Error|*} e - Thrown object.
+ * @param {string=} stackTrace - Error message suffix.
+ * @see formatErrorMessage
+ */
+exports.handle = function(message, e, stackTrace) {
+  message = formatErrorMessage(message, e, stackTrace);
   handler(message, e);
 };
 
-// |newHandler| A function which matches |exports.handle|.
+// |newHandler| A function which matches |handler|.
 exports.setHandler = function(newHandler) {
   handler = newHandler;
 };
+
+exports.getStackTrace = getStackTrace;
+exports.getExtensionStackTrace = getExtensionStackTrace;