[VrShell] Centralize color handling and enable close button on fullscreen

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 28 matching lines @@
 static constexpr float kExitWarningHeight = 0.160;
 static constexpr float kExitWarningWidth = 0.512;
 
 static constexpr float kContentDistance = 2.5;
 static constexpr float kContentWidth = 0.96 * kContentDistance;
 static constexpr float kContentHeight = 0.64 * kContentDistance;
 static constexpr float kContentVerticalOffset = -0.1 * kContentDistance;
 static constexpr float kBackplaneSize = 1000.0;
 static constexpr float kBackgroundDistanceMultiplier = 1.414;
 
+static constexpr float kFullscreenDistance = 3;
+static constexpr float kFullscreenHeight = 0.64 * kFullscreenDistance;
+static constexpr float kFullscreenWidth = 1.138 * kFullscreenDistance;
+static constexpr float kFullscreenVerticalOffset = -0.1 * kFullscreenDistance;
+
 static constexpr float kUrlBarDistance = 2.4;
 static constexpr float kUrlBarWidth = 0.672 * kUrlBarDistance;
 static constexpr float kUrlBarHeight = 0.088 * kUrlBarDistance;
 static constexpr float kUrlBarVerticalOffset = -0.516 * kUrlBarDistance;
 static constexpr float kUrlBarRotationRad = -0.175;
 
+static constexpr float kCloseButtonDistance = 2.4;
+static constexpr float kCloseButtonHeight = 0.088 * kCloseButtonDistance;
+static constexpr float kCloseButtonWidth = 0.088 * kCloseButtonDistance;
+static constexpr float kCloseButtonFullscreenDistance = 2.9;
+static constexpr float kCloseButtonFullscreenHeight =
+    0.088 * kCloseButtonDistance;
+static constexpr float kCloseButtonFullscreenWidth =
+    0.088 * kCloseButtonDistance;
+
 static constexpr float kLoadingIndicatorWidth = 0.24 * kUrlBarDistance;
 static constexpr float kLoadingIndicatorHeight = 0.008 * kUrlBarDistance;
 static constexpr float kLoadingIndicatorVerticalOffset =
     (-kUrlBarVerticalOffset + kContentVerticalOffset - kContentHeight / 2 -
      kUrlBarHeight / 2) /
     2;
 static constexpr float kLoadingIndicatorDepthOffset =
     (kUrlBarDistance - kContentDistance) / 2;
 
 static constexpr float kSceneSize = 25.0;
 static constexpr float kSceneHeight = 4.0;
 static constexpr int kFloorGridlineCount = 40;
 
