VR: Factor transient timing out of UiSceneManager.

chrome/browser/android/vr_shell/ui_scene_manager.cc

 // Copyright 2017 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.
 
 #include "chrome/browser/android/vr_shell/ui_scene_manager.h"
 
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
 #include "chrome/browser/android/vr_shell/textures/close_button_texture.h"
 #include "chrome/browser/android/vr_shell/textures/ui_texture.h"
@@ skipping 120 matching lines @@
 
 UiSceneManager::UiSceneManager(UiBrowserInterface* browser,
                                UiScene* scene,
                                bool in_cct,
                                bool in_web_vr,
                                bool web_vr_autopresentation_expected)
     : browser_(browser),
       scene_(scene),
       in_cct_(in_cct),
       web_vr_mode_(in_web_vr),
+      web_vr_autopresentation_(web_vr_autopresentation_expected),
       web_vr_autopresentation_expected_(web_vr_autopresentation_expected),
       weak_ptr_factory_(this) {
   CreateSplashScreen();
   CreateBackground();
   CreateContentQuad();
   CreateSecurityWarnings();
   CreateSystemIndicators();
   CreateUrlBar();
   CreateTransientUrlBar();
   CreateCloseButton();
   CreateScreenDimmer();
   CreateExitPrompt();
   CreateToasts();
 
   ConfigureScene();
-  ConfigureSecurityWarnings();
 }
 
 UiSceneManager::~UiSceneManager() {}
 
 void UiSceneManager::CreateScreenDimmer() {
   std::unique_ptr<UiElement> element;
   element = base::MakeUnique<ScreenDimmer>();
   element->set_debug_id(kScreenDimmer);
   element->set_id(AllocateId());
   element->set_fill(vr_shell::Fill::NONE);
@@ skipping 19 matching lines @@
       gfx::Vector3dF(0, kWarningDistance * sin(kWarningAngleRadians),
                      -kWarningDistance * cos(kWarningAngleRadians)));
   element->set_rotation(
       gfx::Quaternion(gfx::Vector3dF(1, 0, 0), kWarningAngleRadians));
   element->set_visible(false);
   element->set_hit_testable(false);
   element->set_lock_to_fov(true);
   permanent_security_warning_ = element.get();
   scene_->AddUiElement(std::move(element));
 
-  element = base::MakeUnique<TransientSecurityWarning>(1024);
+  auto transient_warning = base::MakeUnique<TransientSecurityWarning>(
+      1024, base::TimeDelta::FromSeconds(kWarningTimeoutSeconds));
+  transient_security_warning_ = transient_warning.get();
+  element = std::move(transient_warning);
   element->set_debug_id(kWebVrTransientHttpSecurityWarning);
   element->set_id(AllocateId());
   element->set_fill(vr_shell::Fill::NONE);
   element->set_size({kTransientWarningWidth, kTransientWarningHeight, 1});
   element->set_scale({kWarningDistance, kWarningDistance, 1});
   element->set_translation({0, 0, -kWarningDistance});
   element->set_visible(false);
   element->set_hit_testable(false);
   element->set_lock_to_fov(true);
-  transient_security_warning_ = element.get();
   scene_->AddUiElement(std::move(element));
 
   element = base::MakeUnique<ExitWarning>(1024);
   element->set_debug_id(kExitWarning);
   element->set_id(AllocateId());
   element->set_fill(vr_shell::Fill::NONE);
   element->set_size({kExitWarningWidth, kExitWarningHeight, 1});
   element->set_scale({kExitWarningDistance, kExitWarningDistance, 1});
   element->set_translation({0, 0, -kExitWarningDistance});
   element->set_visible(false);
