DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/screencast/ScreencastView.js

 /*
  * Copyright (C) 2013 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 10 matching lines @@
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * 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.
  */
 /**
- * @implements {WebInspector.DOMNodeHighlighter}
+ * @implements {SDK.DOMNodeHighlighter}
  * @unrestricted
  */
-WebInspector.ScreencastView = class extends WebInspector.VBox {
+Screencast.ScreencastView = class extends UI.VBox {
   /**
-   * @param {!WebInspector.Target} target
-   * @param {!WebInspector.ResourceTreeModel} resourceTreeModel
+   * @param {!SDK.Target} target
+   * @param {!SDK.ResourceTreeModel} resourceTreeModel
    */
   constructor(target, resourceTreeModel) {
     super();
     this._target = target;
-    this._domModel = WebInspector.DOMModel.fromTarget(target);
+    this._domModel = SDK.DOMModel.fromTarget(target);
     this._resourceTreeModel = resourceTreeModel;
 
     this.setMinimumSize(150, 150);
     this.registerRequiredCSS('screencast/screencastView.css');
   }
 
   initialize() {
     this.element.classList.add('screencast');
 
     this._createNavigationBar();
@@ skipping 27 matching lines @@
     this._titleElement.createChild('span', 'screencast-px').textContent = 'px';
     this._titleElement.style.top = '0';
     this._titleElement.style.left = '0';
 
     this._imageElement = new Image();
     this._isCasting = false;
     this._context = this._canvasElement.getContext('2d');
     this._checkerboardPattern = this._createCheckerboardPattern(this._context);
 
     this._shortcuts = /** !Object.<number, function(Event=):boolean> */ ({});
-    this._shortcuts[WebInspector.KeyboardShortcut.makeKey('l', WebInspector.KeyboardShortcut.Modifiers.Ctrl)] =
+    this._shortcuts[UI.KeyboardShortcut.makeKey('l', UI.KeyboardShortcut.Modifiers.Ctrl)] =
         this._focusNavigationBar.bind(this);
 
     this._resourceTreeModel.addEventListener(
-        WebInspector.ResourceTreeModel.Events.ScreencastFrame, this._screencastFrame, this);
+        SDK.ResourceTreeModel.Events.ScreencastFrame, this._screencastFrame, this);
     this._resourceTreeModel.addEventListener(
-        WebInspector.ResourceTreeModel.Events.ScreencastVisibilityChanged, this._screencastVisibilityChanged, this);
+        SDK.ResourceTreeModel.Events.ScreencastVisibilityChanged, this._screencastVisibilityChanged, this);
 
-    WebInspector.targetManager.addEventListener(
-        WebInspector.TargetManager.Events.SuspendStateChanged, this._onSuspendStateChange, this);
+    SDK.targetManager.addEventListener(
+        SDK.TargetManager.Events.SuspendStateChanged, this._onSuspendStateChange, this);
     this._updateGlasspane();
   }
 
   /**
    * @override
    */
   wasShown() {
     this._startCasting();
   }
 
   /**
    * @override
    */
   willHide() {
     this._stopCasting();
   }
 
   _startCasting() {
-    if (WebInspector.targetManager.allTargetsSuspended())
+    if (SDK.targetManager.allTargetsSuspended())
       return;
     if (this._isCasting)
       return;
     this._isCasting = true;
 
     const maxImageDimension = 2048;
     var dimensions = this._viewportDimensions();
     if (dimensions.width < 0 || dimensions.height < 0) {
       this._isCasting = false;
       return;
     }
     dimensions.width *= window.devicePixelRatio;
     dimensions.height *= window.devicePixelRatio;
     this._target.pageAgent().startScreencast(
         'jpeg', 80, Math.min(maxImageDimension, dimensions.width), Math.min(maxImageDimension, dimensions.height));
     this._target.emulationAgent().setTouchEmulationEnabled(true);
     this._domModel.setHighlighter(this);
   }
 
   _stopCasting() {
     if (!this._isCasting)
       return;
     this._isCasting = false;
     this._target.pageAgent().stopScreencast();
     this._target.emulationAgent().setTouchEmulationEnabled(false);
     this._domModel.setHighlighter(null);
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _screencastFrame(event) {
     var metadata = /** type {Protocol.Page.ScreencastFrameMetadata} */ (event.data.metadata);
     var base64Data = /** type {string} */ (event.data.data);
     this._imageElement.src = 'data:image/jpg;base64,' + base64Data;
     this._pageScaleFactor = metadata.pageScaleFactor;
     this._screenOffsetTop = metadata.offsetTop;
     this._scrollOffsetX = metadata.scrollOffsetX;
     this._scrollOffsetY = metadata.scrollOffsetY;
 
     var deviceSizeRatio = metadata.deviceHeight / metadata.deviceWidth;
     var dimensionsCSS = this._viewportDimensions();
 
     this._imageZoom = Math.min(
         dimensionsCSS.width / this._imageElement.naturalWidth,
         dimensionsCSS.height / (this._imageElement.naturalWidth * deviceSizeRatio));
     this._viewportElement.classList.remove('hidden');
-    var bordersSize = WebInspector.ScreencastView._bordersSize;
+    var bordersSize = Screencast.ScreencastView._bordersSize;
     if (this._imageZoom < 1.01 / window.devicePixelRatio)
       this._imageZoom = 1 / window.devicePixelRatio;
     this._screenZoom = this._imageElement.naturalWidth * this._imageZoom / metadata.deviceWidth;
     this._viewportElement.style.width = metadata.deviceWidth * this._screenZoom + bordersSize + 'px';
     this._viewportElement.style.height = metadata.deviceHeight * this._screenZoom + bordersSize + 'px';
 
     this.highlightDOMNode(this._highlightNode, this._highlightConfig);
   }
 
   _isGlassPaneActive() {
     return !this._glassPaneElement.classList.contains('hidden');
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _screencastVisibilityChanged(event) {
     this._targetInactive = !event.data.visible;
     this._updateGlasspane();
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _onSuspendStateChange(event) {
-    if (WebInspector.targetManager.allTargetsSuspended())
+    if (SDK.targetManager.allTargetsSuspended())
       this._stopCasting();
     else
       this._startCasting();
     this._updateGlasspane();
   }
 
   _updateGlasspane() {
     if (this._targetInactive) {
-      this._glassPaneElement.textContent = WebInspector.UIString('The tab is inactive');
+      this._glassPaneElement.textContent = Common.UIString('The tab is inactive');
       this._glassPaneElement.classList.remove('hidden');
-    } else if (WebInspector.targetManager.allTargetsSuspended()) {
-      this._glassPaneElement.textContent = WebInspector.UIString('Profiling in progress');
+    } else if (SDK.targetManager.allTargetsSuspended()) {
+      this._glassPaneElement.textContent = Common.UIString('Profiling in progress');
       this._glassPaneElement.classList.remove('hidden');
     } else {
       this._glassPaneElement.classList.add('hidden');
     }
   }
 
   /**
    * @param {!Event} event
    */
   _handleMouseEvent(event) {
@@ skipping 12 matching lines @@
         this._canvasElement.focus();
       return;
     }
 
     var position = this._convertIntoScreenSpace(event);
     this._domModel.nodeForLocation(
         position.x / this._pageScaleFactor + this._scrollOffsetX,
         position.y / this._pageScaleFactor + this._scrollOffsetY, callback.bind(this));
 
     /**
-     * @param {?WebInspector.DOMNode} node
-     * @this {WebInspector.ScreencastView}
+     * @param {?SDK.DOMNode} node
+     * @this {Screencast.ScreencastView}
      */
     function callback(node) {
       if (!node)
         return;
       if (event.type === 'mousemove') {
         this.highlightDOMNode(node, this._inspectModeConfig);
         this._domModel.nodeHighlightRequested(node.id);
       } else if (event.type === 'click') {
-        WebInspector.Revealer.reveal(node);
+        Common.Revealer.reveal(node);
       }
     }
   }
 
   /**
    * @param {!Event} event
    */
   _handleKeyEvent(event) {
     if (this._isGlassPaneActive()) {
       event.consume();
       return;
     }
 
-    var shortcutKey = WebInspector.KeyboardShortcut.makeKeyFromEvent(/** @type {!KeyboardEvent} */ (event));
+    var shortcutKey = UI.KeyboardShortcut.makeKeyFromEvent(/** @type {!KeyboardEvent} */ (event));
     var handler = this._shortcuts[shortcutKey];
     if (handler && handler(event)) {
       event.consume();
       return;
     }
 
     var type;
     switch (event.type) {
       case 'keydown':
         type = 'keyDown';
@@ skipping 137 matching lines @@
       clearTimeout(this._deferredCasting);
       delete this._deferredCasting;
     }
 
     this._stopCasting();
     this._deferredCasting = setTimeout(this._startCasting.bind(this), 100);
   }
 
   /**
    * @override
-   * @param {?WebInspector.DOMNode} node
+   * @param {?SDK.DOMNode} node
    * @param {?Protocol.DOM.HighlightConfig} config
    * @param {!Protocol.DOM.BackendNodeId=} backendNodeId
    * @param {!Protocol.Runtime.RemoteObjectId=} objectId
    */
   highlightDOMNode(node, config, backendNodeId, objectId) {
     this._highlightNode = node;
     this._highlightConfig = config;
     if (!node) {
       this._model = null;
       this._config = null;
       this._node = null;
       this._titleElement.classList.add('hidden');
       this._repaint();
       return;
     }
 
     this._node = node;
     node.boxModel(callback.bind(this));
 
     /**
      * @param {?Protocol.DOM.BoxModel} model
-     * @this {WebInspector.ScreencastView}
+     * @this {Screencast.ScreencastView}
      */
     function callback(model) {
       if (!model || !this._pageScaleFactor) {
         this._repaint();
         return;
       }
       this._model = this._scaleModel(model);
       this._config = config;
       this._repaint();
     }
   }
 
   /**
    * @param {!Protocol.DOM.BoxModel} model
    * @return {!Protocol.DOM.BoxModel}
    */
   _scaleModel(model) {
     /**
      * @param {!Protocol.DOM.Quad} quad
-     * @this {WebInspector.ScreencastView}
+     * @this {Screencast.ScreencastView}
      */
     function scaleQuad(quad) {
       for (var i = 0; i < quad.length; i += 2) {
         quad[i] = quad[i] * this._screenZoom;
         quad[i + 1] = (quad[i + 1] + this._screenOffsetTop) * this._screenZoom;
       }
     }
 
     scaleQuad.call(this, model.content);
     scaleQuad.call(this, model.padding);
@@ skipping 53 matching lines @@
     this._context.restore();
   }
 
   /**
    * @param {!Protocol.DOM.RGBA} color
    * @return {string}
    */
   _cssColor(color) {
     if (!color)
       return 'transparent';
-    return WebInspector.Color.fromRGBA([color.r, color.g, color.b, color.a]).asString(WebInspector.Color.Format.RGBA) ||
+    return Common.Color.fromRGBA([color.r, color.g, color.b, color.a]).asString(Common.Color.Format.RGBA) ||
         '';
   }
 
   /**
    * @param {!Protocol.DOM.Quad} quad
    * @return {!CanvasRenderingContext2D}
    */
   _quadToPath(quad) {
     this._context.beginPath();
     this._context.moveTo(quad[0], quad[1]);
@@ skipping 109 matching lines @@
 
     this._titleElement.style.top = (boxY + 3) + 'px';
     this._titleElement.style.left = (boxX + 3) + 'px';
   }
 
   /**
    * @return {!{width: number, height: number}}
    */
   _viewportDimensions() {
     const gutterSize = 30;
-    const bordersSize = WebInspector.ScreencastView._bordersSize;
+    const bordersSize = Screencast.ScreencastView._bordersSize;
     var width = this.element.offsetWidth - bordersSize - gutterSize;
-    var height = this.element.offsetHeight - bordersSize - gutterSize - WebInspector.ScreencastView._navBarHeight;
+    var height = this.element.offsetHeight - bordersSize - gutterSize - Screencast.ScreencastView._navBarHeight;
     return {width: width, height: height};
   }
 
   /**
    * @override
    * @param {!Protocol.DOM.InspectMode} mode
    * @param {!Protocol.DOM.HighlightConfig} config
    * @param {function(?Protocol.Error)=} callback
    */
   setInspectMode(mode, config, callback) {
@@ skipping 40 matching lines @@
     this._navigationForward.addEventListener('click', this._navigateToHistoryEntry.bind(this, 1), false);
 
     this._navigationReload = this._navigationBar.createChild('button', 'reload');
     this._navigationReload.addEventListener('click', this._navigateReload.bind(this), false);
 
     this._navigationUrl = this._navigationBar.createChild('input');
     this._navigationUrl.type = 'text';
     this._navigationUrl.addEventListener('keyup', this._navigationUrlKeyUp.bind(this), true);
 
     this._navigationProgressBar =
-        new WebInspector.ScreencastView.ProgressTracker(this._navigationBar.createChild('div', 'progress'));
+        new Screencast.ScreencastView.ProgressTracker(this._navigationBar.createChild('div', 'progress'));
 
     this._requestNavigationHistory();
-    WebInspector.targetManager.addEventListener(
-        WebInspector.TargetManager.Events.InspectedURLChanged, this._requestNavigationHistory, this);
+    SDK.targetManager.addEventListener(
+        SDK.TargetManager.Events.InspectedURLChanged, this._requestNavigationHistory, this);
   }
 
   _navigateToHistoryEntry(offset) {
     var newIndex = this._historyIndex + offset;
     if (newIndex < 0 || newIndex >= this._historyEntries.length)
       return;
     this._target.pageAgent().navigateToHistoryEntry(this._historyEntries[newIndex].id);
     this._requestNavigationHistory();
   }
 
   _navigateReload() {
     this._resourceTreeModel.reloadPage();
   }
 
   _navigationUrlKeyUp(event) {
     if (event.key !== 'Enter')
       return;
     var url = this._navigationUrl.value;
     if (!url)
       return;
-    if (!url.match(WebInspector.ScreencastView._SchemeRegex))
+    if (!url.match(Screencast.ScreencastView._SchemeRegex))
       url = 'http://' + url;
     this._target.pageAgent().navigate(url);
     this._canvasElement.focus();
   }
 
   _requestNavigationHistory() {
     this._target.pageAgent().getNavigationHistory(this._onNavigationHistory.bind(this));
   }
 
   _onNavigationHistory(error, currentIndex, entries) {
     if (error)
       return;
 
     this._historyIndex = currentIndex;
     this._historyEntries = entries;
 
     this._navigationBack.disabled = currentIndex === 0;
     this._navigationForward.disabled = currentIndex === (entries.length - 1);
 
     var url = entries[currentIndex].url;
-    var match = url.match(WebInspector.ScreencastView._HttpRegex);
+    var match = url.match(Screencast.ScreencastView._HttpRegex);
     if (match)
       url = match[1];
     InspectorFrontendHost.inspectedURLChanged(url);
     this._navigationUrl.value = url;
   }
 
   _focusNavigationBar() {
     this._navigationUrl.focus();
     this._navigationUrl.select();
     return true;
   }
 };
 
-WebInspector.ScreencastView._bordersSize = 44;
+Screencast.ScreencastView._bordersSize = 44;
 
-WebInspector.ScreencastView._navBarHeight = 29;
+Screencast.ScreencastView._navBarHeight = 29;
 
-WebInspector.ScreencastView._HttpRegex = /^http:\/\/(.+)/;
+Screencast.ScreencastView._HttpRegex = /^http:\/\/(.+)/;
 
-WebInspector.ScreencastView._SchemeRegex = /^(https?|about|chrome):/;
+Screencast.ScreencastView._SchemeRegex = /^(https?|about|chrome):/;
 
 /**
  * @unrestricted
  */
-WebInspector.ScreencastView.ProgressTracker = class {
+Screencast.ScreencastView.ProgressTracker = class {
   /**
    * @param {!Element} element
    */
   constructor(element) {
     this._element = element;
 
-    WebInspector.targetManager.addModelListener(
-        WebInspector.ResourceTreeModel, WebInspector.ResourceTreeModel.Events.MainFrameNavigated,
+    SDK.targetManager.addModelListener(
+        SDK.ResourceTreeModel, SDK.ResourceTreeModel.Events.MainFrameNavigated,
         this._onMainFrameNavigated, this);
-    WebInspector.targetManager.addModelListener(
-        WebInspector.ResourceTreeModel, WebInspector.ResourceTreeModel.Events.Load, this._onLoad, this);
-    WebInspector.targetManager.addModelListener(
-        WebInspector.NetworkManager, WebInspector.NetworkManager.Events.RequestStarted, this._onRequestStarted, this);
-    WebInspector.targetManager.addModelListener(
-        WebInspector.NetworkManager, WebInspector.NetworkManager.Events.RequestFinished, this._onRequestFinished, this);
+    SDK.targetManager.addModelListener(
+        SDK.ResourceTreeModel, SDK.ResourceTreeModel.Events.Load, this._onLoad, this);
+    SDK.targetManager.addModelListener(
+        SDK.NetworkManager, SDK.NetworkManager.Events.RequestStarted, this._onRequestStarted, this);
+    SDK.targetManager.addModelListener(
+        SDK.NetworkManager, SDK.NetworkManager.Events.RequestFinished, this._onRequestFinished, this);
   }
 
   _onMainFrameNavigated() {
     this._requestIds = {};
     this._startedRequests = 0;
     this._finishedRequests = 0;
     this._maxDisplayedProgress = 0;
     this._updateProgress(0.1);  // Display first 10% on navigation start.
   }
 
   _onLoad() {
     delete this._requestIds;
     this._updateProgress(1);  // Display 100% progress on load, hide it in 0.5s.
     setTimeout(function() {
       if (!this._navigationProgressVisible())
         this._displayProgress(0);
     }.bind(this), 500);
   }
 
   _navigationProgressVisible() {
     return !!this._requestIds;
   }
 
   _onRequestStarted(event) {
     if (!this._navigationProgressVisible())
       return;
-    var request = /** @type {!WebInspector.NetworkRequest} */ (event.data);
+    var request = /** @type {!SDK.NetworkRequest} */ (event.data);
     // Ignore long-living WebSockets for the sake of progress indicator, as we won't be waiting them anyway.
-    if (request.type === WebInspector.resourceTypes.WebSocket)
+    if (request.type === Common.resourceTypes.WebSocket)
       return;
     this._requestIds[request.requestId] = request;
     ++this._startedRequests;
   }
 
   _onRequestFinished(event) {
     if (!this._navigationProgressVisible())
       return;
-    var request = /** @type {!WebInspector.NetworkRequest} */ (event.data);
+    var request = /** @type {!SDK.NetworkRequest} */ (event.data);
     if (!(request.requestId in this._requestIds))
       return;
     ++this._finishedRequests;
     setTimeout(function() {
       this._updateProgress(
           this._finishedRequests / this._startedRequests * 0.9);  // Finished requests drive the progress up to 90%.
     }.bind(this), 500);  // Delay to give the new requests time to start. This makes the progress smoother.
   }
 
   _updateProgress(progress) {
     if (!this._navigationProgressVisible())
       return;
     if (this._maxDisplayedProgress >= progress)
       return;
     this._maxDisplayedProgress = progress;
     this._displayProgress(progress);
   }
 
   _displayProgress(progress) {
     this._element.style.width = (100 * progress) + '%';
   }
 };