1/*
2 * Copyright (C) 2011 Google Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
6 * met:
7 *
8 *     * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *     * Redistributions in binary form must reproduce the above
11 * copyright notice, this list of conditions and the following disclaimer
12 * in the documentation and/or other materials provided with the
13 * distribution.
14 *     * Neither the name of Google Inc. nor the names of its
15 * contributors may be used to endorse or promote products derived from
16 * this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31/**
32 * @constructor
33 */
34WebInspector.ExtensionServer = function()
35{
36    this._clientObjects = {};
37    this._handlers = {};
38    this._subscribers = {};
39    this._subscriptionStartHandlers = {};
40    this._subscriptionStopHandlers = {};
41    this._extraHeaders = {};
42    this._requests = {};
43    this._lastRequestId = 0;
44    this._registeredExtensions = {};
45    this._status = new WebInspector.ExtensionStatus();
46
47    var commands = WebInspector.extensionAPI.Commands;
48
49    this._registerHandler(commands.AddAuditCategory, this._onAddAuditCategory.bind(this));
50    this._registerHandler(commands.AddAuditResult, this._onAddAuditResult.bind(this));
51    this._registerHandler(commands.AddConsoleMessage, this._onAddConsoleMessage.bind(this));
52    this._registerHandler(commands.AddRequestHeaders, this._onAddRequestHeaders.bind(this));
53    this._registerHandler(commands.CreatePanel, this._onCreatePanel.bind(this));
54    this._registerHandler(commands.CreateSidebarPane, this._onCreateSidebarPane.bind(this));
55    this._registerHandler(commands.CreateStatusBarButton, this._onCreateStatusBarButton.bind(this));
56    this._registerHandler(commands.EvaluateOnInspectedPage, this._onEvaluateOnInspectedPage.bind(this));
57    this._registerHandler(commands.GetHAR, this._onGetHAR.bind(this));
58    this._registerHandler(commands.GetConsoleMessages, this._onGetConsoleMessages.bind(this));
59    this._registerHandler(commands.GetPageResources, this._onGetPageResources.bind(this));
60    this._registerHandler(commands.GetRequestContent, this._onGetRequestContent.bind(this));
61    this._registerHandler(commands.GetResourceContent, this._onGetResourceContent.bind(this));
62    this._registerHandler(commands.Log, this._onLog.bind(this));
63    this._registerHandler(commands.Reload, this._onReload.bind(this));
64    this._registerHandler(commands.SetOpenResourceHandler, this._onSetOpenResourceHandler.bind(this));
65    this._registerHandler(commands.SetResourceContent, this._onSetResourceContent.bind(this));
66    this._registerHandler(commands.SetSidebarHeight, this._onSetSidebarHeight.bind(this));
67    this._registerHandler(commands.SetSidebarContent, this._onSetSidebarContent.bind(this));
68    this._registerHandler(commands.SetSidebarPage, this._onSetSidebarPage.bind(this));
69    this._registerHandler(commands.ShowPanel, this._onShowPanel.bind(this));
70    this._registerHandler(commands.StopAuditCategoryRun, this._onStopAuditCategoryRun.bind(this));
71    this._registerHandler(commands.Subscribe, this._onSubscribe.bind(this));
72    this._registerHandler(commands.Unsubscribe, this._onUnsubscribe.bind(this));
73    this._registerHandler(commands.UpdateButton, this._onUpdateButton.bind(this));
74    this._registerHandler(commands.UpdateAuditProgress, this._onUpdateAuditProgress.bind(this));
75
76    window.addEventListener("message", this._onWindowMessage.bind(this), false);
77}
78
79WebInspector.ExtensionServer.prototype = {
80    hasExtensions: function()
81    {
82        return !!Object.keys(this._registeredExtensions).length;
83    },
84
85    notifySearchAction: function(panelId, action, searchString)
86    {
87        this._postNotification(WebInspector.extensionAPI.Events.PanelSearch + panelId, action, searchString);
88    },
89
90    notifyViewShown: function(identifier, frameIndex)
91    {
92        this._postNotification(WebInspector.extensionAPI.Events.ViewShown + identifier, frameIndex);
93    },
94
95    notifyViewHidden: function(identifier)
96    {
97        this._postNotification(WebInspector.extensionAPI.Events.ViewHidden + identifier);
98    },
99
100    notifyButtonClicked: function(identifier)
101    {
102        this._postNotification(WebInspector.extensionAPI.Events.ButtonClicked + identifier);
103    },
104
105    _inspectedURLChanged: function(event)
106    {
107        this._requests = {};
108        var url = event.data;
109        this._postNotification(WebInspector.extensionAPI.Events.InspectedURLChanged, url);
110    },
111
112    startAuditRun: function(category, auditRun)
113    {
114        this._clientObjects[auditRun.id] = auditRun;
115        this._postNotification("audit-started-" + category.id, auditRun.id);
116    },
117
118    stopAuditRun: function(auditRun)
119    {
120        delete this._clientObjects[auditRun.id];
121    },
122
123    /**
124     * @param {...*} vararg
125     */
126    _postNotification: function(type, vararg)
127    {
128        var subscribers = this._subscribers[type];
129        if (!subscribers)
130            return;
131        var message = {
132            command: "notify-" + type,
133            arguments: Array.prototype.slice.call(arguments, 1)
134        };
135        for (var i = 0; i < subscribers.length; ++i)
136            subscribers[i].postMessage(message);
137    },
138
139    _onSubscribe: function(message, port)
140    {
141        var subscribers = this._subscribers[message.type];
142        if (subscribers)
143            subscribers.push(port);
144        else {
145            this._subscribers[message.type] = [ port ];
146            if (this._subscriptionStartHandlers[message.type])
147                this._subscriptionStartHandlers[message.type]();
148        }
149    },
150
151    _onUnsubscribe: function(message, port)
152    {
153        var subscribers = this._subscribers[message.type];
154        if (!subscribers)
155            return;
156        subscribers.remove(port);
157        if (!subscribers.length) {
158            delete this._subscribers[message.type];
159            if (this._subscriptionStopHandlers[message.type])
160                this._subscriptionStopHandlers[message.type]();
161        }
162    },
163
164    _onAddRequestHeaders: function(message)
165    {
166        var id = message.extensionId;
167        if (typeof id !== "string")
168            return this._status.E_BADARGTYPE("extensionId", typeof id, "string");
169        var extensionHeaders = this._extraHeaders[id];
170        if (!extensionHeaders) {
171            extensionHeaders = {};
172            this._extraHeaders[id] = extensionHeaders;
173        }
174        for (var name in message.headers)
175            extensionHeaders[name] = message.headers[name];
176        var allHeaders = /** @type NetworkAgent.Headers */ ({});
177        for (var extension in this._extraHeaders) {
178            var headers = this._extraHeaders[extension];
179            for (name in headers) {
180                if (typeof headers[name] === "string")
181                    allHeaders[name] = headers[name];
182            }
183        }
184        NetworkAgent.setExtraHTTPHeaders(allHeaders);
185    },
186
187    _onCreatePanel: function(message, port)
188    {
189        var id = message.id;
190        // The ids are generated on the client API side and must be unique, so the check below
191        // shouldn't be hit unless someone is bypassing the API.
192        if (id in this._clientObjects || id in WebInspector.panels)
193            return this._status.E_EXISTS(id);
194
195        var page = this._expandResourcePath(port._extensionOrigin, message.page);
196        var panelDescriptor = new WebInspector.PanelDescriptor(id, message.title, undefined, undefined, new WebInspector.ExtensionPanel(id, page));
197        panelDescriptor.setIconURL(this._expandResourcePath(port._extensionOrigin, message.icon));
198        this._clientObjects[id] = panelDescriptor.panel();
199        WebInspector.inspectorView.addPanel(panelDescriptor);
200        return this._status.OK();
201    },
202
203    _onShowPanel: function(message)
204    {
205        // Note: WebInspector.showPanel already sanitizes input.
206        WebInspector.showPanel(message.id);
207    },
208
209    _onCreateStatusBarButton: function(message, port)
210    {
211        var panel = this._clientObjects[message.panel];
212        if (!panel || !(panel instanceof WebInspector.ExtensionPanel))
213            return this._status.E_NOTFOUND(message.panel);
214        var button = new WebInspector.ExtensionButton(message.id, this._expandResourcePath(port._extensionOrigin, message.icon), message.tooltip, message.disabled);
215        this._clientObjects[message.id] = button;
216        panel.addStatusBarItem(button.element);
217        return this._status.OK();
218    },
219
220    _onUpdateButton: function(message, port)
221    {
222        var button = this._clientObjects[message.id];
223        if (!button || !(button instanceof WebInspector.ExtensionButton))
224            return this._status.E_NOTFOUND(message.id);
225        button.update(this._expandResourcePath(port._extensionOrigin, message.icon), message.tooltip, message.disabled);
226        return this._status.OK();
227    },
228
229    _onCreateSidebarPane: function(message)
230    {
231        var panel = WebInspector.panel(message.panel);
232        if (!panel)
233            return this._status.E_NOTFOUND(message.panel);
234        if (!panel.addExtensionSidebarPane)
235            return this._status.E_NOTSUPPORTED();
236        var id = message.id;
237        var sidebar = new WebInspector.ExtensionSidebarPane(message.title, message.id);
238        this._clientObjects[id] = sidebar;
239        panel.addExtensionSidebarPane(id, sidebar);
240
241        return this._status.OK();
242    },
243
244    _onSetSidebarHeight: function(message)
245    {
246        var sidebar = this._clientObjects[message.id];
247        if (!sidebar)
248            return this._status.E_NOTFOUND(message.id);
249        sidebar.setHeight(message.height);
250        return this._status.OK();
251    },
252
253    _onSetSidebarContent: function(message, port)
254    {
255        var sidebar = this._clientObjects[message.id];
256        if (!sidebar)
257            return this._status.E_NOTFOUND(message.id);
258        function callback(error)
259        {
260            var result = error ? this._status.E_FAILED(error) : this._status.OK();
261            this._dispatchCallback(message.requestId, port, result);
262        }
263        if (message.evaluateOnPage)
264            return sidebar.setExpression(message.expression, message.rootTitle, message.evaluateOptions, port._extensionOrigin, callback.bind(this));
265        sidebar.setObject(message.expression, message.rootTitle, callback.bind(this));
266    },
267
268    _onSetSidebarPage: function(message, port)
269    {
270        var sidebar = this._clientObjects[message.id];
271        if (!sidebar)
272            return this._status.E_NOTFOUND(message.id);
273        sidebar.setPage(this._expandResourcePath(port._extensionOrigin, message.page));
274    },
275
276    _onSetOpenResourceHandler: function(message, port)
277    {
278        var name = this._registeredExtensions[port._extensionOrigin].name || ("Extension " + port._extensionOrigin);
279        if (message.handlerPresent)
280            WebInspector.openAnchorLocationRegistry.registerHandler(name, this._handleOpenURL.bind(this, port));
281        else
282            WebInspector.openAnchorLocationRegistry.unregisterHandler(name);
283    },
284
285    _handleOpenURL: function(port, details)
286    {
287        var url = /** @type {string} */ (details.url);
288        var contentProvider = WebInspector.workspace.uiSourceCodeForOriginURL(url) || WebInspector.resourceForURL(url);
289        if (!contentProvider)
290            return false;
291
292        var lineNumber = details.lineNumber;
293        if (typeof lineNumber === "number")
294            lineNumber += 1;
295        port.postMessage({
296            command: "open-resource",
297            resource: this._makeResource(contentProvider),
298            lineNumber: lineNumber
299        });
300        return true;
301    },
302
303    _onLog: function(message)
304    {
305        WebInspector.log(message.message);
306    },
307
308    _onReload: function(message)
309    {
310        var options = /** @type ExtensionReloadOptions */ (message.options || {});
311        NetworkAgent.setUserAgentOverride(typeof options.userAgent === "string" ? options.userAgent : "");
312        var injectedScript;
313        if (options.injectedScript)
314            injectedScript = "(function(){" + options.injectedScript + "})()";
315        PageAgent.reload(!!options.ignoreCache, injectedScript);
316        return this._status.OK();
317    },
318
319    _onEvaluateOnInspectedPage: function(message, port)
320    {
321        /**
322         * @param {?Protocol.Error} error
323         * @param {RuntimeAgent.RemoteObject} resultPayload
324         * @param {boolean=} wasThrown
325         */
326        function callback(error, resultPayload, wasThrown)
327        {
328            var result;
329            if (error)
330                result = this._status.E_PROTOCOLERROR(error.toString());
331            else if (wasThrown)
332                result = { isException: true, value: resultPayload.description };
333            else
334                result = { value: resultPayload.value };
335
336            this._dispatchCallback(message.requestId, port, result);
337        }
338        return this.evaluate(message.expression, true, true, message.evaluateOptions, port._extensionOrigin, callback.bind(this));
339    },
340
341    _onGetConsoleMessages: function()
342    {
343        return WebInspector.console.messages.map(this._makeConsoleMessage);
344    },
345
346    _onAddConsoleMessage: function(message)
347    {
348        function convertSeverity(level)
349        {
350            switch (level) {
351                case WebInspector.extensionAPI.console.Severity.Log:
352                    return WebInspector.ConsoleMessage.MessageLevel.Log;
353                case WebInspector.extensionAPI.console.Severity.Warning:
354                    return WebInspector.ConsoleMessage.MessageLevel.Warning;
355                case WebInspector.extensionAPI.console.Severity.Error:
356                    return WebInspector.ConsoleMessage.MessageLevel.Error;
357                case WebInspector.extensionAPI.console.Severity.Debug:
358                    return WebInspector.ConsoleMessage.MessageLevel.Debug;
359            }
360        }
361        var level = convertSeverity(message.severity);
362        if (!level)
363            return this._status.E_BADARG("message.severity", message.severity);
364
365        var consoleMessage = WebInspector.ConsoleMessage.create(
366            WebInspector.ConsoleMessage.MessageSource.JS,
367            level,
368            message.text,
369            WebInspector.ConsoleMessage.MessageType.Log,
370            message.url,
371            message.line);
372        WebInspector.console.addMessage(consoleMessage);
373    },
374
375    _makeConsoleMessage: function(message)
376    {
377        function convertLevel(level)
378        {
379            if (!level)
380                return;
381            switch (level) {
382                case WebInspector.ConsoleMessage.MessageLevel.Log:
383                    return WebInspector.extensionAPI.console.Severity.Log;
384                case WebInspector.ConsoleMessage.MessageLevel.Warning:
385                    return WebInspector.extensionAPI.console.Severity.Warning;
386                case WebInspector.ConsoleMessage.MessageLevel.Error:
387                    return WebInspector.extensionAPI.console.Severity.Error;
388                case WebInspector.ConsoleMessage.MessageLevel.Debug:
389                    return WebInspector.extensionAPI.console.Severity.Debug;
390                default:
391                    return WebInspector.extensionAPI.console.Severity.Log;
392            }
393        }
394        var result = {
395            severity: convertLevel(message.level),
396            text: message.text,
397        };
398        if (message.url)
399            result.url = message.url;
400        if (message.line)
401            result.line = message.line;
402        return result;
403    },
404
405    _onGetHAR: function()
406    {
407        var requests = WebInspector.networkLog.requests;
408        var harLog = (new WebInspector.HARLog(requests)).build();
409        for (var i = 0; i < harLog.entries.length; ++i)
410            harLog.entries[i]._requestId = this._requestId(requests[i]);
411        return harLog;
412    },
413
414    /**
415     * @param {WebInspector.ContentProvider} contentProvider
416     */
417    _makeResource: function(contentProvider)
418    {
419        return {
420            url: contentProvider.contentURL(),
421            type: contentProvider.contentType().name()
422        };
423    },
424
425    _onGetPageResources: function()
426    {
427        var resources = {};
428
429        function pushResourceData(contentProvider)
430        {
431            if (!resources[contentProvider.contentURL()])
432                resources[contentProvider.contentURL()] = this._makeResource(contentProvider);
433        }
434        var uiSourceCodes = WebInspector.workspace.uiSourceCodesForProjectType(WebInspector.projectTypes.Network);
435        uiSourceCodes.forEach(pushResourceData.bind(this));
436        WebInspector.resourceTreeModel.forAllResources(pushResourceData.bind(this));
437        return Object.values(resources);
438    },
439
440    /**
441     * @param {WebInspector.ContentProvider} contentProvider
442     */
443    _getResourceContent: function(contentProvider, message, port)
444    {
445        /**
446         * @param {?string} content
447         * @param {boolean} contentEncoded
448         * @param {string} mimeType
449         */
450        function onContentAvailable(content, contentEncoded, mimeType)
451        {
452            var response = {
453                encoding: contentEncoded ? "base64" : "",
454                content: content
455            };
456            this._dispatchCallback(message.requestId, port, response);
457        }
458        contentProvider.requestContent(onContentAvailable.bind(this));
459    },
460
461    _onGetRequestContent: function(message, port)
462    {
463        var request = this._requestById(message.id);
464        if (!request)
465            return this._status.E_NOTFOUND(message.id);
466        this._getResourceContent(request, message, port);
467    },
468
469    _onGetResourceContent: function(message, port)
470    {
471        var url = /** @type {string} */ (message.url);
472        var contentProvider = WebInspector.workspace.uiSourceCodeForOriginURL(url) || WebInspector.resourceForURL(url);
473        if (!contentProvider)
474            return this._status.E_NOTFOUND(url);
475        this._getResourceContent(contentProvider, message, port);
476    },
477
478    _onSetResourceContent: function(message, port)
479    {
480        /**
481         * @param {?Protocol.Error} error
482         */
483        function callbackWrapper(error)
484        {
485            var response = error ? this._status.E_FAILED(error) : this._status.OK();
486            this._dispatchCallback(message.requestId, port, response);
487        }
488
489        var url = /** @type {string} */ (message.url);
490        var uiSourceCode = WebInspector.workspace.uiSourceCodeForOriginURL(url);
491        if (!uiSourceCode) {
492            var resource = WebInspector.resourceTreeModel.resourceForURL(url);
493            if (!resource)
494                return this._status.E_NOTFOUND(url);
495            return this._status.E_NOTSUPPORTED("Resource is not editable")
496        }
497        uiSourceCode.setWorkingCopy(message.content);
498        if (message.commit)
499            uiSourceCode.commitWorkingCopy(callbackWrapper.bind(this));
500        else
501            callbackWrapper.call(this, null);
502    },
503
504    _requestId: function(request)
505    {
506        if (!request._extensionRequestId) {
507            request._extensionRequestId = ++this._lastRequestId;
508            this._requests[request._extensionRequestId] = request;
509        }
510        return request._extensionRequestId;
511    },
512
513    _requestById: function(id)
514    {
515        return this._requests[id];
516    },
517
518    _onAddAuditCategory: function(message, port)
519    {
520        var category = new WebInspector.ExtensionAuditCategory(port._extensionOrigin, message.id, message.displayName, message.resultCount);
521        if (WebInspector.panel("audits").getCategory(category.id))
522            return this._status.E_EXISTS(category.id);
523        this._clientObjects[message.id] = category;
524        WebInspector.panel("audits").addCategory(category);
525    },
526
527    _onAddAuditResult: function(message)
528    {
529        var auditResult = this._clientObjects[message.resultId];
530        if (!auditResult)
531            return this._status.E_NOTFOUND(message.resultId);
532        try {
533            auditResult.addResult(message.displayName, message.description, message.severity, message.details);
534        } catch (e) {
535            return e;
536        }
537        return this._status.OK();
538    },
539
540    _onUpdateAuditProgress: function(message)
541    {
542        var auditResult = this._clientObjects[message.resultId];
543        if (!auditResult)
544            return this._status.E_NOTFOUND(message.resultId);
545        auditResult.updateProgress(Math.min(Math.max(0, message.progress), 1));
546    },
547
548    _onStopAuditCategoryRun: function(message)
549    {
550        var auditRun = this._clientObjects[message.resultId];
551        if (!auditRun)
552            return this._status.E_NOTFOUND(message.resultId);
553        auditRun.done();
554    },
555
556    _dispatchCallback: function(requestId, port, result)
557    {
558        if (requestId)
559            port.postMessage({ command: "callback", requestId: requestId, result: result });
560    },
561
562    initExtensions: function()
563    {
564        this._registerAutosubscriptionHandler(WebInspector.extensionAPI.Events.ConsoleMessageAdded,
565            WebInspector.console, WebInspector.ConsoleModel.Events.MessageAdded, this._notifyConsoleMessageAdded);
566        this._registerAutosubscriptionHandler(WebInspector.extensionAPI.Events.NetworkRequestFinished,
567            WebInspector.networkManager, WebInspector.NetworkManager.EventTypes.RequestFinished, this._notifyRequestFinished);
568        this._registerAutosubscriptionHandler(WebInspector.extensionAPI.Events.ResourceAdded,
569            WebInspector.workspace,
570            WebInspector.UISourceCodeProvider.Events.UISourceCodeAdded,
571            this._notifyResourceAdded);
572        this._registerAutosubscriptionHandler(WebInspector.extensionAPI.Events.ElementsPanelObjectSelected,
573            WebInspector.notifications,
574            WebInspector.ElementsTreeOutline.Events.SelectedNodeChanged,
575            this._notifyElementsSelectionChanged);
576        this._registerAutosubscriptionHandler(WebInspector.extensionAPI.Events.ResourceContentCommitted,
577            WebInspector.workspace,
578            WebInspector.Workspace.Events.UISourceCodeContentCommitted,
579            this._notifyUISourceCodeContentCommitted);
580
581        function onTimelineSubscriptionStarted()
582        {
583            WebInspector.timelineManager.addEventListener(WebInspector.TimelineManager.EventTypes.TimelineEventRecorded,
584                this._notifyTimelineEventRecorded, this);
585            WebInspector.timelineManager.start();
586        }
587        function onTimelineSubscriptionStopped()
588        {
589            WebInspector.timelineManager.stop();
590            WebInspector.timelineManager.removeEventListener(WebInspector.TimelineManager.EventTypes.TimelineEventRecorded,
591                this._notifyTimelineEventRecorded, this);
592        }
593        this._registerSubscriptionHandler(WebInspector.extensionAPI.Events.TimelineEventRecorded,
594            onTimelineSubscriptionStarted.bind(this), onTimelineSubscriptionStopped.bind(this));
595
596        WebInspector.resourceTreeModel.addEventListener(WebInspector.ResourceTreeModel.EventTypes.InspectedURLChanged,
597            this._inspectedURLChanged, this);
598        this._initDone = true;
599        if (this._pendingExtensions) {
600            this._pendingExtensions.forEach(this._innerAddExtension, this);
601            delete this._pendingExtensions;
602        }
603        InspectorExtensionRegistry.getExtensionsAsync();
604    },
605
606    _notifyConsoleMessageAdded: function(event)
607    {
608        this._postNotification(WebInspector.extensionAPI.Events.ConsoleMessageAdded, this._makeConsoleMessage(event.data));
609    },
610
611    _notifyResourceAdded: function(event)
612    {
613        var uiSourceCode = /** @type {WebInspector.UISourceCode} */ (event.data);
614        this._postNotification(WebInspector.extensionAPI.Events.ResourceAdded, this._makeResource(uiSourceCode));
615    },
616
617    _notifyUISourceCodeContentCommitted: function(event)
618    {
619        var uiSourceCode = /** @type {WebInspector.UISourceCode} */ (event.data.uiSourceCode);
620        var content = /** @type {string} */ (event.data.content);
621        this._postNotification(WebInspector.extensionAPI.Events.ResourceContentCommitted, this._makeResource(uiSourceCode), content);
622    },
623
624    _notifyRequestFinished: function(event)
625    {
626        var request = /** @type {WebInspector.NetworkRequest} */ (event.data);
627        this._postNotification(WebInspector.extensionAPI.Events.NetworkRequestFinished, this._requestId(request), (new WebInspector.HAREntry(request)).build());
628    },
629
630    _notifyElementsSelectionChanged: function()
631    {
632        this._postNotification(WebInspector.extensionAPI.Events.ElementsPanelObjectSelected);
633    },
634
635    _notifyTimelineEventRecorded: function(event)
636    {
637        this._postNotification(WebInspector.extensionAPI.Events.TimelineEventRecorded, event.data);
638    },
639
640    /**
641     * @param {Array.<ExtensionDescriptor>} extensions
642     */
643    _addExtensions: function(extensions)
644    {
645        extensions.forEach(this._addExtension, this);
646    },
647
648    _addExtension: function(extensionInfo)
649    {
650        if (this._initDone) {
651            this._innerAddExtension(extensionInfo);
652            return;
653        }
654        if (this._pendingExtensions)
655            this._pendingExtensions.push(extensionInfo);
656        else
657            this._pendingExtensions = [extensionInfo];
658    },
659
660    _innerAddExtension: function(extensionInfo)
661    {
662        const urlOriginRegExp = new RegExp("([^:]+:\/\/[^/]*)\/"); // Can't use regexp literal here, MinJS chokes on it.
663        var startPage = extensionInfo.startPage;
664        var name = extensionInfo.name;
665
666        try {
667            var originMatch = urlOriginRegExp.exec(startPage);
668            if (!originMatch) {
669                console.error("Skipping extension with invalid URL: " + startPage);
670                return false;
671            }
672            var extensionOrigin = originMatch[1];
673            if (!this._registeredExtensions[extensionOrigin]) {
674                // See ExtensionAPI.js and ExtensionCommon.js for details.
675                InspectorFrontendHost.setInjectedScriptForOrigin(extensionOrigin, buildExtensionAPIInjectedScript(extensionInfo));
676                this._registeredExtensions[extensionOrigin] = { name: name };
677            }
678            var iframe = document.createElement("iframe");
679            iframe.src = startPage;
680            iframe.style.display = "none";
681            document.body.appendChild(iframe);
682        } catch (e) {
683            console.error("Failed to initialize extension " + startPage + ":" + e);
684            return false;
685        }
686        return true;
687    },
688
689    _onWindowMessage: function(event)
690    {
691        if (event.data === "registerExtension")
692            this._registerExtension(event.origin, event.ports[0]);
693    },
694
695    _registerExtension: function(origin, port)
696    {
697        if (!this._registeredExtensions.hasOwnProperty(origin)) {
698            if (origin !== window.location.origin) // Just ignore inspector frames.
699                console.error("Ignoring unauthorized client request from " + origin);
700            return;
701        }
702        port._extensionOrigin = origin;
703        port.addEventListener("message", this._onmessage.bind(this), false);
704        port.start();
705    },
706
707    _onmessage: function(event)
708    {
709        var message = event.data;
710        var result;
711
712        if (message.command in this._handlers)
713            result = this._handlers[message.command](message, event.target);
714        else
715            result = this._status.E_NOTSUPPORTED(message.command);
716
717        if (result && message.requestId)
718            this._dispatchCallback(message.requestId, event.target, result);
719    },
720
721    _registerHandler: function(command, callback)
722    {
723        this._handlers[command] = callback;
724    },
725
726    _registerSubscriptionHandler: function(eventTopic, onSubscribeFirst, onUnsubscribeLast)
727    {
728        this._subscriptionStartHandlers[eventTopic] =  onSubscribeFirst;
729        this._subscriptionStopHandlers[eventTopic] =  onUnsubscribeLast;
730    },
731
732    _registerAutosubscriptionHandler: function(eventTopic, eventTarget, frontendEventType, handler)
733    {
734        this._registerSubscriptionHandler(eventTopic,
735            eventTarget.addEventListener.bind(eventTarget, frontendEventType, handler, this),
736            eventTarget.removeEventListener.bind(eventTarget, frontendEventType, handler, this));
737    },
738
739    _expandResourcePath: function(extensionPath, resourcePath)
740    {
741        if (!resourcePath)
742            return;
743        return extensionPath + this._normalizePath(resourcePath);
744    },
745
746    _normalizePath: function(path)
747    {
748        var source = path.split("/");
749        var result = [];
750
751        for (var i = 0; i < source.length; ++i) {
752            if (source[i] === ".")
753                continue;
754            // Ignore empty path components resulting from //, as well as a leading and traling slashes.
755            if (source[i] === "")
756                continue;
757            if (source[i] === "..")
758                result.pop();
759            else
760                result.push(source[i]);
761        }
762        return "/" + result.join("/");
763    },
764
765    /**
766     * @param {string} expression
767     * @param {boolean} exposeCommandLineAPI
768     * @param {boolean} returnByValue
769     * @param {Object} options
770     * @param {string} securityOrigin
771     * @param {function(?string, ?RuntimeAgent.RemoteObject, boolean=)} callback
772     */
773    evaluate: function(expression, exposeCommandLineAPI, returnByValue, options, securityOrigin, callback)
774    {
775        var contextId;
776        if (typeof options === "object") {
777
778            function resolveURLToFrame(url)
779            {
780                var found;
781                function hasMatchingURL(frame)
782                {
783                    found = (frame.url === url) ? frame : null;
784                    return found;
785                }
786                WebInspector.resourceTreeModel.frames().some(hasMatchingURL);
787                return found;
788            }
789
790            var frame = options.frameURL ? resolveURLToFrame(options.frameURL) : WebInspector.resourceTreeModel.mainFrame;
791            if (!frame) {
792                if (options.frameURL)
793                    console.warn("evaluate: there is no frame with URL " + options.frameURL);
794                else
795                    console.warn("evaluate: the main frame is not yet available");
796                return this._status.E_NOTFOUND(options.frameURL || "<top>");
797            }
798
799            var contextSecurityOrigin;
800            if (options.useContentScriptContext)
801                contextSecurityOrigin = securityOrigin;
802            else if (options.scriptExecutionContext)
803                contextSecurityOrigin = options.scriptExecutionContext;
804
805            var frameContextList = WebInspector.runtimeModel.contextListByFrame(frame);
806            var context;
807            if (contextSecurityOrigin) {
808                context = frameContextList.contextBySecurityOrigin(contextSecurityOrigin);
809                if (!context) {
810                    console.warn("The JS context " + contextSecurityOrigin + " was not found in the frame " + frame.url)
811                    return this._status.E_NOTFOUND(contextSecurityOrigin)
812                }
813            } else {
814                context = frameContextList.mainWorldContext();
815                if (!context)
816                    return this._status.E_FAILED(frame.url + " has no execution context");
817            }
818
819            contextId = context.id;
820        }
821        RuntimeAgent.evaluate(expression, "extension", exposeCommandLineAPI, true, contextId, returnByValue, false, callback);
822    }
823}
824
825/**
826 * @constructor
827 */
828WebInspector.ExtensionStatus = function()
829{
830    function makeStatus(code, description)
831    {
832        var details = Array.prototype.slice.call(arguments, 2);
833        var status = { code: code, description: description, details: details };
834        if (code !== "OK") {
835            status.isError = true;
836            console.log("Extension server error: " + String.vsprintf(description, details));
837        }
838        return status;
839    }
840
841    this.OK = makeStatus.bind(null, "OK", "OK");
842    this.E_EXISTS = makeStatus.bind(null, "E_EXISTS", "Object already exists: %s");
843    this.E_BADARG = makeStatus.bind(null, "E_BADARG", "Invalid argument %s: %s");
844    this.E_BADARGTYPE = makeStatus.bind(null, "E_BADARGTYPE", "Invalid type for argument %s: got %s, expected %s");
845    this.E_NOTFOUND = makeStatus.bind(null, "E_NOTFOUND", "Object not found: %s");
846    this.E_NOTSUPPORTED = makeStatus.bind(null, "E_NOTSUPPORTED", "Object does not support requested operation: %s");
847    this.E_PROTOCOLERROR = makeStatus.bind(null, "E_PROTOCOLERROR", "Inspector protocol error: %s");
848    this.E_FAILED = makeStatus.bind(null, "E_FAILED", "Operation failed: %s");
849}
850
851WebInspector.addExtensions = function(extensions)
852{
853    WebInspector.extensionServer._addExtensions(extensions);
854}
855
856WebInspector.extensionAPI = {};
857defineCommonExtensionSymbols(WebInspector.extensionAPI);
858
859WebInspector.extensionServer = new WebInspector.ExtensionServer();
860
861window.addExtension = function(page, name)
862{
863    WebInspector.extensionServer._addExtension({
864        startPage: page,
865        name: name,
866    });
867}
868