Devtools: [WIP] Implement enhanced devtools extension language APIs

Source/devtools/front_end/extensions/ExtensionServer.js

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
  * @constructor
  * @extends {WebInspector.Object}
+ * @param {!WebInspector.ExtensionServer.UIDelegate} delegate
  * @suppressGlobalPropertiesCheck
  */
-WebInspector.ExtensionServer = function()
+WebInspector.ExtensionServer = function(delegate)
 {
+    this._delegate = delegate;
     this._clientObjects = {};
     this._handlers = {};
+    this._callbacks = {};
     this._subscribers = {};
     this._subscriptionStartHandlers = {};
     this._subscriptionStopHandlers = {};
     this._extraHeaders = {};
     this._requests = {};
     this._lastRequestId = 0;
     this._registeredExtensions = {};
     this._status = new WebInspector.ExtensionStatus();
     /** @type {!Array.<!WebInspector.ExtensionSidebarPane>} */
     this._sidebarPanes = [];
     /** @type {!Array.<!WebInspector.ExtensionAuditCategory>} */
     this._auditCategories = [];
 
     var commands = WebInspector.extensionAPI.Commands;
 
     this._registerHandler(commands.AddAuditCategory, this._onAddAuditCategory.bind(this));
     this._registerHandler(commands.AddAuditResult, this._onAddAuditResult.bind(this));
     this._registerHandler(commands.AddRequestHeaders, this._onAddRequestHeaders.bind(this));
     this._registerHandler(commands.ApplyStyleSheet, this._onApplyStyleSheet.bind(this));
     this._registerHandler(commands.CreatePanel, this._onCreatePanel.bind(this));
     this._registerHandler(commands.CreateSidebarPane, this._onCreateSidebarPane.bind(this));
     this._registerHandler(commands.CreateToolbarButton, this._onCreateToolbarButton.bind(this));
+    this._registerHandler(commands.DisplaySearchResults, this._onDisplaySearchResults.bind(this));
     this._registerHandler(commands.EvaluateOnInspectedPage, this._onEvaluateOnInspectedPage.bind(this));
     this._registerHandler(commands.ForwardKeyboardEvent, this._onForwardKeyboardEvent.bind(this));
     this._registerHandler(commands.GetHAR, this._onGetHAR.bind(this));
     this._registerHandler(commands.GetPageResources, this._onGetPageResources.bind(this));
     this._registerHandler(commands.GetRequestContent, this._onGetRequestContent.bind(this));
     this._registerHandler(commands.GetResourceContent, this._onGetResourceContent.bind(this));
+    this._registerHandler(commands.GetResourceLineMessages, this._onGetResourceLineMessages.bind(this));
+    this._registerHandler(commands.RegisterLanguageService, this._onRegisterLanguageService.bind(this));
+    this._registerHandler(commands.RegisterMimeRecognizer, this._onRegisterMimeRecognizer.bind(this));
     this._registerHandler(commands.Reload, this._onReload.bind(this));
     this._registerHandler(commands.SetOpenResourceHandler, this._onSetOpenResourceHandler.bind(this));
     this._registerHandler(commands.SetResourceContent, this._onSetResourceContent.bind(this));
+    this._registerHandler(commands.SetResourceLineMessages, this._onSetResourceLineMessages.bind(this));
     this._registerHandler(commands.SetSidebarHeight, this._onSetSidebarHeight.bind(this));
     this._registerHandler(commands.SetSidebarContent, this._onSetSidebarContent.bind(this));
     this._registerHandler(commands.SetSidebarPage, this._onSetSidebarPage.bind(this));
     this._registerHandler(commands.ShowPanel, this._onShowPanel.bind(this));
     this._registerHandler(commands.StopAuditCategoryRun, this._onStopAuditCategoryRun.bind(this));
     this._registerHandler(commands.Subscribe, this._onSubscribe.bind(this));
     this._registerHandler(commands.OpenResource, this._onOpenResource.bind(this));
     this._registerHandler(commands.Unsubscribe, this._onUnsubscribe.bind(this));
     this._registerHandler(commands.UpdateButton, this._onUpdateButton.bind(this));
     this._registerHandler(commands.UpdateAuditProgress, this._onUpdateAuditProgress.bind(this));
+    this._registerHandler("callback", this._onCallback.bind(this));
     window.addEventListener("message", this._onWindowMessage.bind(this), false);  // Only for main window.
 
     InspectorFrontendHost.events.addEventListener(InspectorFrontendHostAPI.Events.AddExtensions, this._addExtensions, this);
     InspectorFrontendHost.events.addEventListener(InspectorFrontendHostAPI.Events.SetInspectedTabId, this._setInspectedTabId, this);
 
     this._initExtensions();
 }
 
 WebInspector.ExtensionServer.Events = {
     SidebarPaneAdded: "SidebarPaneAdded",
@@ skipping 81 matching lines @@
 
     /**
      * @param {string} type
      * @return {boolean}
      */
     hasSubscribers: function(type)
     {
         return !!this._subscribers[type];
     },
 
+    _registerCallback: function(callback) {
+        var cbId = Math.random()*Number.MAX_VALUE;
+        if (this._callbacks[cbId]) {
+            return this._registerCallback(callback);
+        }
+        this._callbacks[cbId] = callback;
+        return cbId;
+    },
+
+    /**
+     * @param {!MessagePort} port
+     * @param {*} message
+     * @param {?Function=} callback
+     */
+    _sendRequest: function(port, message, callback) {
+        if (typeof callback === "function")
+            message.requestId = this._registerCallback(callback);
+        port.postMessage(message);
+    },
+
     /**
      * @param {string} type
      * @param {...*} vararg
      */
     _postNotification: function(type, vararg)
     {
         var subscribers = this._subscribers[type];
         if (!subscribers)
             return;
         var message = {
@@ skipping 48 matching lines @@
                 if (typeof headers[name] === "string")
                     allHeaders[name] = headers[name];
             }
         }
 
         WebInspector.multitargetNetworkManager.setExtraHTTPHeaders(allHeaders);
     },
 
     /**
      * @param {*} message
+     * @param {!MessagePort} port
+     */
+    _onRegisterLanguageService: function(message, port) {
+        if (!(message.mimes && message.name && message.capabilities)) {
+            return;
+        }
+        var _this = this;
+        
+        if (message.simplemode) {
+            this._delegate.addSimpleCodeMirrorMode(message.mimes, message.simplemode);
+        }
+
+        var service = new WebInspector.LanguageService.CallbackDelegate(message.name, {});
+
+        if (message.capabilities.indexOf(WebInspector.LanguageService.Capabilities.Transpile) !== -1) {
+            service.appendActionHandler(WebInspector.LanguageService.Capabilities.Transpile, function(input, location, callback) {
+                if (!callback) {
+                    callback = location;
+                    location = undefined;
+                }
+                _this._sendRequest(port, {
+                    command: WebInspector.LanguageService.Capabilities.Transpile+"-"+message.name, 
+                    input: input, 
+                    location: location
+                }, function(result) {
+                    if ((!result) || typeof result !== "string") {
+                        return callback(input);
+                    }
+                    callback(result);
+                });
+            });
+        }
+        if (message.capabilities.indexOf(WebInspector.LanguageService.Capabilities.PopulateContextMenu) !== -1) {
+            service.appendActionHandler(WebInspector.LanguageService.Capabilities.PopulateContextMenu, function(location, callback) {
+                _this._sendRequest(port, {
+                    command: WebInspector.LanguageService.Capabilities.PopulateContextMenu+"-"+message.name, 
+                    location: location
+                }, function(items) {
+                    if (!items || !(items instanceof Array)) {
+                        return callback([]);
+                    }
+                    callback(items.map(function(item) {
+                        if (typeof item.text !== "string") return;
+                        if (typeof item.id !== "number") return;
+                        return {
+                            text: item.text,
+                            callback: function() {
+                                _this._sendRequest(port, {command: "notify-"+WebInspector.extensionAPI.Events.ContextMenuClicked, id: item.id});
+                            }
+                        };
+                    }).filter(i => {return i;}));
+                });
+            });
+        }
+        
+        function handleCompletionsResponse(callback) { 
+            return function(completions) {
+                if ((!completions) || !(completions instanceof Array)) {
+                    return callback([]);
+                }
+                callback(completions.map(function(c){
+                    if (typeof c.text !== "string") return;
+                    if (!(typeof c.icon === "string" || typeof c.icon === "undefined")) return;
+                    if (typeof c.id !== "number") return;
+                    return {
+                        text: c.text,
+                        icon: c.icon,
+                        details: function() {
+                            return new Promise(function(resolve, reject) {
+                                _this._sendRequest(port, {command: "completionDetails-"+message.name, id: c.id}, function(resp) {
+                                    if (!resp) reject();
+                                    if (typeof resp.detail !== "string") reject();
+                                    if (typeof resp.description !== "string") reject();
+                                    resolve(resp);
+                                });
+                            });
+                        }
+                    };
+                }).filter(i => {return i;}));
+            }
+        }
+
+        if (message.capabilities.indexOf(WebInspector.LanguageService.Capabilities.Completions) !== -1) {
+            service.appendActionHandler(WebInspector.LanguageService.Capabilities.Completions, function(location, prefix, callback) {
+                _this._sendRequest(port, {
+                    command: WebInspector.LanguageService.Capabilities.Completions+"-"+message.name,
+                    location: location,
+                    prefix: prefix
+                }, handleCompletionsResponse(callback));
+            });
+        }
+
+        if (message.capabilities.indexOf(WebInspector.LanguageService.Capabilities.DebuggerCompletions) !== -1) {
+            service.appendActionHandler(WebInspector.LanguageService.Capabilities.DebuggerCompletions, function(content, cursor, prefix, context, callback) {
+                _this._sendRequest(port, {
+                    command: WebInspector.LanguageService.Capabilities.DebuggerCompletions+"-"+message.name,
+                    content: content,
+                    cursor: cursor,
+                    prefix: prefix,
+                    context: context
+                }, handleCompletionsResponse(callback));
+            });
+        }
+
+        WebInspector.languageService.register(message.mimes, service);
+    },
+    
+    _onRegisterMimeRecognizer: function(message) {
+        if (typeof message.mime !== "string") {
+            return this._status.E_BADARGTYPE("mime", typeof message.mime, "string");
+        }
+        if (typeof message.match !== "string") {
+            return this._status.E_BADARGTYPE("match", typeof message.match, "string");
+        }
+        WebInspector.ResourceType.registerMimeRecognizer(message.match, message.mime, message.matchName);
+    },
+
+    _onDisplaySearchResults: function(message) {
+        //FIXME: Search result highlighting should allow ranges to be highlighted rather than regexes
+        var results = message.results || [];
+
+        var groupedResults = results.reduce(function(accum, item) { //group by source
+            var elem;
+            for (var index = 0; index < accum.length; index++) {
+                var element = accum[index];
+                if (element.source === item.source) {
+                    elem = element;
+                    break;
+                }
+            }
+            if (!elem) {
+                elem = [];
+                elem.source = item.source;
+                accum.push(elem);
+            }
+            elem.push({
+                line: item.line,
+                lineContent: item.lineContent || '',
+                startColumn: item.startColumn || 0,
+                endColumn: item.endColumn || 0
+            });
+            return accum;
+        }, []);
+        this._delegate.displaySearchResults(results.highlight || '', groupedResults);
+    },
+
+    /**
+     * @param {*} message
+     * @param {!MessagePort} port
+     */
+    _onGetResourceLineMessages: function(message, port) {
+        var url = /** @type {string} */ (message.url);
+        var uiSourceCode = WebInspector.networkMapping.uiSourceCodeFromURL(url);
+        if (!uiSourceCode)
+            return this._status.E_NOTFOUND(url);
+
+        this._delegate.getResourceLineMessages(uiSourceCode).then(arr => {
+            var result = arr.map(m => {
+                return {
+                    text: m.messageText(),
+                    kind: m.level(),
+                    location: {
+                        startLine: m.start().line,
+                        startColumn: m.start().column,
+                        endLine: m.end().line,
+                        endColumn: m.end().column
+                    }
+                };
+            });
+            this._dispatchCallback(message.requestId, port, result);
+        });
+    },
+
+    /**
+     * @param {*} message
+     * @param {!MessagePort} port
+     */
+    _onSetResourceLineMessages: function(message, port) {
+        var url = /** @type {string} */ (message.url);
+        var messages = /** @type {?Array.<{kind: string, text: string, location: {startLine: number, startColumn: number, endLine: number, endColumn: number}}>} */ (message.messages);
+        if ((!messages) || typeof messages !== "object")
+            return this._status.E_BADARGTYPE("messages", typeof messages, "Array<LineMessage>");
+        var uiSourceCode = WebInspector.networkMapping.uiSourceCodeFromURL(url);
+        if (!uiSourceCode)
+            return this._status.E_NOTFOUND(url);
+        this._delegate.setResourceLineMessages(uiSourceCode, messages);
+        this._dispatchCallback(message.requestId, port, this._status.OK());
+    },
+
+    /**
+     * @param {*} message
      * @suppressGlobalPropertiesCheck
      */
     _onApplyStyleSheet: function(message)
     {
         if (!Runtime.experiments.isEnabled("applyCustomStylesheet"))
             return;
         var styleSheet = createElement("style");
         styleSheet.textContent = message.styleSheet;
         document.head.appendChild(styleSheet);
     },
