Adds in-out easing type.

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/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 78 matching lines @@
   return false;
 }
 
 std::unique_ptr<easing::Easing> ParseEasing(const base::DictionaryValue& dict) {
   easing::EasingType easingType;
   CHECK(ParseInt(dict, "type", &easingType));
   std::unique_ptr<easing::Easing> result;
 
   switch (easingType) {
     case easing::EasingType::LINEAR: {
-      result.reset(new easing::Linear());
+      result = base::MakeUnique<easing::Linear>();
       break;
     }
     case easing::EasingType::CUBICBEZIER: {
       double p1x, p1y, p2x, p2y;
       CHECK(dict.GetDouble("p1x", &p1x));
       CHECK(dict.GetDouble("p1y", &p1y));
       CHECK(dict.GetDouble("p2x", &p2x));
       CHECK(dict.GetDouble("p2y", &p2y));
-      result.reset(new easing::CubicBezier(p1x, p1y, p2x, p2y));
+      result = base::MakeUnique<easing::CubicBezier>(p1x, p1y, p2x, p2y);
       break;
     }
     case easing::EasingType::EASEIN: {
       double pow;
       CHECK(dict.GetDouble("pow", &pow));
-      result.reset(new easing::EaseIn(pow));
+      result = base::MakeUnique<easing::EaseIn>(pow);
       break;
     }
     case easing::EasingType::EASEOUT: {
       double pow;
       CHECK(dict.GetDouble("pow", &pow));
-      result.reset(new easing::EaseOut(pow));
+      result = base::MakeUnique<easing::EaseOut>(pow);
+      break;
+    }
+    case easing::EasingType::EASEINOUT: {
+      double pow;
+      CHECK(dict.GetDouble("pow", &pow));
+      result = base::MakeUnique<easing::EaseInOut>(pow);
       break;
     }
   }
   return result;
 }
 
 void ApplyAnchoring(const ContentRectangle& parent,
                     XAnchoring x_anchoring,
                     YAnchoring y_anchoring,
                     ReversibleTransform* transform) {
@@ skipping 37 matching lines @@
     CHECK_EQ(element->y_anchoring, YAnchoring::YNONE);
   }
   ui_elements_.push_back(std::move(element));
 }
 
 void UiScene::AddUiElementFromDict(const base::DictionaryValue& dict) {
   int id;
   CHECK(ParseInt(dict, "id", &id));
   CHECK_EQ(GetUiElementById(id), nullptr);
 
-  std::unique_ptr<ContentRectangle> element(new ContentRectangle);
+  auto element = base::MakeUnique<ContentRectangle>();
   element->id = id;
 
   ApplyDictToElement(dict, element.get());
   ui_elements_.push_back(std::move(element));
 }
 
 void UiScene::UpdateUiElementFromDict(const base::DictionaryValue& dict) {
   int id;
   CHECK(ParseInt(dict, "id", &id));
   ContentRectangle* element = GetUiElementById(id);
@@ skipping 54 matching lines @@
   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;
 
   ContentRectangle* element = GetUiElementById(element_id);
   CHECK_NE(element, nullptr);
-  element->animations.emplace_back(std::unique_ptr<Animation>(
-      new Animation(animation_id, static_cast<Animation::Property>(property),
-                    std::move(easing), from, to, start, duration)));
+  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);
@@ skipping 174 matching lines @@
         content_element_ = element;
         break;
       default:
         element->fill = Fill::NONE;
         break;
     }
   }
 }
 
 }  // namespace vr_shell