NOT FOR REVIEW - convert to cc animation

chrome/browser/android/vr_shell/ui_scene_manager.cc

Index: chrome/browser/android/vr_shell/ui_scene_manager.cc
diff --git a/chrome/browser/android/vr_shell/ui_scene_manager.cc b/chrome/browser/android/vr_shell/ui_scene_manager.cc
index dca383c308cff2459f26b4e22b4a103d8746009b..72aa95ee4649adc62c9f599c5e95c7ddb26a1f29 100644
--- a/chrome/browser/android/vr_shell/ui_scene_manager.cc
+++ b/chrome/browser/android/vr_shell/ui_scene_manager.cc
@@ -24,6 +24,7 @@
 #include "chrome/browser/android/vr_shell/ui_scene.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/vector_icons/vector_icons.h"
+#include "ui/gfx/transform_util.h"
 #include "ui/vector_icons/vector_icons.h"
 
 namespace vr_shell {
@@ -128,6 +129,10 @@ static constexpr int kFloorGridlineCount = 40;
 // Tiny distance to offset textures that should appear in the same plane.
 static constexpr float kTextureOffset = 0.01;
 
+static double toDegrees(double radians) {
+  return radians * 180.0 / M_PI;
+}
+
 }  // namespace
 
 UiSceneManager::UiSceneManager(UiBrowserInterface* browser,
@@ -161,9 +166,8 @@ UiSceneManager::~UiSceneManager() {}
 
 void UiSceneManager::CreateScreenDimmer() {
   std::unique_ptr<UiElement> element;
-  element = base::MakeUnique<ScreenDimmer>();
+  element = base::MakeUnique<ScreenDimmer>(AllocateId());
   element->set_debug_id(kScreenDimmer);
-  element->set_id(AllocateId());
   element->set_fill(vr_shell::Fill::NONE);
   element->set_visible(false);
   element->set_hit_testable(false);
@@ -177,17 +181,18 @@ void UiSceneManager::CreateSecurityWarnings() {
 
   // TODO(mthiesse): Programatically compute the proper texture size for these
   // textured UI elements.
-  element = base::MakeUnique<PermanentSecurityWarning>(512);
+  element = base::MakeUnique<PermanentSecurityWarning>(AllocateId(), 512);
   element->set_debug_id(kWebVrPermanentHttpSecurityWarning);
-  element->set_id(AllocateId());
   element->set_fill(vr_shell::Fill::NONE);
   element->set_size({kPermanentWarningWidth, kPermanentWarningHeight, 1});
-  element->set_scale({kWarningDistance, kWarningDistance, 1});
-  element->set_translation(
-      gfx::Vector3dF(0, kWarningDistance * sin(kWarningAngleRadians),
-                     -kWarningDistance * cos(kWarningAngleRadians)));
-  element->set_rotation(
-      gfx::Quaternion(gfx::Vector3dF(1, 0, 0), kWarningAngleRadians));
+
+  cc::TransformOperations operations;
+  operations.AppendTranslate(0, kWarningDistance * sin(kWarningAngleRadians),
+                             -kWarningDistance * cos(kWarningAngleRadians));
+  operations.AppendRotate(1, 0, 0, toDegrees(kWarningAngleRadians));
+  operations.AppendScale(kWarningDistance, kWarningDistance, 1);
+  element->set_transform_operations(operations);
+
   element->set_visible(false);
   element->set_hit_testable(false);
   element->set_lock_to_fov(true);
@@ -195,27 +200,28 @@ void UiSceneManager::CreateSecurityWarnings() {
   scene_->AddUiElement(std::move(element));
 
   auto transient_warning = base::MakeUnique<TransientSecurityWarning>(
-      1024, base::TimeDelta::FromSeconds(kWarningTimeoutSeconds));
+      AllocateId(), 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});
+  operations = cc::TransformOperations();
+  operations.AppendTranslate(0, 0, -kWarningDistance);
+  element->set_transform_operations(operations);
   element->set_visible(false);
   element->set_hit_testable(false);
   element->set_lock_to_fov(true);
   scene_->AddUiElement(std::move(element));
 
-  element = base::MakeUnique<ExitWarning>(1024);
+  element = base::MakeUnique<ExitWarning>(AllocateId(), 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});
+  operations = cc::TransformOperations();
+  operations.AppendTranslate(0, 0, -kExitWarningDistance);
+  operations.AppendScale(kExitWarningDistance, kExitWarningDistance, 1);
+  element->set_transform_operations(operations);
   element->set_visible(false);
   element->set_hit_testable(false);
   element->set_lock_to_fov(true);
@@ -247,9 +253,9 @@ void UiSceneManager::CreateSystemIndicators() {
 
   for (const auto& indicator : indicators) {
     element = base::MakeUnique<SystemIndicator>(
-        512, kIndicatorHeight, indicator.icon, indicator.resource_string);
+        AllocateId(), 512, kIndicatorHeight, indicator.icon,
+        indicator.resource_string);
     element->set_debug_id(indicator.debug_id);
-    element->set_id(AllocateId());
     element->set_parent_id(main_content_->id());
     element->set_y_anchoring(YAnchoring::YTOP);
     element->set_visible(false);
@@ -264,12 +270,13 @@ void UiSceneManager::CreateSystemIndicators() {
 void UiSceneManager::CreateContentQuad() {
   std::unique_ptr<UiElement> element;
 
-  element = base::MakeUnique<UiElement>();
+  element = base::MakeUnique<UiElement>(AllocateId());
   element->set_debug_id(kContentQuad);
-  element->set_id(AllocateId());
   element->set_fill(vr_shell::Fill::CONTENT);
   element->set_size({kContentWidth, kContentHeight, 1});
-  element->set_translation({0, kContentVerticalOffset, -kContentDistance});
+  cc::TransformOperations operations;
+  operations.AppendTranslate(0, kContentVerticalOffset, -kContentDistance);
+  element->set_transform_operations(operations);
   element->set_visible(false);
   main_content_ = element.get();
   content_elements_.push_back(element.get());
@@ -277,31 +284,34 @@ void UiSceneManager::CreateContentQuad() {
 
   // Place an invisible but hittable plane behind the content quad, to keep the
   // reticle roughly planar with the content if near content.
-  element = base::MakeUnique<UiElement>();
+  element = base::MakeUnique<UiElement>(AllocateId());
   element->set_debug_id(kBackplane);
-  element->set_id(AllocateId());
   element->set_fill(vr_shell::Fill::NONE);
   element->set_size({kBackplaneSize, kBackplaneSize, 1.0});
-  element->set_translation({0.0, 0.0, -kTextureOffset});
+  operations = cc::TransformOperations();
+  operations.AppendTranslate(0, 0, -kTextureOffset);
+  element->set_transform_operations(operations);
   element->set_parent_id(main_content_->id());
   content_elements_.push_back(element.get());
   scene_->AddUiElement(std::move(element));
 
   // Limit reticle distance to a sphere based on content distance.
-  scene_->SetBackgroundDistance(main_content_->translation().z() *
-                                -kBackgroundDistanceMultiplier);
+  scene_->SetBackgroundDistance(
+      main_content_->transform_operations().Apply().matrix().get(2, 3) *
+      -kBackgroundDistanceMultiplier);
 }
 
 void UiSceneManager::CreateSplashScreen() {
   // Chrome icon.
   std::unique_ptr<SplashScreenIcon> icon =
-      base::MakeUnique<SplashScreenIcon>(256);
+      base::MakeUnique<SplashScreenIcon>(AllocateId(), 256);
   icon->set_debug_id(kSplashScreenIcon);
-  icon->set_id(AllocateId());
   icon->set_hit_testable(false);
   icon->set_size({kSplashScreenIconWidth, kSplashScreenIconHeight, 1.0});
-  icon->set_translation(
-      {0, kSplashScreenIconVerticalOffset, -kSplashScreenDistance});
+  cc::TransformOperations operations;
+  operations.AppendTranslate(0, kSplashScreenIconVerticalOffset,
+                             -kSplashScreenDistance);
+  icon->set_transform_operations(operations);
   splash_screen_icon_ = icon.get();
   scene_->AddUiElement(std::move(icon));
 }
@@ -310,12 +320,13 @@ void UiSceneManager::CreateBackground() {
   std::unique_ptr<UiElement> element;
 
   // Floor.
-  element = base::MakeUnique<UiElement>();
+  element = base::MakeUnique<UiElement>(AllocateId());
   element->set_debug_id(kFloor);
-  element->set_id(AllocateId());
   element->set_size({kSceneSize, kSceneSize, 1.0});
-  element->set_translation({0.0, -kSceneHeight / 2, 0.0});
-  element->set_rotation(gfx::Quaternion(gfx::Vector3dF(1, 0, 0), -M_PI / 2));
+  cc::TransformOperations operations;
+  operations.AppendTranslate(0.0, -kSceneHeight / 2, 0.0);
+  operations.AppendRotate(1, 0, 0, -90);
+  element->set_transform_operations(operations);
   element->set_fill(vr_shell::Fill::GRID_GRADIENT);
   element->set_draw_phase(0);
   element->set_gridline_count(kFloorGridlineCount);
@@ -324,12 +335,13 @@ void UiSceneManager::CreateBackground() {
   scene_->AddUiElement(std::move(element));
 
   // Ceiling.
-  element = base::MakeUnique<UiElement>();
+  element = base::MakeUnique<UiElement>(AllocateId());
   element->set_debug_id(kCeiling);
-  element->set_id(AllocateId());
   element->set_size({kSceneSize, kSceneSize, 1.0});
-  element->set_translation({0.0, kSceneHeight / 2, 0.0});
-  element->set_rotation(gfx::Quaternion(gfx::Vector3dF(1, 0, 0), M_PI / 2));
+  operations = cc::TransformOperations();
+  operations.AppendTranslate(0.0, kSceneHeight / 2, 0.0);
+  operations.AppendRotate(1, 0, 0, 90);
+  element->set_transform_operations(operations);
   element->set_fill(vr_shell::Fill::OPAQUE_GRADIENT);
   element->set_draw_phase(0);
   ceiling_ = element.get();
@@ -342,26 +354,27 @@ void UiSceneManager::CreateBackground() {
 void UiSceneManager::CreateUrlBar() {
   // TODO(cjgrant): Incorporate final size and position.
   auto url_bar = base::MakeUnique<UrlBar>(
-      512,
+      AllocateId(), 512,
       base::Bind(&UiSceneManager::OnBackButtonClicked, base::Unretained(this)),
       base::Bind(&UiSceneManager::OnSecurityIconClicked,
                  base::Unretained(this)),
       base::Bind(&UiSceneManager::OnUnsupportedMode, base::Unretained(this)));
   url_bar->set_debug_id(kUrlBar);
-  url_bar->set_id(AllocateId());
-  url_bar->set_translation({0, kUrlBarVerticalOffset, -kUrlBarDistance});
-  url_bar->set_rotation(
-      gfx::Quaternion(gfx::Vector3dF(1, 0, 0), kUrlBarRotationRad));
+  cc::TransformOperations operations;
+  operations.AppendTranslate(0, kUrlBarVerticalOffset, -kUrlBarDistance);
+  operations.AppendRotate(1, 0, 0, toDegrees(kUrlBarRotationRad));
+  url_bar->set_transform_operations(operations);
   url_bar->set_size({kUrlBarWidth, kUrlBarHeight, 1});
   url_bar_ = url_bar.get();
   control_elements_.push_back(url_bar.get());
   scene_->AddUiElement(std::move(url_bar));
 
-  auto indicator = base::MakeUnique<LoadingIndicator>(256);
+  auto indicator = base::MakeUnique<LoadingIndicator>(AllocateId(), 256);
   indicator->set_debug_id(kLoadingIndicator);
-  indicator->set_id(AllocateId());
-  indicator->set_translation(
-      {0, kLoadingIndicatorVerticalOffset, kLoadingIndicatorDepthOffset});
+  operations = cc::TransformOperations();
+  operations.AppendTranslate(0, kLoadingIndicatorVerticalOffset,
+                             kLoadingIndicatorDepthOffset);
+  indicator->set_transform_operations(operations);
   indicator->set_size({kLoadingIndicatorWidth, kLoadingIndicatorHeight, 1});
   indicator->set_parent_id(url_bar_->id());
   indicator->set_y_anchoring(YAnchoring::YTOP);
@@ -372,17 +385,18 @@ void UiSceneManager::CreateUrlBar() {
 
 void UiSceneManager::CreateTransientUrlBar() {
   auto url_bar = base::MakeUnique<TransientUrlBar>(
-      512, base::TimeDelta::FromSeconds(kTransientUrlBarTimeoutSeconds),
+      AllocateId(), 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));
+  cc::TransformOperations operations;
+  operations.AppendTranslate(0, kTransientUrlBarVerticalOffset,
+                             -kTransientUrlBarDistance);
+  operations.AppendRotate(1, 0, 0, toDegrees(kUrlBarRotationRad));
+  url_bar->set_transform_operations(operations);
   url_bar->set_size({kTransientUrlBarWidth, kTransientUrlBarHeight, 1});
   transient_url_bar_ = url_bar.get();
   scene_->AddUiElement(std::move(url_bar));
@@ -390,14 +404,16 @@ void UiSceneManager::CreateTransientUrlBar() {
 
 void UiSceneManager::CreateCloseButton() {
   std::unique_ptr<Button> element = base::MakeUnique<Button>(
+      AllocateId(),
       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,
-                     -kCloseButtonDistance));
+  cc::TransformOperations operations;
+  operations.AppendTranslate(
+      0, kContentVerticalOffset - (kContentHeight / 2) - 0.3,
+      -kCloseButtonDistance);
+  element->set_transform_operations(operations);
   element->set_size(gfx::Vector3dF(kCloseButtonWidth, kCloseButtonHeight, 1));
   close_button_ = element.get();
   scene_->AddUiElement(std::move(element));
@@ -405,16 +421,17 @@ void UiSceneManager::CreateCloseButton() {
 
 void UiSceneManager::CreateExitPrompt() {
   std::unique_ptr<UiElement> element = base::MakeUnique<ExitPrompt>(
-      512,
+      AllocateId(), 512,
       base::Bind(&UiSceneManager::OnExitPromptPrimaryButtonClicked,
                  base::Unretained(this)),
       base::Bind(&UiSceneManager::OnExitPromptSecondaryButtonClicked,
                  base::Unretained(this)));
   element->set_debug_id(kExitPrompt);
-  element->set_id(AllocateId());
   element->set_fill(vr_shell::Fill::NONE);
   element->set_size({kExitPromptWidth, kExitPromptHeight, 1});
-  element->set_translation({0.0, kExitPromptVerticalOffset, kTextureOffset});
+  cc::TransformOperations operations;
+  operations.AppendTranslate(0.0, kExitPromptVerticalOffset, kTextureOffset);
+  element->set_transform_operations(operations);
   element->set_parent_id(main_content_->id());
   element->set_visible(false);
   exit_prompt_ = element.get();
@@ -422,13 +439,15 @@ void UiSceneManager::CreateExitPrompt() {
 
   // Place an invisible but hittable plane behind the exit prompt, to keep the
   // reticle roughly planar with the content if near content.
-  element = base::MakeUnique<ExitPromptBackplane>(base::Bind(
-      &UiSceneManager::OnExitPromptBackplaneClicked, base::Unretained(this)));
+  element = base::MakeUnique<ExitPromptBackplane>(
+      AllocateId(), base::Bind(&UiSceneManager::OnExitPromptBackplaneClicked,
+                               base::Unretained(this)));
   element->set_debug_id(kExitPromptBackplane);
-  element->set_id(AllocateId());
   element->set_fill(vr_shell::Fill::NONE);
   element->set_size({kExitPromptBackplaneSize, kExitPromptBackplaneSize, 1.0});
-  element->set_translation({0.0, 0.0, -kTextureOffset});
+  operations = cc::TransformOperations();
+  operations.AppendTranslate(0.0, 0.0, -kTextureOffset);
+  element->set_transform_operations(operations);
   element->set_parent_id(exit_prompt_->id());
   exit_prompt_backplane_ = element.get();
   content_elements_.push_back(element.get());
@@ -437,9 +456,8 @@ void UiSceneManager::CreateExitPrompt() {
 
 void UiSceneManager::CreateToasts() {
   auto element = base::MakeUnique<ExclusiveScreenToast>(
-      512, base::TimeDelta::FromSeconds(kToastTimeoutSeconds));
+      AllocateId(), 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);
@@ -513,31 +531,39 @@ void UiSceneManager::ConfigureScene() {
   // Update content quad parameters depending on fullscreen.
   // TODO(http://crbug.com/642937): Animate fullscreen transitions.
   if (fullscreen_) {
-    main_content_->set_translation(
-        {0, kFullscreenVerticalOffset, -kFullscreenDistance});
+    cc::TransformOperations operations;
+    operations.AppendTranslate(0, kFullscreenVerticalOffset,
+                               -kFullscreenDistance);
+    main_content_->set_transform_operations(operations);
     main_content_->set_size({kFullscreenWidth, kFullscreenHeight, 1});
 
-    close_button_->set_translation(gfx::Vector3dF(
+    operations = cc::TransformOperations();
+    operations.AppendTranslate(
         0, kFullscreenVerticalOffset - (kFullscreenHeight / 2) - 0.35,
-        -kCloseButtonFullscreenDistance));
+        -kCloseButtonFullscreenDistance);
+    close_button_->set_transform_operations(operations);
     close_button_->set_size(gfx::Vector3dF(kCloseButtonFullscreenWidth,
                                            kCloseButtonFullscreenHeight, 1));
   } else {
+    cc::TransformOperations operations;
+    operations.AppendTranslate(0, kContentVerticalOffset, -kContentDistance);
     // Note that main_content_ is already visible in this case.
-    main_content_->set_translation(
-        {0, kContentVerticalOffset, -kContentDistance});
+    main_content_->set_transform_operations(operations);
     main_content_->set_size({kContentWidth, kContentHeight, 1});
 
-    close_button_->set_translation(
-        gfx::Vector3dF(0, kContentVerticalOffset - (kContentHeight / 2) - 0.3,
-                       -kCloseButtonDistance));
+    operations = cc::TransformOperations();
+    operations.AppendTranslate(
+        0, kContentVerticalOffset - (kContentHeight / 2) - 0.3,
+        -kCloseButtonDistance);
+    close_button_->set_transform_operations(operations);
     close_button_->set_size(
         gfx::Vector3dF(kCloseButtonWidth, kCloseButtonHeight, 1));
   }
 
   scene_->SetMode(mode());
-  scene_->SetBackgroundDistance(main_content_->translation().z() *
-                                -kBackgroundDistanceMultiplier);
+  scene_->SetBackgroundDistance(
+      main_content_->transform_operations().Apply().matrix().get(2, 3) *
+      -kBackgroundDistanceMultiplier);
   UpdateBackgroundColor();
 
   transient_url_bar_->SetEnabled(web_vr_autopresentation_ &&
@@ -643,6 +669,7 @@ void UiSceneManager::ConfigureIndicators() {
 
   // Position elements dynamically relative to each other, based on which
   // indicators are showing, and how big each one is.
+  // TODO(vollick): create a linear layout element to own this logic.
   float total_width = 0;
   for (const UiElement* indicator : system_indicators_) {
     if (indicator->visible()) {
@@ -656,9 +683,10 @@ void UiSceneManager::ConfigureIndicators() {
     if (!indicator->visible())
       continue;
     float width = indicator->size().x();
-    indicator->set_translation({x_position + width / 2,
-                                kIndicatorVerticalOffset,
-                                kIndicatorDistanceOffset});
+    cc::TransformOperations operations;
+    operations.AppendTranslate(x_position + width / 2, kIndicatorVerticalOffset,
+                               kIndicatorDistanceOffset);
+    indicator->set_transform_operations(operations);
     x_position += width + kIndicatorGap;
   }
 }
@@ -670,24 +698,23 @@ void UiSceneManager::ConfigureExclusiveScreenToast() {
   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));
+    cc::TransformOperations operations;
+    operations.AppendTranslate(
+        0,
+        kFullscreenVerticalOffset + kFullscreenHeight / 2 +
+            (kToastOffsetDMM + kToastHeightDMM) * kFullscreenToastDistance,
+        -kFullscreenToastDistance);
+    operations.AppendScale(kFullscreenToastDistance, kFullscreenToastDistance,
+                           1);
+    exclusive_screen_toast_->set_transform_operations(operations);
     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));
+    cc::TransformOperations operations;
+    operations.AppendTranslate(0, kWebVrToastDistance * sin(kWebVrAngleRadians),
+                               -kWebVrToastDistance * cos(kWebVrAngleRadians));
+    operations.AppendRotate(1, 0, 0, toDegrees(kWebVrAngleRadians));
+    operations.AppendScale(kWebVrToastDistance, kWebVrToastDistance, 1);
+    exclusive_screen_toast_->set_transform_operations(operations);
     exclusive_screen_toast_->set_lock_to_fov(true);
   }
 }