[vr] Use base's time classes

chrome/browser/android/vr_shell/ui_scene_unittest.cc

 // Copyright (c) 2016 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.h"
 
 #define _USE_MATH_DEFINES  // For M_PI in MSVC.
 #include <cmath>
 #include <utility>
 #include <vector>
@@ skipping 10 matching lines @@
 
 #define EXPECT_VEC3F_NEAR(a, b)     \
   EXPECT_NEAR(a.x, b.x, TOLERANCE); \
   EXPECT_NEAR(a.y, b.y, TOLERANCE); \
   EXPECT_NEAR(a.z, b.z, TOLERANCE);
 
 namespace vr_shell {
 
 namespace {
 
+base::TimeTicks usToTicks(uint64_t us) {
+  return base::TimeTicks::FromInternalValue(us);
+}
+
+base::TimeDelta usToDelta(uint64_t us) {
+  return base::TimeDelta::FromInternalValue(us);
+}
+
 void addElement(UiScene* scene, int id) {
   auto element = base::MakeUnique<ContentRectangle>();
   element->id = id;
   scene->AddUiElement(std::move(element));
 }
 
 void addAnimation(UiScene* scene,
                   int element_id,
                   int animation_id,
                   Animation::Property property) {
   std::unique_ptr<easing::Easing> easing = base::MakeUnique<easing::Linear>();
   std::vector<float> from = {};
   std::vector<float> to = {1, 1, 1, 1};
-  auto animation = base::MakeUnique<Animation>(
-      animation_id, property, std::move(easing), from, to, 0, 1);
+  auto animation =
+      base::MakeUnique<Animation>(animation_id, property, std::move(easing),
+                                  from, to, usToTicks(0), usToDelta(1));
   scene->AddAnimation(element_id, std::move(animation));
 }
 
 }  // namespace
 
 TEST(UiScene, AddRemoveElements) {
   UiScene scene;
 
   EXPECT_EQ(scene.GetUiElements().size(), 0u);
   addElement(&scene, 0);
@@ skipping 63 matching lines @@
   element->size = {1, 1, 1};
   element->scale = {2, 2, 1};
   element->rotation = {0, 0, 1, M_PI / 2};
   element->translation = {3, 0, 0};
   scene.AddUiElement(std::move(element));
   const ContentRectangle* child = scene.GetUiElementById(1);
 
   const gvr::Vec3f origin({0, 0, 0});
   const gvr::Vec3f point({1, 0, 0});
 
-  scene.UpdateTransforms(0);
+  scene.UpdateTransforms(usToTicks(0));
   auto new_origin = MatrixVectorMul(child->TransformMatrix(), origin);
   auto new_point = MatrixVectorMul(child->TransformMatrix(), point);
   EXPECT_VEC3F_NEAR(gvr::Vec3f({6, 10, 0}), new_origin);
   EXPECT_VEC3F_NEAR(gvr::Vec3f({0, 10, 0}), new_point);
 }
 
 TEST(UiScene, Opacity) {
   UiScene scene;
 
   auto element = base::MakeUnique<ContentRectangle>();
   element->id = 0;
   element->opacity = 0.5;
   scene.AddUiElement(std::move(element));
 
   element = base::MakeUnique<ContentRectangle>();
   element->id = 1;
   element->parent_id = 0;
   element->opacity = 0.5;
   scene.AddUiElement(std::move(element));
 
-  scene.UpdateTransforms(0);
+  scene.UpdateTransforms(usToTicks(0));
   EXPECT_EQ(scene.GetUiElementById(0)->computed_opacity, 0.5f);
   EXPECT_EQ(scene.GetUiElementById(1)->computed_opacity, 0.25f);
 }
 
 TEST(UiScene, LockToFov) {
   UiScene scene;
 
   auto element = base::MakeUnique<ContentRectangle>();
   element->id = 0;
   element->lock_to_fov = true;
   scene.AddUiElement(std::move(element));
 
   element = base::MakeUnique<ContentRectangle>();
   element->id = 1;
   element->parent_id = 0;
   element->lock_to_fov = false;
   scene.AddUiElement(std::move(element));
 
-  scene.UpdateTransforms(0);
+  scene.UpdateTransforms(usToTicks(0));
   EXPECT_EQ(scene.GetUiElementById(0)->computed_lock_to_fov, true);
   EXPECT_EQ(scene.GetUiElementById(1)->computed_lock_to_fov, true);
 }
 
 typedef struct {
   XAnchoring x_anchoring;
   YAnchoring y_anchoring;
   float expected_x;
   float expected_y;
 } AnchoringTestCase;
@@ skipping 11 matching lines @@
   scene.AddUiElement(std::move(element));
 
   // Add a child to the parent, with anchoring.
   element = base::MakeUnique<ContentRectangle>();
   element->id = 1;
   element->parent_id = 0;
   element->x_anchoring = GetParam().x_anchoring;
   element->y_anchoring = GetParam().y_anchoring;
   scene.AddUiElement(std::move(element));
 
-  scene.UpdateTransforms(0);
+  scene.UpdateTransforms(usToTicks(0));
   const ContentRectangle* child = scene.GetUiElementById(1);
   EXPECT_NEAR(child->GetCenter().x, GetParam().expected_x, TOLERANCE);
   EXPECT_NEAR(child->GetCenter().y, GetParam().expected_y, TOLERANCE);
   scene.RemoveUiElement(1);
 }
 
 const std::vector<AnchoringTestCase> anchoring_test_cases = {
     {XAnchoring::XNONE, YAnchoring::YNONE, 0, 0},
     {XAnchoring::XLEFT, YAnchoring::YNONE, -2, 0},
     {XAnchoring::XRIGHT, YAnchoring::YNONE, 2, 0},
@@ skipping 201 matching lines @@
   to->SetInteger("a", 203);
   dict.Set("to", std::move(to));
 
   auto from = base::MakeUnique<base::DictionaryValue>();
   from->SetInteger("x", 300);
   from->SetInteger("y", 301);
   from->SetInteger("z", 302);
   from->SetInteger("a", 303);
   dict.Set("from", std::move(from));
 
-  scene.AddAnimationFromDict(dict, 10000000);
+  scene.AddAnimationFromDict(dict, usToTicks(10000000));
   const auto* element = scene.GetUiElementById(0);
   const auto* animation = element->animations[0].get();
   EXPECT_NE(animation, nullptr);
 
   EXPECT_EQ(animation->id, 10);
 
-  EXPECT_FLOAT_EQ(animation->to[0], 200);
-  EXPECT_FLOAT_EQ(animation->to[1], 201);
-  EXPECT_FLOAT_EQ(animation->to[2], 202);
-  EXPECT_FLOAT_EQ(animation->to[3], 203);
+  EXPECT_FLOAT_EQ(200, animation->to[0]);
+  EXPECT_FLOAT_EQ(201, animation->to[1]);
+  EXPECT_FLOAT_EQ(202, animation->to[2]);
+  EXPECT_FLOAT_EQ(203, animation->to[3]);
 
-  EXPECT_FLOAT_EQ(animation->from[0], 300);
-  EXPECT_FLOAT_EQ(animation->from[1], 301);
-  EXPECT_FLOAT_EQ(animation->from[2], 302);
-  EXPECT_FLOAT_EQ(animation->from[3], 303);
+  EXPECT_FLOAT_EQ(300, animation->from[0]);
+  EXPECT_FLOAT_EQ(301, animation->from[1]);
+  EXPECT_FLOAT_EQ(302, animation->from[2]);
+  EXPECT_FLOAT_EQ(303, animation->from[3]);
 
-  EXPECT_EQ(animation->start, 22345000);
-  EXPECT_EQ(animation->duration, 54321000);
+  EXPECT_EQ(usToTicks(22345000), animation->start);
+  EXPECT_EQ(usToDelta(54321000), animation->duration);
 }
 
 }  // namespace vr_shell