@@ skipping 100 matching lines @@
     _onSetSidebarPage: function(message, port)
     {
         var sidebar = this._clientObjects[message.id];
         if (!sidebar)
             return this._status.E_NOTFOUND(message.id);
         sidebar.setPage(this._expandResourcePath(port._extensionOrigin, message.page));
     },
 
     _onOpenResource: function(message)
     {
-        var uiSourceCode = WebInspector.networkMapping.uiSourceCodeForURLForAnyTarget(message.url);
+        var uiSourceCode = WebInspector.networkMapping.uiSourceCodeForURLForAnyTarget(message.url) || WebInspector.workspace.uiSourceCodeForFilePath(message.url);

[wes, 2015/08/14 01:13:32]

Upon review, I see that this line is an alias to the
NetworkMapping.uiSourceCodeFromURL function I added, and should (likely?) be
replaced with it.

[pfeldman, 2015/08/17 21:15:51]

Your message has a target, so you should get resource from the project built on
that target first, then callback to any project.

[wes, 2015/08/25 18:13:18]

The open resource message only has a url and a line number?

         if (uiSourceCode) {
             WebInspector.Revealer.reveal(uiSourceCode.uiLocation(message.lineNumber, 0));
             return this._status.OK();
         }
 
         var resource = WebInspector.resourceForURL(message.url);
         if (resource) {
             WebInspector.Revealer.reveal(resource, message.lineNumber);
             return this._status.OK();
         }
@@ skipping 101 matching lines @@
         /**
          * @this {WebInspector.ExtensionServer}
          */
         function pushResourceData(contentProvider)
         {
             if (!resources[contentProvider.contentURL()])
                 resources[contentProvider.contentURL()] = this._makeResource(contentProvider);
         }
         var uiSourceCodes = WebInspector.workspace.uiSourceCodesForProjectType(WebInspector.projectTypes.Network);
         uiSourceCodes = uiSourceCodes.concat(WebInspector.workspace.uiSourceCodesForProjectType(WebInspector.projectTypes.ContentScripts));
+        uiSourceCodes = uiSourceCodes.concat(WebInspector.workspace.uiSourceCodesForProjectType(WebInspector.projectTypes.FileSystem));
         uiSourceCodes.forEach(pushResourceData.bind(this));
         for (var target of WebInspector.targetManager.targets())
             target.resourceTreeModel.forAllResources(pushResourceData.bind(this));
         return Object.values(resources);
     },
 
     /**
      * @param {!WebInspector.ContentProvider} contentProvider
      * @param {!Object} message
      * @param {!MessagePort} port
@@ skipping 25 matching lines @@
     {
         var request = this._requestById(message.id);
         if (!request)
             return this._status.E_NOTFOUND(message.id);
         this._getResourceContent(request, message, port);
     },
 
     _onGetResourceContent: function(message, port)
     {
         var url = /** @type {string} */ (message.url);