-static constexpr float kFullscreenDistance = 3;
-static constexpr float kFullscreenHeight = 0.64 * kFullscreenDistance;
-static constexpr float kFullscreenWidth = 1.138 * kFullscreenDistance;
-static constexpr float kFullscreenVerticalOffset = -0.1 * kFullscreenDistance;
-
 // Tiny distance to offset textures that should appear in the same plane.
 static constexpr float kTextureOffset = 0.01;
 
 }  // namespace
 
 UiSceneManager::UiSceneManager(UiBrowserInterface* browser,
                                UiScene* scene,
                                bool in_cct,
                                bool in_web_vr)
     : browser_(browser),
       scene_(scene),
       in_cct_(in_cct),
       web_vr_mode_(in_web_vr),
       weak_ptr_factory_(this) {
   CreateBackground();
   CreateContentQuad();
   CreateSecurityWarnings();
   CreateSystemIndicators();
   CreateUrlBar();
-  if (in_cct_)
-    CreateCloseButton();
+  CreateCloseButton();
   CreateScreenDimmer();
 
   ConfigureScene();
   ConfigureSecurityWarnings();
 }
 
 UiSceneManager::~UiSceneManager() {}
 
 void UiSceneManager::CreateScreenDimmer() {
   std::unique_ptr<UiElement> element;
@@ skipping 184 matching lines @@
 
 void UiSceneManager::CreateCloseButton() {
   std::unique_ptr<Button> element = base::MakeUnique<Button>(
       base::Bind(&UiSceneManager::OnCloseButtonClicked, base::Unretained(this)),
       base::MakeUnique<CloseButtonTexture>());
   element->set_debug_id(kCloseButton);
   element->set_id(AllocateId());
   element->set_fill(vr_shell::Fill::NONE);
   element->set_translation(
       gfx::Vector3dF(0, kContentVerticalOffset - (kContentHeight / 2) - 0.3,
-                     -kContentDistance + 0.4));
-  element->set_size(gfx::Vector3dF(0.2, 0.2, 1));
-  control_elements_.push_back(element.get());
+                     -kCloseButtonDistance));
+  element->set_size(gfx::Vector3dF(kCloseButtonWidth, kCloseButtonHeight, 1));
+  close_button_ = element.get();
   scene_->AddUiElement(std::move(element));
 }
 
 base::WeakPtr<UiSceneManager> UiSceneManager::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void UiSceneManager::SetWebVrMode(bool web_vr) {
   if (web_vr_mode_ == web_vr)
     return;
   web_vr_mode_ = web_vr;
   ConfigureScene();
   ConfigureSecurityWarnings();
   audio_capture_indicator_->set_visible(!web_vr && audio_capturing_);
   video_capture_indicator_->set_visible(!web_vr && video_capturing_);
   screen_capture_indicator_->set_visible(!web_vr && screen_capturing_);
 }
 
 void UiSceneManager::ConfigureScene() {
   exit_warning_->SetEnabled(scene_->is_exiting());
   screen_dimmer_->SetEnabled(scene_->is_exiting());
 
   // Controls (URL bar, loading progress, etc).
   bool controls_visible = !web_vr_mode_ && !fullscreen_;
   for (UiElement* element : control_elements_) {
     element->SetEnabled(controls_visible);
   }
 
+  // Close button is a special control element that needs to be hidden when in
+  // WebVR, but it needs to be visible when in cct or fullscreen.
+  close_button_->SetEnabled(!web_vr_mode_ && (fullscreen_ || in_cct_));
+
   // Content elements.
   for (UiElement* element : content_elements_) {
     element->SetEnabled(!web_vr_mode_);
   }
 
   // Update content quad parameters depending on fullscreen.
   // TODO(http://crbug.com/642937): Animate fullscreen transitions.
   if (fullscreen_) {
     main_content_->set_translation(
         {0, kFullscreenVerticalOffset, -kFullscreenDistance});
     main_content_->set_size({kFullscreenWidth, kFullscreenHeight, 1});
+
+    close_button_->set_translation(gfx::Vector3dF(
+        0, kFullscreenVerticalOffset - (kFullscreenHeight / 2) - 0.35,
+        -kCloseButtonFullscreenDistance));
+    close_button_->set_size(gfx::Vector3dF(kCloseButtonFullscreenWidth,
+                                           kCloseButtonFullscreenHeight, 1));
   } else {
     // Note that main_content_ is already visible in this case.
     main_content_->set_translation(
         {0, kContentVerticalOffset, -kContentDistance});
     main_content_->set_size({kContentWidth, kContentHeight, 1});
+
+    close_button_->set_translation(
+        gfx::Vector3dF(0, kContentVerticalOffset - (kContentHeight / 2) - 0.3,
+                       -kCloseButtonDistance));
+    close_button_->set_size(
+        gfx::Vector3dF(kCloseButtonWidth, kCloseButtonHeight, 1));
   }
 
   scene_->SetMode(mode());
   scene_->SetBackgroundDistance(main_content_->translation().z() *
                                 -kBackgroundDistanceMultiplier);
   UpdateBackgroundColor();
 }
 
 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().horizon);
+  ceiling_->set_edge_color(color_scheme().world_background);
   floor_->set_center_color(color_scheme().floor);
-  floor_->set_edge_color(color_scheme().horizon);
+  floor_->set_edge_color(color_scheme().world_background);
   floor_->set_grid_color(color_scheme().floor_grid);
 }
 
 void UiSceneManager::SetAudioCapturingIndicator(bool enabled) {
   audio_capturing_ = enabled;
   audio_capture_indicator_->set_visible(enabled && !web_vr_mode_);
 }
 
 void UiSceneManager::SetVideoCapturingIndicator(bool enabled) {
   video_capturing_ = enabled;
@@ skipping 76 matching lines @@
   scene_->set_is_exiting();
   ConfigureScene();
 }
 
 void UiSceneManager::SetHistoryButtonsEnabled(bool can_go_back,
                                               bool can_go_forward) {
   url_bar_->SetHistoryButtonsEnabled(can_go_back);
 }
 
 void UiSceneManager::OnCloseButtonClicked() {
-  browser_->ExitCct();
+  if (fullscreen_) {
+    browser_->ExitFullscreen();
+  }
+  if (in_cct_) {
+    browser_->ExitCct();
+  }
 }
 
 void UiSceneManager::OnUnsupportedMode(UiUnsupportedMode mode) {
   browser_->OnUnsupportedMode(mode);
 }
 
 int UiSceneManager::AllocateId() {
   return next_available_id_++;
 }
 
 ColorScheme::Mode UiSceneManager::mode() const {
   if (incognito_)
     return ColorScheme::kModeIncognito;
   if (fullscreen_)
     return ColorScheme::kModeFullscreen;
   return ColorScheme::kModeNormal;
 }
 
 const ColorScheme& UiSceneManager::color_scheme() const {
   return ColorScheme::GetColorScheme(mode());
 }
 
 }  // namespace vr_shell