Put Scene class into scene namespace.

chrome/browser/resources/vr_shell/vr_shell_ui.js

 // Copyright 2016 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.
 
 var vrShellUi = (function() {
   'use strict';
 
-  let scene = new ui.Scene();
-  let sceneManager;
+  let ui = new scene.Scene();
+  let uiManager;
 
   let uiRootElement = document.querySelector('#ui');
   let uiStyle = window.getComputedStyle(uiRootElement);
   /** @const */ var ANIM_DURATION = 150;
 
   // This value should match the one in VrShellImpl.java
   /** @const */ var UI_DPR = 1.2;
 
   function getStyleFloat(style, property) {
     let value = parseFloat(style.getPropertyValue(property));
@@ skipping 11 matching lines @@
       /** @const */ this.SCREEN_RATIO = 16 / 9;
       /** @const */ this.BROWSING_SCREEN_DISTANCE = 2.0;
       /** @const */ this.FULLSCREEN_DISTANCE = 3.0;
 
       let element = new api.UiElement(0, 0, 0, 0);
       element.setIsContentQuad();
       element.setVisible(false);
       element.setSize(
           this.SCREEN_HEIGHT * this.SCREEN_RATIO, this.SCREEN_HEIGHT);
       element.setTranslation(0, 0, -this.BROWSING_SCREEN_DISTANCE);
-      this.elementId = scene.addElement(element);
+      this.elementId = ui.addElement(element);
     }
 
     setEnabled(enabled) {
       let update = new api.UiElementUpdate();
       update.setVisible(enabled);
-      scene.updateElement(this.elementId, update);
+      ui.updateElement(this.elementId, update);
     }
 
     setFullscreen(enabled) {
       let anim = new api.Animation(this.elementId, ANIM_DURATION);
       if (enabled) {
         anim.setTranslation(0, 0, -this.FULLSCREEN_DISTANCE);
       } else {
         anim.setTranslation(0, 0, -this.BROWSING_SCREEN_DISTANCE);
       }
-      scene.addAnimation(anim);
+      ui.addAnimation(anim);
     }
 
     // TODO(crbug/643815): Add a method setting aspect ratio (and possible
     // animation of changing it).
 
     getElementId() {
       return this.elementId;
     }
   };
 
@@ skipping 10 matching lines @@
 
       let element = new api.UiElement(pixelX, pixelY, pixelWidth, pixelHeight);
       element.setSize(pixelWidth / 1000, pixelHeight / 1000);
 
       // Pull additional custom properties from CSS.
       let style = window.getComputedStyle(domElement);
       element.setTranslation(
           getStyleFloat(style, '--tranX'), getStyleFloat(style, '--tranY'),
           getStyleFloat(style, '--tranZ'));
 
-      this.uiElementId = scene.addElement(element);
+      this.uiElementId = ui.addElement(element);
       this.uiAnimationId = -1;
       this.domElement = domElement;
     }
   };
 
   class RoundButton extends DomUiElement {
     constructor(domId, callback) {
       super(domId);
 
       let button = this.domElement.querySelector('.button');
       button.addEventListener('mouseenter', this.onMouseEnter.bind(this));
       button.addEventListener('mouseleave', this.onMouseLeave.bind(this));
       button.addEventListener('click', callback);
     }
 
     configure(buttonOpacity, captionOpacity, distanceForward) {
       let button = this.domElement.querySelector('.button');
       let caption = this.domElement.querySelector('.caption');
       button.style.opacity = buttonOpacity;
       caption.style.opacity = captionOpacity;
       let anim = new api.Animation(this.uiElementId, ANIM_DURATION);
       anim.setTranslation(0, 0, distanceForward);
       if (this.uiAnimationId >= 0) {
-        scene.removeAnimation(this.uiAnimationId);
+        ui.removeAnimation(this.uiAnimationId);
       }
-      this.uiAnimationId = scene.addAnimation(anim);
-      scene.flush();
+      this.uiAnimationId = ui.addAnimation(anim);
+      ui.flush();
     }
 
     onMouseEnter() {
       this.configure(1, 1, 0.015);
     }
 
     onMouseLeave() {
       this.configure(0.8, 0, 0);
     }
   };