-        var contentProvider = WebInspector.workspace.uiSourceCodeForOriginURL(url) || WebInspector.resourceForURL(url);
+        var contentProvider = WebInspector.networkMapping.uiSourceCodeFromURL(url);
         if (!contentProvider)
             return this._status.E_NOTFOUND(url);
         this._getResourceContent(contentProvider, message, port);
     },
 
     _onSetResourceContent: function(message, port)
     {
         /**
          * @param {?Protocol.Error} error
          * @this {WebInspector.ExtensionServer}
@@ skipping 116 matching lines @@
             return keyCode || 0;
         }
     },
 
     _dispatchCallback: function(requestId, port, result)
     {
         if (requestId)
             port.postMessage({ command: "callback", requestId: requestId, result: result });
     },
 
+    _onCallback: function(request, target)
+    {
+        if (request.requestId in this._callbacks) {
+            var callback = this._callbacks[request.requestId];
+            delete this._callbacks[request.requestId];
+            callback(request.result);
+        }
+    },
+
     _initExtensions: function()
     {
         this._registerAutosubscriptionHandler(WebInspector.extensionAPI.Events.ResourceAdded,
             WebInspector.workspace, WebInspector.Workspace.Events.UISourceCodeAdded, this._notifyResourceAdded);
         this._registerAutosubscriptionTargetManagerHandler(WebInspector.extensionAPI.Events.NetworkRequestFinished,
             WebInspector.NetworkManager, WebInspector.NetworkManager.EventTypes.RequestFinished, this._notifyRequestFinished);
 
         /**
          * @this {WebInspector.ExtensionServer}
          */
         function onElementsSubscriptionStarted()
         {
             WebInspector.notifications.addEventListener(WebInspector.NotificationService.Events.SelectedNodeChanged, this._notifyElementsSelectionChanged, this);
         }
 
         /**
          * @this {WebInspector.ExtensionServer}
          */
         function onElementsSubscriptionStopped()
         {
             WebInspector.notifications.removeEventListener(WebInspector.NotificationService.Events.SelectedNodeChanged, this._notifyElementsSelectionChanged, this);
         }
 
         this._registerSubscriptionHandler(WebInspector.extensionAPI.Events.PanelObjectSelected + "elements",
             onElementsSubscriptionStarted.bind(this), onElementsSubscriptionStopped.bind(this));
         this._registerResourceContentCommittedHandler(this._notifyUISourceCodeContentCommitted);
+        this._registerResourceContentEditedHandler(this._notifyUISourceCodeContentEdited);
 
         WebInspector.targetManager.addEventListener(WebInspector.TargetManager.Events.InspectedURLChanged,
             this._inspectedURLChanged, this);
 
         InspectorExtensionRegistry.getExtensionsAsync();
     },
 
     _notifyResourceAdded: function(event)
     {
         var uiSourceCode = /** @type {!WebInspector.UISourceCode} */ (event.data);
         this._postNotification(WebInspector.extensionAPI.Events.ResourceAdded, this._makeResource(uiSourceCode));
     },
 
     _notifyUISourceCodeContentCommitted: function(event)
     {
         var uiSourceCode = /** @type {!WebInspector.UISourceCode} */ (event.data.uiSourceCode);
         var content = /** @type {string} */ (event.data.content);
         this._postNotification(WebInspector.extensionAPI.Events.ResourceContentCommitted, this._makeResource(uiSourceCode), content);
     },
 
