[DevTools] Introduce EmulationModel which will encapsulate emulation

third_party/WebKit/Source/devtools/front_end/emulation/SensorsView.js

 // Copyright (c) 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 /**
  * @unrestricted
  */
 Emulation.SensorsView = class extends UI.VBox {
   constructor() {
     super(true);
     this.registerRequiredCSS('emulation/sensors.css');
     this.contentElement.classList.add('sensors-view');
 
     this._geolocationSetting = Common.settings.createSetting('emulation.geolocationOverride', '');
-    this._geolocation = Emulation.Geolocation.parseSetting(this._geolocationSetting.get());
+    this._geolocation = SDK.EmulationModel.Geolocation.parseSetting(this._geolocationSetting.get());
     this._geolocationOverrideEnabled = false;
     this._createGeolocationSection(this._geolocation);
 
     this.contentElement.createChild('div').classList.add('panel-section-separator');
 
     this._deviceOrientationSetting = Common.settings.createSetting('emulation.deviceOrientationOverride', '');
-    this._deviceOrientation = Emulation.DeviceOrientation.parseSetting(this._deviceOrientationSetting.get());
+    this._deviceOrientation = SDK.EmulationModel.DeviceOrientation.parseSetting(this._deviceOrientationSetting.get());
     this._deviceOrientationOverrideEnabled = false;
     this._createDeviceOrientationSection();
 
     this.contentElement.createChild('div').classList.add('panel-section-separator');
 
     this._appendTouchControl();
   }
 
   /**
    * @return {!Emulation.SensorsView}
    */
   static instance() {
     if (!Emulation.SensorsView._instanceObject)
       Emulation.SensorsView._instanceObject = new Emulation.SensorsView();
     return Emulation.SensorsView._instanceObject;
   }
 
   /**
-   * @param {!Emulation.Geolocation} geolocation
+   * @param {!SDK.EmulationModel.Geolocation} geolocation
    */
   _createGeolocationSection(geolocation) {
     var geogroup = this.contentElement.createChild('section', 'sensors-group');
     geogroup.createChild('div', 'sensors-group-title').textContent = Common.UIString('Geolocation');
     var fields = geogroup.createChild('div', 'geo-fields');
 
     const noOverrideOption = {
       title: Common.UIString('No override'),
       location: Emulation.SensorsView.NonPresetOptions.NoOverride
     };
@@ skipping 22 matching lines @@
     this._fieldsetElement.disabled = !this._geolocationOverrideEnabled;
     this._fieldsetElement.id = 'geolocation-override-section';
 
     var latitudeGroup = this._fieldsetElement.createChild('div', 'latlong-group');
     var longitudeGroup = this._fieldsetElement.createChild('div', 'latlong-group');
 
     this._latitudeInput = latitudeGroup.createChild('input');
     this._latitudeInput.setAttribute('type', 'number');
     this._latitudeInput.value = 0;
     this._latitudeSetter = UI.bindInput(
-        this._latitudeInput, this._applyGeolocationUserInput.bind(this), Emulation.Geolocation.latitudeValidator, true);
+        this._latitudeInput, this._applyGeolocationUserInput.bind(this),
+        SDK.EmulationModel.Geolocation.latitudeValidator, true);
     this._latitudeSetter(String(geolocation.latitude));
 
     this._longitudeInput = longitudeGroup.createChild('input');
     this._longitudeInput.setAttribute('type', 'number');
     this._longitudeInput.value = 0;
     this._longitudeSetter = UI.bindInput(
-        this._longitudeInput, this._applyGeolocationUserInput.bind(this), Emulation.Geolocation.longitudeValidator,
-        true);
+        this._longitudeInput, this._applyGeolocationUserInput.bind(this),
+        SDK.EmulationModel.Geolocation.longitudeValidator, true);
     this._longitudeSetter(String(geolocation.longitude));
 
     latitudeGroup.createChild('div', 'latlong-title').textContent = Common.UIString('Latitude');
     longitudeGroup.createChild('div', 'latlong-title').textContent = Common.UIString('Longitude');
   }
 
   _geolocationSelectChanged() {
     this._fieldsetElement.disabled = false;
     var value = this._locationSelectElement.options[this._locationSelectElement.selectedIndex].value;
     if (value === Emulation.SensorsView.NonPresetOptions.NoOverride) {
       this._geolocationOverrideEnabled = false;
       this._fieldsetElement.disabled = true;
     } else if (value === Emulation.SensorsView.NonPresetOptions.Custom) {
       this._geolocationOverrideEnabled = true;
     } else if (value === Emulation.SensorsView.NonPresetOptions.Unavailable) {
       this._geolocationOverrideEnabled = true;
-      this._geolocation = new Emulation.Geolocation(0, 0, true);
+      this._geolocation = new SDK.EmulationModel.Geolocation(0, 0, true);
     } else {
       this._geolocationOverrideEnabled = true;
       var coordinates = JSON.parse(value);
-      this._geolocation = new Emulation.Geolocation(coordinates[0], coordinates[1], false);
+      this._geolocation = new SDK.EmulationModel.Geolocation(coordinates[0], coordinates[1], false);
       this._latitudeSetter(coordinates[0]);
       this._longitudeSetter(coordinates[1]);
     }
 
     this._applyGeolocation();
     if (value === Emulation.SensorsView.NonPresetOptions.Custom)
       this._latitudeInput.focus();
   }
 
   _applyGeolocationUserInput() {
-    var geolocation =
-        Emulation.Geolocation.parseUserInput(this._latitudeInput.value.trim(), this._longitudeInput.value.trim(), '');
+    var geolocation = SDK.EmulationModel.Geolocation.parseUserInput(
+        this._latitudeInput.value.trim(), this._longitudeInput.value.trim(), '');
     if (!geolocation)
       return;
 
     this._setSelectElementLabel(this._locationSelectElement, Emulation.SensorsView.NonPresetOptions.Custom);
     this._geolocation = geolocation;
     this._applyGeolocation();
   }
 
   _applyGeolocation() {
-    if (this._geolocationOverrideEnabled) {
+    if (this._geolocationOverrideEnabled)
       this._geolocationSetting.set(this._geolocation.toSetting());
-      this._geolocation.apply();
-    } else {
-      this._geolocation.clear();
-    }
+    for (var emulationModel of SDK.targetManager.models(SDK.EmulationModel))
+      emulationModel.emulateGeolocation(this._geolocationOverrideEnabled ? this._geolocation : null);
   }
 
   _createDeviceOrientationSection() {
     var orientationGroup = this.contentElement.createChild('section', 'sensors-group');
     orientationGroup.createChild('div', 'sensors-group-title').textContent = Common.UIString('Orientation');
     var orientationContent = orientationGroup.createChild('div', 'orientation-content');
     var fields = orientationContent.createChild('div', 'orientation-fields');
 
     const orientationOffOption = {
       title: Common.UIString('Off'),
@@ skipping 63 matching lines @@
 
     if (value === Emulation.SensorsView.NonPresetOptions.NoOverride) {
       this._deviceOrientationOverrideEnabled = false;
       this._enableOrientationFields(true);
     } else if (value === Emulation.SensorsView.NonPresetOptions.Custom) {
       this._deviceOrientationOverrideEnabled = true;
       this._alphaElement.focus();
     } else {
       var parsedValue = JSON.parse(value);
       this._deviceOrientationOverrideEnabled = true;
-      this._deviceOrientation = new Emulation.DeviceOrientation(parsedValue[0], parsedValue[1], parsedValue[2]);
+      this._deviceOrientation =
+          new SDK.EmulationModel.DeviceOrientation(parsedValue[0], parsedValue[1], parsedValue[2]);
       this._setDeviceOrientation(
           this._deviceOrientation, Emulation.SensorsView.DeviceOrientationModificationSource.SelectPreset);
     }
   }
 
   _applyDeviceOrientation() {
-    if (this._deviceOrientationOverrideEnabled) {
+    if (this._deviceOrientationOverrideEnabled)
       this._deviceOrientationSetting.set(this._deviceOrientation.toSetting());
-      this._deviceOrientation.apply();
-    } else {
-      this._deviceOrientation.clear();
-    }
+    for (var emulationModel of SDK.targetManager.models(SDK.EmulationModel))
+      emulationModel.emulateDeviceOrientation(this._deviceOrientationOverrideEnabled ? this._deviceOrientation : null);
   }
 
   /**
    * @param {!Element} selectElement
    * @param {string} labelValue
    */
   _setSelectElementLabel(selectElement, labelValue) {
     var optionValues = Array.prototype.map.call(selectElement.options, x => x.value);
     selectElement.selectedIndex = optionValues.indexOf(labelValue);
   }
 
   _applyDeviceOrientationUserInput() {
     this._setDeviceOrientation(
-        Emulation.DeviceOrientation.parseUserInput(
+        SDK.EmulationModel.DeviceOrientation.parseUserInput(
             this._alphaElement.value.trim(), this._betaElement.value.trim(), this._gammaElement.value.trim()),
         Emulation.SensorsView.DeviceOrientationModificationSource.UserInput);
     this._setSelectElementLabel(this._orientationSelectElement, Emulation.SensorsView.NonPresetOptions.Custom);
   }
 
   _resetDeviceOrientation() {
     this._setDeviceOrientation(
-        new Emulation.DeviceOrientation(0, 90, 0),
+        new SDK.EmulationModel.DeviceOrientation(0, 90, 0),
         Emulation.SensorsView.DeviceOrientationModificationSource.ResetButton);
     this._setSelectElementLabel(this._orientationSelectElement, '[0, 90, 0]');
   }
 
   /**
-   * @param {?Emulation.DeviceOrientation} deviceOrientation
+   * @param {?SDK.EmulationModel.DeviceOrientation} deviceOrientation
    * @param {!Emulation.SensorsView.DeviceOrientationModificationSource} modificationSource
    */
   _setDeviceOrientation(deviceOrientation, modificationSource) {
     if (!deviceOrientation)
       return;
 
     /**
      * @param {number} angle
      * @return {number}
      */
@@ skipping 19 matching lines @@
    * @param {!Element} input
    * @param {string} label
    * @return {function(string)}
    */
   _createAxisInput(parentElement, input, label) {
     var div = parentElement.createChild('div', 'orientation-axis-input-container');
     div.appendChild(input);
     div.createTextChild(label);
     input.type = 'number';
     return UI.bindInput(
-        input, this._applyDeviceOrientationUserInput.bind(this), Emulation.DeviceOrientation.validator, true);
+        input, this._applyDeviceOrientationUserInput.bind(this), SDK.EmulationModel.DeviceOrientation.validator, true);
   }
 
   /**
-   * @param {!Emulation.DeviceOrientation} deviceOrientation
+   * @param {!SDK.EmulationModel.DeviceOrientation} deviceOrientation
    * @return {!Element}
    */
   _createDeviceOrientationOverrideElement(deviceOrientation) {
     var fieldsetElement = createElement('fieldset');
     fieldsetElement.classList.add('device-orientation-override-section');
     var cellElement = fieldsetElement.createChild('td', 'orientation-inputs-cell');
 
     this._alphaElement = createElement('input');
     this._alphaSetter = this._createAxisInput(cellElement, this._alphaElement, Common.UIString('\u03B1 (alpha)'));
     this._alphaSetter(String(deviceOrientation.alpha));
 
     this._betaElement = createElement('input');
     this._betaSetter = this._createAxisInput(cellElement, this._betaElement, Common.UIString('\u03B2 (beta)'));
     this._betaSetter(String(deviceOrientation.beta));
 
     this._gammaElement = createElement('input');
     this._gammaSetter = this._createAxisInput(cellElement, this._gammaElement, Common.UIString('\u03B3 (gamma)'));
     this._gammaSetter(String(deviceOrientation.gamma));
 
     cellElement.appendChild(UI.createTextButton(
         Common.UIString('Reset'), this._resetDeviceOrientation.bind(this), 'orientation-reset-button'));
     return fieldsetElement;
   }
 
   /**
-   * @param {!Emulation.DeviceOrientation} deviceOrientation
+   * @param {!SDK.EmulationModel.DeviceOrientation} deviceOrientation
    * @param {boolean} animate
    */
   _setBoxOrientation(deviceOrientation, animate) {
     if (animate)
       this._stageElement.classList.add('is-animating');
     else
       this._stageElement.classList.remove('is-animating');
 
     // The CSS transform should not depend on matrix3d, which does not interpolate well.
     var matrix = new WebKitCSSMatrix();
@@ skipping 24 matching lines @@
 
     // The mouse movement vectors occur in the screen space, which is offset by 90 degrees from
     // the actual device orientation.
     var currentMatrix = new WebKitCSSMatrix();
     currentMatrix = currentMatrix.rotate(-90, 0, 0)
                         .rotateAxisAngle(axis.x, axis.y, axis.z, angle)
                         .rotate(90, 0, 0)
                         .multiply(this._originalBoxMatrix);
 
     var eulerAngles = UI.Geometry.EulerAngles.fromRotationMatrix(currentMatrix);
-    var newOrientation = new Emulation.DeviceOrientation(-eulerAngles.alpha, -eulerAngles.beta, eulerAngles.gamma);
+    var newOrientation =
+        new SDK.EmulationModel.DeviceOrientation(-eulerAngles.alpha, -eulerAngles.beta, eulerAngles.gamma);
     this._setDeviceOrientation(newOrientation, Emulation.SensorsView.DeviceOrientationModificationSource.UserDrag);
     this._setSelectElementLabel(this._orientationSelectElement, Emulation.SensorsView.NonPresetOptions.Custom);
     return false;
   }
 
   /**
    * @param {!MouseEvent} event
    * @return {boolean}
    */
   _onBoxDragStart(event) {
@@ skipping 32 matching lines @@
     var title = groupElement.createChild('div', 'sensors-group-title');
     var fieldsElement = groupElement.createChild('div', 'sensors-group-fields');
 
     title.textContent = Common.UIString('Touch');
     var select = fieldsElement.createChild('select', 'chrome-select');
     select.appendChild(new Option(Common.UIString('Device-based'), 'auto'));
     select.appendChild(new Option(Common.UIString('Force enabled'), 'enabled'));
     select.addEventListener('change', applyTouch, false);
 
     function applyTouch() {
-      Emulation.MultitargetTouchModel.instance().setCustomTouchEnabled(select.value === 'enabled');
+      for (var emulationModel of SDK.targetManager.models(SDK.EmulationModel))
+        emulationModel.overrideEmulateTouch(select.value === 'enabled');
     }
   }
 };
 
 /** @enum {string} */
 Emulation.SensorsView.DeviceOrientationModificationSource = {
   UserInput: 'userInput',
   UserDrag: 'userDrag',
   ResetButton: 'resetButton',
   SelectPreset: 'selectPreset'
@@ skipping 23 matching lines @@
     ]
   },
   {
     title: 'Error',
     value: [
       {title: Common.UIString('Location unavailable'), location: Emulation.SensorsView.NonPresetOptions.Unavailable}
     ]
   }
 ];
 
-/** @type {!Array.<{title: string, value: !Array.<{title: string, orientation: !Emulation.DeviceOrientation}>}>} */
+/** @type {!Array.<{title: string, value: !Array.<{title: string, orientation: string}>}>} */
 Emulation.SensorsView.PresetOrientations = [{
   title: 'Presets',
   value: [
     {title: Common.UIString('Portrait'), orientation: '[0, 90, 0]'},
     {title: Common.UIString('Portrait upside down'), orientation: '[180, -90, 0]'},
     {title: Common.UIString('Landscape left'), orientation: '[0, 90, -90]'},
     {title: Common.UIString('Landscape right'), orientation: '[0, 90, 90]'},
     {title: Common.UIString('Display up'), orientation: '[0, 0, 0]'},
     {title: Common.UIString('Display down'), orientation: '[0, 180, 0]'}
   ]
@@ skipping 11 matching lines @@
    * @param {string} actionId
    * @return {boolean}
    */
   handleAction(context, actionId) {
     UI.viewManager.showView('sensors');
     return true;
   }
 };
 
 Emulation.SensorsView.ShiftDragOrientationSpeed = 16;