NOT FOR REVIEW - convert to cc animation

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"
 #include "chrome/browser/android/vr_shell/ui_browser_interface.h"
 #include "chrome/browser/android/vr_shell/ui_elements/button.h"
 #include "chrome/browser/android/vr_shell/ui_elements/exclusive_screen_toast.h"
 #include "chrome/browser/android/vr_shell/ui_elements/exit_prompt.h"
 #include "chrome/browser/android/vr_shell/ui_elements/exit_prompt_backplane.h"
 #include "chrome/browser/android/vr_shell/ui_elements/loading_indicator.h"
 #include "chrome/browser/android/vr_shell/ui_elements/screen_dimmer.h"
 #include "chrome/browser/android/vr_shell/ui_elements/splash_screen_icon.h"
 #include "chrome/browser/android/vr_shell/ui_elements/system_indicator.h"
 #include "chrome/browser/android/vr_shell/ui_elements/transient_url_bar.h"
 #include "chrome/browser/android/vr_shell/ui_elements/ui_element.h"
 #include "chrome/browser/android/vr_shell/ui_elements/ui_element_debug_id.h"
 #include "chrome/browser/android/vr_shell/ui_elements/url_bar.h"
 #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 {
 
 namespace {
 
 static constexpr int kWarningTimeoutSeconds = 30;
 static constexpr float kWarningDistance = 0.7;
 static constexpr float kWarningAngleRadians = 16.3 * M_PI / 180.0;
 static constexpr float kPermanentWarningHeight = 0.070f;
@@ skipping 84 matching lines @@
 static constexpr float kLoadingIndicatorDepthOffset =
     (kUrlBarDistance - kContentDistance) / 2;
 
 static constexpr float kSceneSize = 25.0;
 static constexpr float kSceneHeight = 4.0;
 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,
                                UiScene* scene,
                                bool in_cct,
                                bool in_web_vr,
                                bool web_vr_autopresentation_expected)
     : browser_(browser),
       scene_(scene),
       in_cct_(in_cct),
@@ skipping 13 matching lines @@
   CreateExitPrompt();
   CreateToasts();
 
   ConfigureScene();
 }
 
 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);
   element->set_is_overlay(true);
   screen_dimmer_ = element.get();
   scene_->AddUiElement(std::move(element));
 }
 
 void UiSceneManager::CreateSecurityWarnings() {
   std::unique_ptr<UiElement> element;
 
   // 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);
   permanent_security_warning_ = element.get();
   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);
   exit_warning_ = element.get();
   scene_->AddUiElement(std::move(element));
 }
 
 void UiSceneManager::CreateSystemIndicators() {
   std::unique_ptr<UiElement> element;
 
@@ skipping 11 matching lines @@
       {&screen_capture_indicator_, kScreenCaptureIndicator,
        vector_icons::kScreenShareIcon, IDS_SCREEN_CAPTURE_NOTIFICATION_TEXT_2},
       {&bluetooth_connected_indicator_, kBluetoothConnectedIndicator,
        vector_icons::kBluetoothConnectedIcon, 0},
       {&location_access_indicator_, kLocationAccessIndicator,
        ui::kLocationOnIcon, 0},
   };
 
   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);
     *(indicator.element) = element.get();
     system_indicators_.push_back(element.get());
     scene_->AddUiElement(std::move(element));
   }
 
   ConfigureIndicators();
 }
 
 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());
   scene_->AddUiElement(std::move(element));
 
   // 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));
 }
 
 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);
   floor_ = element.get();
   background_elements_.push_back(element.get());
   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();
   background_elements_.push_back(element.get());
   scene_->AddUiElement(std::move(element));
 
   UpdateBackgroundColor();
 }
 
 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);
   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, 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));
 }
 
 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));
 }
 
 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();
   scene_->AddUiElement(std::move(element));
 
   // 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());
   scene_->AddUiElement(std::move(element));
 }
 
 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);
   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();
@@ skipping 53 matching lines @@
   }
 
   // Exit prompt.
   bool showExitPrompt = browsing_mode && scene_->is_prompting_to_exit();
   exit_prompt_->SetEnabled(showExitPrompt);
   exit_prompt_backplane_->SetEnabled(showExitPrompt);
 
   // 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_ &&
                                  !scene_->showing_splash_screen());
 
   ConfigureExclusiveScreenToast();
   ConfigureSecurityWarnings();
   ConfigureIndicators();
 }
 
@@ skipping 85 matching lines @@
   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_);
 
   if (!allowed)
     return;
 
   // 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()) {
       if (total_width > 0)
         total_width += kIndicatorGap;
       total_width += indicator->size().x();
     }
   }
   float x_position = -total_width / 2;
   for (UiElement* indicator : system_indicators_) {
     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;
   }
 }
 
 void UiSceneManager::ConfigureExclusiveScreenToast() {
   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));
+    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);
   }
 }
 
 void UiSceneManager::OnBackButtonClicked() {
   browser_->NavigateBack();
 }
 
 void UiSceneManager::OnSecurityIconClickedForTesting() {
   OnSecurityIconClicked();
@@ skipping 77 matching lines @@
   if (fullscreen_)
     return ColorScheme::kModeFullscreen;
   return ColorScheme::kModeNormal;
 }
 
 const ColorScheme& UiSceneManager::color_scheme() const {
   return ColorScheme::GetColorScheme(mode());
 }
 
 }  // namespace vr_shell