+    _notifyUISourceCodeContentEdited: function(event)
+    {
+        var data = /** @type {{uiSourceCode: !WebInspector.UISourceCode, replacement: string, range: !WebInspector.TextRange}} */ (event.data);
+        this._postNotification(WebInspector.extensionAPI.Events.ResourceContentEdited, this._makeResource(data.uiSourceCode), data.range, data.replacement);
+    },
+
     _notifyRequestFinished: function(event)
     {
         var request = /** @type {!WebInspector.NetworkRequest} */ (event.data);
         this._postNotification(WebInspector.extensionAPI.Events.NetworkRequestFinished, this._requestId(request), (new WebInspector.HAREntry(request)).build());
     },
 
     _notifyElementsSelectionChanged: function()
     {
         this._postNotification(WebInspector.extensionAPI.Events.PanelObjectSelected + "elements");
     },
@@ skipping 142 matching lines @@
         {
             WebInspector.workspace.setHasResourceContentTrackingExtensions(false);
             WebInspector.workspace.removeEventListener(WebInspector.Workspace.Events.UISourceCodeContentCommitted, handler, this);
         }
 
         this._registerSubscriptionHandler(WebInspector.extensionAPI.Events.ResourceContentCommitted,
             addFirstEventListener.bind(this),
             removeLastEventListener.bind(this));
     },
 
