[vr] Take target transform to calculate content resolution

The translation of the content group (parent of the content quad) is
animated when entering fullscreen. As a result, the calculated content
texture resolution differs depending on the animation's timing. Take the
the target transform of the animation instead in order to get a
deterministic content texture resolution.

Change-Id: Ieef5165c41d02ab2fa87f6736ebf91a10aa3f166
Reviewed-on: https://chromium-review.googlesource.com/667925
Commit-Queue: Tibor Goldschwendt <tiborg@chromium.org>
Reviewed-by: Ian Vollick <vollick@chromium.org>
Cr-Commit-Position: refs/heads/master@{#502125}

chrome/browser/vr/animation_player.cc

@@ -383,6 +383,19 @@ bool AnimationPlayer::IsAnimatingProperty(int property) const {
   return false;
 }
 
+cc::TransformOperations AnimationPlayer::GetTargetTransformOperationsValue(
+    int target_property) const {
+  cc::Animation* running_animation = nullptr;
+  for (auto& animation : animations_) {
+    if (animation->target_property_id() == target_property) {
+      running_animation = animation.get();
+    }
+  }
+  DCHECK(running_animation);
+  const auto* curve = running_animation->curve()->ToTransformAnimationCurve();
+  return curve->GetValue(GetEndTime(running_animation));
+}
+
 gfx::SizeF AnimationPlayer::GetTargetSizeValue(int target_property) const {
   cc::Animation* running_animation = nullptr;
   for (auto& animation : animations_) {

chrome/browser/vr/animation_player.h

@@ -85,6 +85,8 @@ class AnimationPlayer final {
   bool IsAnimatingProperty(int property) const;
 
   // TODO(754822): Implement target getters for other value types.
+  cc::TransformOperations GetTargetTransformOperationsValue(
+      int target_property) const;
   gfx::SizeF GetTargetSizeValue(int target_property) const;
 
  private:

chrome/browser/vr/ui_scene_manager.cc

@@ -177,7 +177,8 @@ static constexpr float kContentAspectRatioPropagationThreshold = 0.01f;
 //       kFloor
 //       kCeiling
 //     k2dBrowsingForeground
-//       kContentQuad
+//       k2dBrowsingContentGroup
+//         kContentQuad
 //         kBackplane
 //         kIndicatorLayout
 //           kAudioCaptureIndicator
@@ -714,8 +715,27 @@ void UiSceneManager::OnProjMatrixChanged(const gfx::Transform& proj_matrix) {
     main_content_size = main_content_->size();
   }
 
+  // We take the target transform in case the content quad's parent's translate
+  // is animated. This approach only works with the current scene hierarchy and
+  // set of animated properties.
+  // TODO(tiborg): Find a way to get the target value of the inheritable
+  // transfrom that works with any scene hierarchy and set of animated
+  // properties.
+  gfx::Transform main_content_inheritable_transform;
+  if (scene_->GetUiElementByName(k2dBrowsingContentGroup)
+          ->animation_player()
+          .IsAnimatingProperty(TargetProperty::TRANSFORM)) {
+    main_content_inheritable_transform =
+        scene_->GetUiElementByName(k2dBrowsingContentGroup)
+            ->animation_player()
+            .GetTargetTransformOperationsValue(TargetProperty::TRANSFORM)
+            .Apply();
+  } else {
+    main_content_inheritable_transform = main_content_->inheritable_transform();
+  }
+
   gfx::SizeF screen_size = CalculateScreenSize(
-      proj_matrix, main_content_->inheritable_transform(), main_content_size);
+      proj_matrix, main_content_inheritable_transform, main_content_size);
 
   float aspect_ratio = main_content_size.width() / main_content_size.height();
   gfx::SizeF screen_bounds;

chrome/browser/vr/ui_scene_manager_unittest.cc

@@ -588,7 +588,7 @@ TEST_F(UiSceneManagerTest, PropagateContentBoundsOnFullscreen) {
   manager_->SetFullscreen(true);
   AnimateBy(MsToDelta(0));
 
-  gfx::SizeF expected_bounds(0.705449f, 0.396737f);
+  gfx::SizeF expected_bounds(0.587874f, 0.330614f);
   EXPECT_CALL(*browser_,
               OnContentScreenBoundsChanged(
                   SizeFsAreApproximatelyEqual(expected_bounds, kTolerance)));