@@ skipping 26 matching lines @@
       ];
 
       /** @const */ var BUTTON_SPACING = 0.136;
 
       let startPosition = -BUTTON_SPACING * (descriptors.length / 2.0 - 0.5);
       for (let i = 0; i < descriptors.length; i++) {
         // Use an invisible parent to simplify Z-axis movement on hover.
         let position = new api.UiElement(0, 0, 0, 0);
         position.setVisible(false);
         position.setTranslation(startPosition + i * BUTTON_SPACING, -0.68, -1);
-        let id = scene.addElement(position);
+        let id = ui.addElement(position);
 
         let domId = descriptors[i][0];
         let callback = descriptors[i][1];
         let element = new RoundButton(domId, callback);
         this.buttons.push(element);
 
         let update = new api.UiElementUpdate();
         update.setParentId(id);
         update.setVisible(false);
-        scene.updateElement(element.uiElementId, update);
+        ui.updateElement(element.uiElementId, update);
       }
 
       this.reloadUiButton = new DomUiElement('#reload-ui-button');
       this.reloadUiButton.domElement.addEventListener('click', function() {
-        scene.purge();
+        ui.purge();
         api.doAction(api.Action.RELOAD_UI);
       });
 
       let update = new api.UiElementUpdate();
       update.setParentId(contentQuadId);
       update.setVisible(false);
       update.setScale(2.2, 2.2, 1);
       update.setTranslation(0, -0.6, 0.3);
       update.setAnchoring(api.XAnchoring.XNONE, api.YAnchoring.YBOTTOM);
-      scene.updateElement(this.reloadUiButton.uiElementId, update);
+      ui.updateElement(this.reloadUiButton.uiElementId, update);
     }
 
     setEnabled(enabled) {
       this.enabled = enabled;
       this.configure();
     }
 
     setReloadUiEnabled(enabled) {
       this.reloadUiEnabled = enabled;
       this.configure();
     }
 
     configure() {
       for (let i = 0; i < this.buttons.length; i++) {
         let update = new api.UiElementUpdate();
         update.setVisible(this.enabled);
-        scene.updateElement(this.buttons[i].uiElementId, update);
+        ui.updateElement(this.buttons[i].uiElementId, update);
       }
       let update = new api.UiElementUpdate();
       update.setVisible(this.enabled && this.reloadUiEnabled);
-      scene.updateElement(this.reloadUiButton.uiElementId, update);
+      ui.updateElement(this.reloadUiButton.uiElementId, update);
     }
   };
 
   class SecureOriginWarnings {
     constructor() {
       /** @const */ var DISTANCE = 0.7;
       /** @const */ var ANGLE_UP = 16.3 * Math.PI / 180.0;
 
       this.enabled = false;
       this.secure = false;
       this.secureOriginTimer = null;
 
       // Permanent WebVR security warning. This warning is shown near the top of
       // the field of view.
       this.webVrSecureWarning = new DomUiElement('#webvr-not-secure-permanent');
       let update = new api.UiElementUpdate();
       update.setScale(DISTANCE, DISTANCE, 1);
       update.setTranslation(
           0, DISTANCE * Math.sin(ANGLE_UP), -DISTANCE * Math.cos(ANGLE_UP));
       update.setRotation(1.0, 0.0, 0.0, ANGLE_UP);
       update.setHitTestable(false);
       update.setVisible(false);
       update.setLockToFieldOfView(true);
-      scene.updateElement(this.webVrSecureWarning.uiElementId, update);
+      ui.updateElement(this.webVrSecureWarning.uiElementId, update);
 
       // Temporary WebVR security warning. This warning is shown in the center
       // of the field of view, for a limited period of time.
       this.transientWarning = new DomUiElement('#webvr-not-secure-transient');
       update = new api.UiElementUpdate();
       update.setScale(DISTANCE, DISTANCE, 1);
       update.setTranslation(0, 0, -DISTANCE);
       update.setHitTestable(false);
       update.setVisible(false);
       update.setLockToFieldOfView(true);
-      scene.updateElement(this.transientWarning.uiElementId, update);
+      ui.updateElement(this.transientWarning.uiElementId, update);
     }
 
     setEnabled(enabled) {
       this.enabled = enabled;
       this.updateState();
     }
 
     setSecure(secure) {
       this.secure = secure;
       this.updateState();
@@ skipping 10 matching lines @@
       if (visible) {
         this.secureOriginTimer =
             setTimeout(this.onTransientTimer.bind(this), TRANSIENT_TIMEOUT_MS);
       }
       this.showOrHideWarnings(visible);
     }
 
     showOrHideWarnings(visible) {
       let update = new api.UiElementUpdate();
       update.setVisible(visible);
-      scene.updateElement(this.webVrSecureWarning.uiElementId, update);
+      ui.updateElement(this.webVrSecureWarning.uiElementId, update);
       update = new api.UiElementUpdate();
       update.setVisible(visible);
-      scene.updateElement(this.transientWarning.uiElementId, update);
+      ui.updateElement(this.transientWarning.uiElementId, update);
     }
 
     onTransientTimer() {
       let update = new api.UiElementUpdate();
       update.setVisible(false);
-      scene.updateElement(this.transientWarning.uiElementId, update);
+      ui.updateElement(this.transientWarning.uiElementId, update);
       this.secureOriginTimer = null;
-      scene.flush();
+      ui.flush();
     }
   };
 
   class Omnibox {
     constructor(contentQuadId) {
       this.domUiElement = new DomUiElement('#omnibox-container');
       this.enabled = false;
       this.loading = false;
       this.loadingProgress = 0;
       this.level = 0;
       this.visibilityTimeout = 0;
       this.visibilityTimer = null;
       this.visibleAfterTransition = false;
       this.nativeState = {};
 
       // Initially invisible.
       let update = new api.UiElementUpdate();
       update.setVisible(false);
-      scene.updateElement(this.domUiElement.uiElementId, update);
+      ui.updateElement(this.domUiElement.uiElementId, update);
       this.nativeState.visible = false;
 
       // Pull colors from CSS so that Javascript can set the progress indicator
       // gradient programmatically.
       let border =
           this.domUiElement.domElement.querySelector('#omnibox-border');
       let style = window.getComputedStyle(border);
       this.statusBarColor = getStyleString(style, '--statusBarColor');
       this.backgroundColor = style.backgroundColor;
 
@@ skipping 118 matching lines @@
       this.setNativeVisibility(true);
     }
 
     setNativeVisibility(visible) {
       if (visible == this.nativeState.visible) {
         return;
       }
       this.nativeState.visible = visible;
       let update = new api.UiElementUpdate();
       update.setVisible(visible);
-      scene.updateElement(this.domUiElement.uiElementId, update);
-      scene.flush();
+      ui.updateElement(this.domUiElement.uiElementId, update);
+      ui.flush();
     }
   };
 