+    _registerResourceContentEditedHandler: function(handler)
+    {
+        /**
+         * @this {WebInspector.ExtensionServer}
+         */
+        function addFirstEventListener()
+        {
+            WebInspector.workspace.addEventListener(WebInspector.Workspace.Events.UISourceCodeEdited, handler, this);
+        }
+
+        /**
+         * @this {WebInspector.ExtensionServer}
+         */
+        function removeLastEventListener()
+        {
+            WebInspector.workspace.removeEventListener(WebInspector.Workspace.Events.UISourceCodeEdited, handler, this);
+        }
+
+        this._registerSubscriptionHandler(WebInspector.extensionAPI.Events.ResourceContentEdited,
+            addFirstEventListener.bind(this),
+            removeLastEventListener.bind(this));
+    },
+
     _expandResourcePath: function(extensionPath, resourcePath)
     {
         if (!resourcePath)
             return;
         return extensionPath + this._normalizePath(resourcePath);
     },
 
     _normalizePath: function(path)
     {
         var source = path.split("/");
@@ skipping 182 matching lines @@
     this.E_FAILED = makeStatus.bind(null, "E_FAILED", "Operation failed: %s");
 }
 
 /**
  * @typedef {{code: string, description: string, details: !Array.<*>}}
  */
 WebInspector.ExtensionStatus.Record;
 
 WebInspector.extensionAPI = {};
 defineCommonExtensionSymbols(WebInspector.extensionAPI);
