1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// 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);
};
/**
* Formats the error message and invokes the error handler.
*
* @param {string} message - Error message prefix.
* @param {Error|*} e - Thrown object.
* @param {string=} priorStackTrace - Error message suffix.
* @see formatErrorMessage
*/
function handle(message, e, priorStackTrace) {
message = formatErrorMessage(message, e, priorStackTrace);
handler(message, e);
}
// Runs a user-supplied callback safely.
function safeCallbackApply(name, callback, args, priorStackTrace) {
try {
$Function.apply(callback, null, args);
} catch (e) {
handle('Error in response to ' + name, e, priorStackTrace);
}
}
/**
* 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=} priorStackTrace - The stack trace to be appended to the
* error message. This stack trace must not include stack frames of |e.stack|,
* because both stack traces are concatenated. Overlapping stack traces will
* confuse extension developers.
* @return {string} The formatted error message.
*/
function formatErrorMessage(message, e, priorStackTrace) {
if (e) {
message += ': ' + safeErrorToString(e, false);
}
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 (!priorStackTrace && !stack) {
stack = getStackTrace();
}
stack = filterExtensionStackTrace(stack);
if (stack) {
message += '\n' + stack;
}
// If an asynchronous stack trace was set, append it.
if (priorStackTrace) {
message += '\n' + priorStackTrace;
}
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 $String.indexOf(line, 'chrome-extension://') >= 0;
});
return $Array.join(stack, '\n');
}
function getStackTrace() {
var e = {};
$Error.captureStackTrace(e, getStackTrace);
return e.stack;
}
function getExtensionStackTrace() {
return filterExtensionStackTrace(getStackTrace());
}
/**
* Convert an object to a string.
*
* @param {Error|*} e - A thrown object (possibly user-supplied).
* @param {boolean=} omitType - Whether to try to serialize |e.message| instead
* of |e.toString()|.
* @return {string} The error message.
*/
function safeErrorToString(e, omitType) {
try {
return $String.self(omitType && e.message || e);
} catch (e) {
// This error is exceptional and could be triggered by
// throw {toString: function() { throw 'Haha' } };
return '(cannot get error message)';
}
}
exports.$set('handle', handle);
// |newHandler| A function which matches |handler|.
exports.$set('setHandler', function(newHandler) {
handler = newHandler;
});
exports.$set('safeCallbackApply', safeCallbackApply);
exports.$set('getStackTrace', getStackTrace);
exports.$set('getExtensionStackTrace', getExtensionStackTrace);
exports.$set('safeErrorToString', safeErrorToString);
|
