[DevTools] Consolidate overlay-related functionality in Overlay domain

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 {SDK.DOMNodeHighlighter}
+ * @implements {SDK.OverlayModel.Highlighter}
  * @unrestricted
  */
 Screencast.ScreencastView = class extends UI.VBox {
   /**
    * @param {!SDK.ScreenCaptureModel} screenCaptureModel
    */
   constructor(screenCaptureModel) {
     super();
     this._screenCaptureModel = screenCaptureModel;
     this._domModel = screenCaptureModel.target().model(SDK.DOMModel);
+    this._overlayModel = screenCaptureModel.target().model(SDK.OverlayModel);
     this._resourceTreeModel = screenCaptureModel.target().model(SDK.ResourceTreeModel);
     this._networkManager = screenCaptureModel.target().model(SDK.NetworkManager);
     this._inputModel = screenCaptureModel.target().model(Screencast.InputModel);
 
     this.setMinimumSize(150, 150);
     this.registerRequiredCSS('screencast/screencastView.css');
   }
 
   initialize() {
     this.element.classList.add('screencast');
@@ skipping 71 matching lines @@
       return;
     }
     dimensions.width *= window.devicePixelRatio;
     dimensions.height *= window.devicePixelRatio;
     // Note: startScreencast width and height are expected to be integers so must be floored.
     this._screenCaptureModel.startScreencast(
         'jpeg', 80, Math.floor(Math.min(maxImageDimension, dimensions.width)),
         Math.floor(Math.min(maxImageDimension, dimensions.height)), undefined, this._screencastFrame.bind(this),
         this._screencastVisibilityChanged.bind(this));
     Emulation.MultitargetTouchModel.instance().setCustomTouchEnabled(true);
-    if (this._domModel)
-      this._domModel.setHighlighter(this);
+    if (this._overlayModel)
+      this._overlayModel.setHighlighter(this);
   }
 
   _stopCasting() {
     if (!this._isCasting)
       return;
     this._isCasting = false;
     this._screenCaptureModel.stopScreencast();
     Emulation.MultitargetTouchModel.instance().setCustomTouchEnabled(false);
-    if (this._domModel)
-      this._domModel.setHighlighter(null);
+    if (this._overlayModel)
+      this._overlayModel.setHighlighter(null);
   }
 
   /**
    * @param {string} base64Data
    * @param {!Protocol.Page.ScreencastFrameMetadata} metadata
    */
   _screencastFrame(base64Data, metadata) {
     this._imageElement.onload = () => {
       this._pageScaleFactor = metadata.pageScaleFactor;
       this._screenOffsetTop = metadata.offsetTop;
@@ skipping 83 matching lines @@
 
     /**
      * @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);
+        this._domModel.overlayModel().nodeHighlightRequested(node.id);
       } else if (event.type === 'click') {
         Common.Revealer.reveal(node);
       }
     }
   }
 
   /**
    * @param {!Event} event
    */
   _handleKeyEvent(event) {
@@ skipping 50 matching lines @@
       delete this._deferredCasting;
     }
 
     this._stopCasting();
     this._deferredCasting = setTimeout(this._startCasting.bind(this), 100);
   }
 
   /**
    * @override
    * @param {?SDK.DOMNode} node
-   * @param {?Protocol.DOM.HighlightConfig} config
+   * @param {?Protocol.Overlay.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;
@@ skipping 232 matching lines @@
   _viewportDimensions() {
     const gutterSize = 30;
     const bordersSize = Screencast.ScreencastView._bordersSize;
     var width = this.element.offsetWidth - bordersSize - gutterSize;
     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
+   * @param {!Protocol.Overlay.InspectMode} mode
+   * @param {!Protocol.Overlay.HighlightConfig} config
+   * @return {!Promise}
    */
-  setInspectMode(mode, config, callback) {
-    this._inspectModeConfig = mode !== Protocol.DOM.InspectMode.None ? config : null;
-    if (callback)
-      callback(null);
+  setInspectMode(mode, config) {
+    this._inspectModeConfig = mode !== Protocol.Overlay.InspectMode.None ? config : null;
+    return Promise.resolve();
   }
 
   /**
    * @override
    * @param {!Protocol.Page.FrameId} frameId
    */
   highlightFrame(frameId) {
   }
 
   /**
@@ skipping 177 matching lines @@
     if (this._maxDisplayedProgress >= progress)
       return;
     this._maxDisplayedProgress = progress;
     this._displayProgress(progress);
   }
 
   _displayProgress(progress) {
     this._element.style.width = (100 * progress) + '%';
   }
 };