+
+/**
+ * @typedef {Array<{line: number, lineContent: string}>}
+ * @property {string} source
+ */
+var SearchResultArray;
+
+/**
+ * @typedef {!Array<{messageText: function(): string, level: function(): string, start: function(): {line: number, column: number}, end: function(): {line: number, column: number}}>}
+ */
+var SourceFrameMessageGetter;
+
+/**
+ * @interface
+ */
+WebInspector.ExtensionServer.UIDelegate = function() {}
+WebInspector.ExtensionServer.UIDelegate.prototype = {
+    /**
+     * @param {!WebInspector.UISourceCode} code
+     * @param {!Array<{kind: string, text: string, location: {startLine: number, startColumn: number, endLine: number, endColumn: number}}>} messages
+     */
+    setResourceLineMessages: function(code, messages) {},
+
+    /**
+     * @param {!WebInspector.UISourceCode} code
+     * @return {!Promise<!SourceFrameMessageGetter>}
+     */
+    getResourceLineMessages: function(code) { return Promise.reject(); },
+
+    /**
+     * @param {string} highlightText
+     * @param {!Array<!SearchResultArray>} groupedResults
+     */
+    displaySearchResults: function(highlightText, groupedResults) {},
+    
+    /**
+     * @param {!Array<string>} mimes
+     * @param {?} mode
+     */ 
+    addSimpleCodeMirrorMode: function(mimes, mode){}
+}