OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 /** | |
6 * @param {!WebInspector.RemoteObject} functionObject | |
7 * @return {!Promise<!WebInspector.RemoteObject>} | |
8 */ | |
9 WebInspector.targetFunction = function(functionObject) | |
10 { | |
11 return new Promise(promiseConstructor); | |
12 | |
13 /** | |
14 * @param {function(?)} fulfill | |
15 * @param {function(*)} reject | |
16 */ | |
17 function promiseConstructor(fulfill, reject) | |
18 { | |
19 functionObject.getOwnProperties(ownPropertiesCallback); | |
pfeldman
2015/08/24 23:29:44
You should promisify the getOwnProperties instead,
| |
20 function ownPropertiesCallback(properties, internalProperties) | |
21 { | |
22 if (internalProperties) { | |
23 for (var i = 0; i < internalProperties.length; ++i) { | |
24 if (internalProperties[i].name === "[[TargetFunction]]") { | |
25 fulfill(internalProperties[i].value); | |
26 return; | |
27 } | |
28 } | |
29 } | |
30 fulfill(functionObject); | |
31 } | |
32 } | |
33 } | |
34 | |
35 /** | |
36 * @param {!WebInspector.RemoteObject} functionObject | |
37 * @return {!Promise<{functionObject: !WebInspector.RemoteObject, functionDetail s: ?WebInspector.DebuggerModel.FunctionDetails}>} | |
38 */ | |
39 WebInspector.functionDetails = function(functionObject) | |
40 { | |
41 return new Promise(promiseConstructor); | |
42 | |
43 /** | |
44 * @param {function(?)} fulfill | |
45 * @param {function(*)} reject | |
46 */ | |
47 function promiseConstructor(fulfill, reject) | |
48 { | |
49 if (!functionObject) { | |
50 fulfill({functionObject: null, functionDetails: null}); | |
51 return; | |
52 } | |
53 functionObject.functionDetails(functionDetailsCallback); | |
pfeldman
2015/08/24 23:29:44
ditto, pure promisification required.
| |
54 /** | |
55 * @param {?WebInspector.DebuggerModel.FunctionDetails} functionDetails | |
56 */ | |
57 function functionDetailsCallback(functionDetails) | |
58 { | |
59 fulfill({functionObject: functionObject, functionDetails: functionDe tails}); | |
60 } | |
61 } | |
62 } | |
63 | |
64 /** | |
65 * @param {!WebInspector.RemoteObject} frameworkEventListener | |
66 * @return {!Promise<!WebInspector.EventListener>} | |
67 */ | |
68 WebInspector.buildEventListener = function(frameworkEventListener) | |
pfeldman
2015/08/24 23:29:44
This should be a part of the event listeners view
| |
69 { | |
70 var promises = [frameworkEventListener.callFunctionJSONPromise(function(){ r eturn this; }, undefined)]; | |
pfeldman
2015/08/24 23:29:44
Also hard to parse what it does, it uses inline fu
| |
71 promises.push(frameworkEventListener.callFunctionPromise(effectiveFunction, undefined).then(targetFunction).then(WebInspector.functionDetails)); | |
72 return Promise.all(promises).then(frameworkEventListenerCallback); | |
73 | |
74 /** | |
75 * @param {!{object: ?WebInspector.RemoteObject, wasThrown: (boolean|undefin ed)}} result | |
76 * @return {!Promise<!WebInspector.RemoteObject>} | |
77 */ | |
78 function targetFunction(result) | |
79 { | |
80 return WebInspector.targetFunction(/** @type {!WebInspector.RemoteObject } */(result.object)); | |
81 } | |
82 | |
83 /** | |
84 * @suppressReceiverCheck | |
85 * @this {Object} | |
86 * @return {function()} | |
87 */ | |
88 function effectiveFunction() | |
89 { | |
90 if (typeof this.handler === "function") | |
91 return this.handler; | |
92 return typeof this.handler === "object" ? (this.handler.handlerEvent || this.handler.constructor) : null; | |
93 } | |
94 | |
95 /** | |
96 * @param {!Array<*>} data | |
97 * @return {!WebInspector.EventListener} | |
98 */ | |
99 function frameworkEventListenerCallback(data) | |
100 { | |
101 var listenerJSON = data[0]; | |
102 var targetFunction = data[1]; | |
103 return new WebInspector.EventListener(frameworkEventListener.target(), l istenerJSON.type, listenerJSON.useCapture, targetFunction.functionDetails.locati on, targetFunction.functionObject, targetFunction.functionDetails.sourceURL); | |
104 } | |
105 } | |
106 | |
107 /** | |
108 * @param {!{object: ?WebInspector.RemoteObject, wasThrown: (boolean|undefined)} } frameworkListenersResult | |
109 * @return {!Promise<?Array<!WebInspector.EventListener>>} | |
110 */ | |
111 WebInspector.castEventListeners = function(frameworkListenersResult) | |
pfeldman
2015/08/24 23:29:43
move into widget, also impossible to tell what lay
| |
112 { | |
113 if (frameworkListenersResult.wasThrown) | |
114 return /** @type{!Promise<?Array<!WebInspector.EventListener>>} */(Promi se.resolve(null)); | |
115 var frameworkListeners = frameworkListenersResult.object; | |
116 var promises = []; | |
117 for (var i = 0; i < frameworkListeners.arrayLength(); ++i) | |
118 promises.push(frameworkListeners.callFunctionPromise(function(idx){ retu rn this[idx]; }, [WebInspector.RemoteObject.toCallArgument(i)]).then(buildEventL istener)); | |
119 return /** @type{!Promise<?Array<!WebInspector.EventListener>>} */(Promise.a ll(promises)); | |
120 | |
121 /** | |
122 * @param {!{object: ?WebInspector.RemoteObject, wasThrown: (boolean|undefin ed)}} result | |
123 * @return {!Promise<!WebInspector.EventListener>} | |
124 */ | |
125 function buildEventListener(result) | |
126 { | |
127 return WebInspector.buildEventListener(/** @type {!WebInspector.RemoteOb ject} */(result.object)); | |
128 } | |
129 } | |
130 | |
131 | |
132 /** | |
133 * @param {!{object: ?WebInspector.RemoteObject, wasThrown: (boolean|undefined)} } frameworkHandlersResult | |
134 * @return {!Promise<?Array<function()>>} | |
135 */ | |
136 WebInspector.castEventHandlers = function(frameworkHandlersResult) | |
pfeldman
2015/08/24 23:29:44
ditto
| |
137 { | |
138 var frameworkHandlers = frameworkHandlersResult.object; | |
139 return new Promise(promiseConstructor); | |
140 | |
141 /** | |
142 * @param {function(?)} fulfill | |
143 * @param {function(*)} reject | |
144 */ | |
145 function promiseConstructor(fulfill, reject) | |
146 { | |
147 frameworkHandlers.callFunctionPromise(function(){ return new Set(); }, u ndefined).then(setCreated); | |
148 | |
149 /** | |
150 * @param {!{object: ?WebInspector.RemoteObject, wasThrown: (boolean|und efined)}} setResult | |
151 */ | |
152 function setCreated(setResult) | |
153 { | |
154 if (setResult.wasThrown) { | |
155 fulfill(null); | |
156 return; | |
157 } | |
158 var setObject = setResult.object; | |
159 var promises = []; | |
160 for (var i = 0; i < frameworkHandlers.arrayLength(); ++i) | |
161 promises.push(frameworkHandlers.callFunctionPromise(function(idx ){ return this[idx]; }, [WebInspector.RemoteObject.toCallArgument(i)]).then(targ etFunction).then(addToSet)); | |
162 Promise.all(promises).then(returnSet); | |
163 | |
164 /** | |
165 * @param {!{object: ?WebInspector.RemoteObject, wasThrown: (boolean |undefined)}} result | |
166 */ | |
167 function targetFunction(result) | |
168 { | |
169 return WebInspector.targetFunction(/** @type {!WebInspector.Remo teObject}*/(result.object)); | |
170 } | |
171 | |
172 /** | |
173 * @param {!WebInspector.RemoteObject} targetFunctionObject | |
174 */ | |
175 function addToSet(targetFunctionObject) | |
176 { | |
177 return setObject.callFunctionPromise(function(f){ this.add(f); } , [WebInspector.RemoteObject.toCallArgument(targetFunctionObject)]); | |
178 } | |
179 | |
180 function returnSet() | |
181 { | |
182 fulfill(setObject); | |
183 } | |
184 } | |
185 } | |
186 } | |
187 | |
188 | |
189 /** | |
190 * @return {!Array<!{handler:function(), useCapture: boolean, type:string}>} | |
191 * @this {Object} | |
192 */ | |
193 function devtoolsFrameworkEventListeners() | |
pfeldman
2015/08/24 23:29:44
ditto
| |
194 { | |
195 var listeners = []; | |
196 var getters = [jQueryEventListeners]; | |
197 try { | |
198 if (isArrayLike(self.devtoolsFrameworkEventListeners)) | |
199 getters = getters.concat(self.devtoolsFrameworkEventListeners); | |
200 } catch (e) { | |
201 } | |
202 | |
203 for (var i = 0; i < getters.length; ++i) { | |
204 try { | |
205 listeners = listeners.concat(getters[i](this)); | |
206 } catch (e) { | |
207 } | |
208 } | |
209 return listeners; | |
210 | |
211 /** | |
212 * @param {?Object} obj | |
213 * @return {boolean} | |
214 */ | |
215 function isArrayLike(obj) | |
216 { | |
217 if (!obj || typeof obj !== "object") | |
218 return false; | |
219 try { | |
220 if (typeof obj.splice === "function") { | |
221 var len = obj.length; | |
222 return typeof len === "number" && (len >>> 0 === len && (len > 0 || 1 / len > 0)); | |
223 } | |
224 } catch (e) { | |
225 } | |
226 return false; | |
227 } | |
228 | |
229 /** | |
230 * @param {?Object} node | |
231 * @return {!Array<!{handler:function(), useCapture: boolean, type:string}>} | |
232 */ | |
233 function jQueryEventListeners(node) | |
234 { | |
235 if (!node || !(node instanceof Node)) | |
236 return []; | |
237 var hasJQuery = (typeof jQuery !== 'undefined') && jQuery.fn; | |
238 if (!hasJQuery) | |
239 return []; | |
240 var listeners = []; | |
241 var data = jQuery._data || jQuery.data; | |
242 if (typeof data === "function") { | |
243 var events = data(node, "events"); | |
244 for (var type in events) { | |
245 for (var key in events[type]) { | |
246 var frameworkListener = events[type][key]; | |
247 if (typeof frameworkListener === "object" || typeof framewor kListener === "function") { | |
248 var listener = { | |
249 handler: frameworkListener.handler || frameworkListe ner, | |
250 useCapture: true, | |
251 type: type | |
252 }; | |
253 listeners.push(listener); | |
254 } | |
255 } | |
256 } | |
257 } | |
258 var entry = jQuery(node)[0]; | |
259 if (entry) { | |
260 var entryEvents = entry["$events"]; | |
261 for (var type in entryEvents) { | |
262 var events = entryEvents[type]; | |
263 for (var key in events) { | |
264 if (typeof events[key] === "function") { | |
265 var listener = { | |
266 handler: events[key], | |
267 useCapture: true, | |
268 type: type | |
269 }; | |
270 listeners.push(listener); | |
271 } | |
272 } | |
273 } | |
274 } | |
275 return listeners; | |
276 } | |
277 } | |
278 | |
279 /** | |
280 * @return {!Array<function()>} | |
281 * @this {Object} | |
282 */ | |
283 function devtoolsFrameworkInternalHandlers() | |
pfeldman
2015/08/24 23:29:44
ditto
| |
284 { | |
285 var handlers = []; | |
286 var getters = [jQueryInternalHandlers]; | |
287 try { | |
288 if (isArrayLike(self.devtoolsFrameworkInternalHandlers)) | |
289 getters = getters.concat(self.devtoolsFrameworkInternalHandlers); | |
290 } catch (e) { | |
291 } | |
292 | |
293 for (var i = 0; i < getters.length; ++i) { | |
294 try { | |
295 handlers = handlers.concat(getters[i](this)); | |
296 } catch (e) { | |
297 } | |
298 } | |
299 return handlers; | |
300 | |
301 /** | |
302 * @param {?Object} obj | |
303 * @return {boolean} | |
304 */ | |
305 function isArrayLike(obj) | |
306 { | |
307 if (!obj || typeof obj !== "object") | |
308 return false; | |
309 try { | |
310 if (typeof obj.splice === "function") { | |
311 var len = obj.length; | |
312 return typeof len === "number" && (len >>> 0 === len && (len > 0 || 1 / len > 0)); | |
313 } | |
314 } catch (e) { | |
315 } | |
316 return false; | |
317 } | |
318 | |
319 /** | |
320 * @param {?Object} node | |
321 * @return {!Array<function()>} | |
322 */ | |
323 function jQueryInternalHandlers(node) | |
324 { | |
325 if (!(node instanceof Node)) | |
326 return []; | |
327 var hasJQuery = (typeof jQuery !== 'undefined') && jQuery.fn; | |
328 if (!hasJQuery) | |
329 return []; | |
330 var handlers = []; | |
331 var data = jQuery._data || jQuery.data; | |
332 if (typeof data === "function") { | |
333 var nodeData = data(node); | |
334 if (typeof nodeData.handle === "function") | |
335 handlers.push(nodeData.handle); | |
336 } | |
337 var entry = jQuery(node)[0]; | |
338 if (entry && entry["$handle"]) | |
339 handlers.push(entry["$handle"]); | |
340 return handlers; | |
341 } | |
342 } | |
OLD | NEW |