@@ skipping 145 matching lines @@
   indicator->set_size({kLoadingIndicatorWidth, kLoadingIndicatorHeight, 1});
   indicator->set_parent_id(url_bar_->id());
   indicator->set_y_anchoring(YAnchoring::YTOP);
   loading_indicator_ = indicator.get();
   control_elements_.push_back(indicator.get());
   scene_->AddUiElement(std::move(indicator));
 }
 
 void UiSceneManager::CreateTransientUrlBar() {
   auto url_bar = base::MakeUnique<TransientUrlBar>(
-      512,
+      512, base::TimeDelta::FromSeconds(kTransientUrlBarTimeoutSeconds),
       base::Bind(&UiSceneManager::OnUnsupportedMode, base::Unretained(this)));
   url_bar->set_debug_id(kTransientUrlBar);
   url_bar->set_id(AllocateId());
   url_bar->set_lock_to_fov(true);
   url_bar->set_visible(false);
   url_bar->set_hit_testable(false);
   url_bar->set_translation(
       {0, kTransientUrlBarVerticalOffset, -kTransientUrlBarDistance});
   url_bar->set_rotation(
       gfx::Quaternion(gfx::Vector3dF(1, 0, 0), kUrlBarRotationRad));
@@ skipping 43 matching lines @@
   element->set_fill(vr_shell::Fill::NONE);
   element->set_size({kExitPromptBackplaneSize, kExitPromptBackplaneSize, 1.0});
   element->set_translation({0.0, 0.0, -kTextureOffset});
   element->set_parent_id(exit_prompt_->id());
   exit_prompt_backplane_ = element.get();
   content_elements_.push_back(element.get());
   scene_->AddUiElement(std::move(element));
 }
 
 void UiSceneManager::CreateToasts() {
-  std::unique_ptr<UiElement> element =
-      base::MakeUnique<ExclusiveScreenToast>(512);
+  auto element = base::MakeUnique<ExclusiveScreenToast>(
+      512, base::TimeDelta::FromSeconds(kToastTimeoutSeconds));
   element->set_debug_id(kExclusiveScreenToast);
   element->set_id(AllocateId());
   element->set_fill(vr_shell::Fill::NONE);
   element->set_size({kToastWidthDMM, kToastHeightDMM, 1});
   element->set_visible(false);
   element->set_hit_testable(false);
   exclusive_screen_toast_ = element.get();
   scene_->AddUiElement(std::move(element));
 }
 
 base::WeakPtr<UiSceneManager> UiSceneManager::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void UiSceneManager::SetWebVrMode(bool web_vr, bool show_toast) {
   if (web_vr_mode_ == web_vr && web_vr_show_toast_ == show_toast) {
     return;
   }
+
   web_vr_mode_ = web_vr;
-  ConfigureTransientUrlBar();
-  scene_->set_showing_splash_screen(false);
   web_vr_autopresentation_expected_ = false;
   web_vr_show_toast_ = show_toast;
-  toast_state_ = SET_FOR_WEB_VR;
+  if (!web_vr_mode_)
+    web_vr_autopresentation_ = false;
+  scene_->set_showing_splash_screen(false);
   ConfigureScene();
-  ConfigureSecurityWarnings();
-  ConfigureExclusiveScreenToast();
+
+  // Because we may be transitioning from and to fullscreen, where the toast is
+  // also shown, explicitly kick or end visibility here.
+  if (web_vr) {
+    exclusive_screen_toast_->transience()->KickVisibilityIfEnabled();
+  } else {
+    exclusive_screen_toast_->transience()->EndVisibilityIfEnabled();
+  }
 }
 
 void UiSceneManager::ConfigureScene() {
   // Splash screen.
   scene_->set_showing_splash_screen(web_vr_autopresentation_expected_);
-  splash_screen_icon_->SetEnabled(!web_vr_mode_ &&
-                                  web_vr_autopresentation_expected_);
+  splash_screen_icon_->SetEnabled(web_vr_autopresentation_expected_);
 
   // Exit warning.
   exit_warning_->SetEnabled(scene_->is_exiting());
   screen_dimmer_->SetEnabled(scene_->is_exiting());
 
   bool browsing_mode = !web_vr_mode_ && !scene_->showing_splash_screen();
 
   // Controls (URL bar, loading progress, etc).
   bool controls_visible = browsing_mode && !fullscreen_;
   for (UiElement* element : control_elements_) {
@@ skipping 42 matching lines @@
                        -kCloseButtonDistance));
     close_button_->set_size(
         gfx::Vector3dF(kCloseButtonWidth, kCloseButtonHeight, 1));
   }
 
   scene_->SetMode(mode());
   scene_->SetBackgroundDistance(main_content_->translation().z() *
                                 -kBackgroundDistanceMultiplier);
   UpdateBackgroundColor();
 
