[vr] Use base's time classes

chrome/browser/android/vr_shell/ui_scene.cc

 // Copyright 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"
 
 #include <string>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
+#include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/android/vr_shell/animation.h"
 #include "chrome/browser/android/vr_shell/easing.h"
 #include "chrome/browser/android/vr_shell/ui_elements.h"
 
 namespace vr_shell {
 
 namespace {
 
 // Parse an integer to an int or enum value.
@@ skipping 201 matching lines @@
                            std::unique_ptr<Animation> animation) {
   ContentRectangle* element = GetUiElementById(element_id);
   CHECK_NE(element, nullptr);
   for (auto& existing_animation : element->animations) {
     CHECK_NE(existing_animation->id, animation->id);
   }
   element->animations.emplace_back(std::move(animation));
 }
 
 void UiScene::AddAnimationFromDict(const base::DictionaryValue& dict,
-                                   int64_t time_in_micro) {
+                                   const base::TimeTicks& current_time) {
   int animation_id;
   int element_id;
   Animation::Property property;
   double start_time_ms;
   double duration_ms;
 
   const base::DictionaryValue* easing_dict = nullptr;
   const base::DictionaryValue* from_dict = nullptr;
   const base::DictionaryValue* to_dict = nullptr;
   std::vector<float> from;
@@ skipping 11 matching lines @@
   CHECK(dict.GetDictionary("to", &to_dict));
   ParseEndpointToFloats(property, *to_dict, &to);
 
   // The start location is optional.  If not specified, the animation will
   // start from the element's current location.
   dict.GetDictionary("from", &from_dict);
   if (from_dict != nullptr) {
     ParseEndpointToFloats(property, *from_dict, &from);
   }
 
-  int64_t start = time_in_micro + (start_time_ms * 1000.0);
-  int64_t duration = duration_ms * 1000.0;
+  base::TimeDelta delay = base::TimeDelta::FromMilliseconds(start_time_ms);
+  base::TimeTicks start = current_time + delay;
+  base::TimeDelta duration = base::TimeDelta::FromMilliseconds(duration_ms);
 
   ContentRectangle* element = GetUiElementById(element_id);
   CHECK_NE(element, nullptr);
   element->animations.emplace_back(base::MakeUnique<Animation>(
       animation_id, static_cast<Animation::Property>(property),
       std::move(easing), from, to, start, duration));
 }
 
 void UiScene::RemoveAnimation(int element_id, int animation_id) {
   ContentRectangle* element = GetUiElementById(element_id);
   CHECK_NE(element, nullptr);
   auto& animations = element->animations;
   for (auto it = animations.begin(); it != animations.end(); ++it) {
     const Animation& existing_animation = **it;
     if (existing_animation.id == animation_id) {
       animations.erase(it);
       return;
     }
   }
 }
 
 void UiScene::HandleCommands(std::unique_ptr<base::ListValue> commands,
-                             int64_t time_in_micro) {
+                             const base::TimeTicks& time) {
   for (auto& item : *commands) {
     base::DictionaryValue* dict;
     CHECK(item->GetAsDictionary(&dict));
 
     Command type;
     base::DictionaryValue* data;
     CHECK(ParseInt(*dict, "type", &type));
     CHECK(dict->GetDictionary("data", &data));
 
     switch (type) {
       case Command::ADD_ELEMENT:
         AddUiElementFromDict(*data);
         break;
       case Command::UPDATE_ELEMENT:
         UpdateUiElementFromDict(*data);
         break;
       case Command::REMOVE_ELEMENT: {
         int element_id;
         CHECK(ParseInt(*data, "id", &element_id));
         RemoveUiElement(element_id);
         break;
       }
       case Command::ADD_ANIMATION:
-        AddAnimationFromDict(*data, time_in_micro);
+        AddAnimationFromDict(*data, time);
         break;
       case Command::REMOVE_ANIMATION: {
         int element_id, animation_id;
         CHECK(ParseInt(*data, "id", &animation_id));
         CHECK(ParseInt(*data, "meshId", &element_id));
         RemoveAnimation(element_id, animation_id);
         break;
       }
       case Command::CONFIGURE_SCENE:
         ParseColorf(*data, "backgroundColor", &background_color_);
         ParseFloat(*data, "backgroundDistance", &background_distance_);
         data->GetBoolean("drawWebVr", &webvr_rendering_enabled_);
         break;
     }
   }
 }
 
-void UiScene::UpdateTransforms(int64_t time_in_micro) {
+void UiScene::UpdateTransforms(const base::TimeTicks& time) {
   for (auto& element : ui_elements_) {
     // Process all animations before calculating object transforms.
-    element->Animate(time_in_micro);
+    element->Animate(time);
     element->dirty = true;
   }
   for (auto& element : ui_elements_) {
     ApplyRecursiveTransforms(element.get());
   }
 }
 
 ContentRectangle* UiScene::GetUiElementById(int element_id) {
   for (auto& element : ui_elements_) {
     if (element->id == element_id) {
@@ skipping 157 matching lines @@
         content_element_ = element;
         break;
       default:
         element->fill = Fill::NONE;
         break;
     }
   }
 }
 
 }  // namespace vr_shell