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