-  // Configure other subsystems here as well. Ultimately, it would be nice if we
-  // could configure all elements through ConfigureScene(), as the exact
-  // conditions that control each element are getting complicated. More systems
-  // should move in here, such that a single method call can update the entire
-  // scene. The drawback is slightly more overhead for individual scene
-  // reconfigurations.
+  transient_url_bar_->SetEnabled(web_vr_autopresentation_ &&
+                                 !scene_->showing_splash_screen());
+
+  ConfigureExclusiveScreenToast();
+  ConfigureSecurityWarnings();
   ConfigureIndicators();
 }
 
 void UiSceneManager::UpdateBackgroundColor() {
   // TODO(vollick): it would be nice if ceiling, floor and the grid were
   // UiElement subclasses and could respond to the OnSetMode signal.
   ceiling_->set_center_color(color_scheme().ceiling);
   ceiling_->set_edge_color(color_scheme().world_background);
   floor_->set_center_color(color_scheme().floor);
   floor_->set_edge_color(color_scheme().world_background);
@@ skipping 24 matching lines @@
   location_access_ = enabled;
   ConfigureIndicators();
 }
 
 void UiSceneManager::SetBluetoothConnectedIndicator(bool enabled) {
   bluetooth_connected_ = enabled;
   ConfigureIndicators();
 }
 
 void UiSceneManager::SetWebVrSecureOrigin(bool secure) {
+  if (secure_origin_ == secure)
+    return;
   secure_origin_ = secure;
   ConfigureSecurityWarnings();
 }
 
 void UiSceneManager::SetIncognito(bool incognito) {
   if (incognito == incognito_)
     return;
   incognito_ = incognito;
   ConfigureScene();
 }