-  class SceneManager {
+  class UiManager {
     constructor() {
       this.mode = api.Mode.UNKNOWN;
       this.menuMode = false;
       this.fullscreen = false;
 
       this.contentQuad = new ContentQuad();
       let contentId = this.contentQuad.getElementId();
 
       this.controls = new Controls(contentId);
       this.secureOriginWarnings = new SecureOriginWarnings();
@@ skipping 31 matching lines @@
     setWebVRSecureOrigin(secure) {
       this.secureOriginWarnings.setSecure(secure);
     }
 
     setReloadUiEnabled(enabled) {
       this.controls.setReloadUiEnabled(enabled);
     }
   };
 
   function initialize() {
-    sceneManager = new SceneManager();
-    scene.flush();
+    uiManager = new UiManager();
+    ui.flush();
 
     api.domLoaded();
   }
 
   function command(dict) {
     if ('mode' in dict) {
-      sceneManager.setMode(dict['mode'], dict['menuMode'], dict['fullscreen']);
+      uiManager.setMode(dict['mode'], dict['menuMode'], dict['fullscreen']);
     }
     if ('securityLevel' in dict) {
-      sceneManager.setSecurityLevel(dict['securityLevel']);
+      uiManager.setSecurityLevel(dict['securityLevel']);
     }
     if ('webVRSecureOrigin' in dict) {
-      sceneManager.setWebVRSecureOrigin(dict['webVRSecureOrigin']);
+      uiManager.setWebVRSecureOrigin(dict['webVRSecureOrigin']);
     }
     if ('enableReloadUi' in dict) {
-      sceneManager.setReloadUiEnabled(dict['enableReloadUi']);
+      uiManager.setReloadUiEnabled(dict['enableReloadUi']);
     }
     if ('url' in dict) {
       let url = dict['url'];
-      sceneManager.omnibox.setURL(url['host'], url['path']);
+      uiManager.omnibox.setURL(url['host'], url['path']);
     }
     if ('loading' in dict) {
-      sceneManager.omnibox.setLoading(dict['loading']);
+      uiManager.omnibox.setLoading(dict['loading']);
     }
     if ('loadingProgress' in dict) {
-      sceneManager.omnibox.setLoadingProgress(dict['loadingProgress']);
+      uiManager.omnibox.setLoadingProgress(dict['loadingProgress']);
     }
-    scene.flush();
+    ui.flush();
   }
 
   return {
     initialize: initialize,
     command: command,
   };
 })();
 
 document.addEventListener('DOMContentLoaded', vrShellUi.initialize);