@@ skipping 10 matching lines @@
   browser_->ExitFullscreen();
 }
 
 void UiSceneManager::OnAppButtonGesturePerformed(
     UiInterface::Direction direction) {}
 
 void UiSceneManager::SetFullscreen(bool fullscreen) {
   if (fullscreen_ == fullscreen)
     return;
   fullscreen_ = fullscreen;
-  toast_state_ = SET_FOR_FULLSCREEN;
   ConfigureScene();
-  ConfigureExclusiveScreenToast();
 }
 
 void UiSceneManager::ConfigureSecurityWarnings() {
   bool enabled = web_vr_mode_ && !secure_origin_;
-  permanent_security_warning_->set_visible(enabled);
-  transient_security_warning_->set_visible(enabled);
-  if (enabled) {
-    security_warning_timer_.Start(
-        FROM_HERE, base::TimeDelta::FromSeconds(kWarningTimeoutSeconds), this,
-        &UiSceneManager::OnSecurityWarningTimer);
-  } else {
-    security_warning_timer_.Stop();
-  }
+  permanent_security_warning_->SetEnabled(enabled);
+  transient_security_warning_->SetEnabled(enabled);
 }
 
 void UiSceneManager::ConfigureIndicators() {
   bool allowed = !web_vr_mode_ && !fullscreen_;
   audio_capture_indicator_->set_visible(allowed && audio_capturing_);
   video_capture_indicator_->set_visible(allowed && video_capturing_);
   screen_capture_indicator_->set_visible(allowed && screen_capturing_);
   location_access_indicator_->set_visible(allowed && location_access_);
   bluetooth_connected_indicator_->set_visible(allowed && bluetooth_connected_);
 
@@ skipping 16 matching lines @@
       continue;
     float width = indicator->size().x();
     indicator->set_translation({x_position + width / 2,
                                 kIndicatorVerticalOffset,
                                 kIndicatorDistanceOffset});
     x_position += width + kIndicatorGap;
   }
 }
 
 void UiSceneManager::ConfigureExclusiveScreenToast() {
-  bool toast_visible = false;
-  switch (toast_state_) {
-    case SET_FOR_WEB_VR:
-      toast_visible = web_vr_show_toast_;
-      break;
-    case SET_FOR_FULLSCREEN:
-      toast_visible = fullscreen_;
-      break;
-    case UNCHANGED:
-      return;
-  }
+  exclusive_screen_toast_->SetEnabled((fullscreen_ && !web_vr_mode_) ||
+                                      (web_vr_mode_ && web_vr_show_toast_));
+
   if (fullscreen_ && !web_vr_mode_) {
     // Do not set size again. The size might have been changed by the backing
     // texture size in UpdateElementSize.
     exclusive_screen_toast_->set_scale(
         {kFullscreenToastDistance, kFullscreenToastDistance, 1});
     exclusive_screen_toast_->set_translation(
         {0,
          kFullscreenVerticalOffset + kFullscreenHeight / 2 +
              (kToastOffsetDMM + kToastHeightDMM) * kFullscreenToastDistance,
          -kFullscreenToastDistance});
     exclusive_screen_toast_->set_rotation(
         gfx::Quaternion(gfx::Vector3dF(1, 0, 0), 0.0));
     exclusive_screen_toast_->set_lock_to_fov(false);
   } else if (web_vr_mode_ && web_vr_show_toast_) {
     exclusive_screen_toast_->set_scale(
         {kWebVrToastDistance, kWebVrToastDistance, 1});
     exclusive_screen_toast_->set_translation(
         gfx::Vector3dF(0, kWebVrToastDistance * sin(kWebVrAngleRadians),
                        -kWebVrToastDistance * cos(kWebVrAngleRadians)));
     exclusive_screen_toast_->set_rotation(
         gfx::Quaternion(gfx::Vector3dF(1, 0, 0), kWebVrAngleRadians));
     exclusive_screen_toast_->set_lock_to_fov(true);
   }
-  exclusive_screen_toast_->set_visible(toast_visible);
-  if (toast_visible) {
-    exclusive_screen_toast_timer_.Start(
-        FROM_HERE, base::TimeDelta::FromSeconds(kToastTimeoutSeconds), this,
-        &UiSceneManager::OnExclusiveScreenToastTimer);
-  } else {
-    exclusive_screen_toast_timer_.Stop();
-  }
-  toast_state_ = UNCHANGED;
-}
-
-void UiSceneManager::OnSecurityWarningTimer() {
-  transient_security_warning_->set_visible(false);
-}
-
-void UiSceneManager::ConfigureTransientUrlBar() {
-  bool enabled = web_vr_mode_ && web_vr_autopresentation_expected_;
-  transient_url_bar_->set_visible(enabled);
-  if (enabled) {
-    transient_url_bar_timer_.Start(
-        FROM_HERE, base::TimeDelta::FromSeconds(kTransientUrlBarTimeoutSeconds),
-        this, &UiSceneManager::OnTransientUrlBarTimer);
-  } else {
-    transient_url_bar_timer_.Stop();
-  }
-}
-
-void UiSceneManager::OnTransientUrlBarTimer() {
-  transient_url_bar_->set_visible(false);
-}
-
-void UiSceneManager::OnExclusiveScreenToastTimer() {
-  exclusive_screen_toast_->set_visible(false);
 }
 
 void UiSceneManager::OnBackButtonClicked() {
   browser_->NavigateBack();
 }
 
 void UiSceneManager::OnSecurityIconClickedForTesting() {
   OnSecurityIconClicked();
 }
 
@@ skipping 75 matching lines @@
   if (fullscreen_)
     return ColorScheme::kModeFullscreen;
   return ColorScheme::kModeNormal;
 }
 
 const ColorScheme& UiSceneManager::color_scheme() const {
   return ColorScheme::GetColorScheme(mode());
 }
 
 }  // namespace vr_shell