For c++, Generate enum classes instead of enum from mojom.

services/view_manager/scheduled_animation_group.cc

 // Copyright 2014 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 "services/view_manager/scheduled_animation_group.h"
 
 #include <set>
 
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "services/view_manager/server_view.h"
 
-using mojo::ANIMATION_PROPERTY_NONE;
-using mojo::ANIMATION_PROPERTY_OPACITY;
-using mojo::ANIMATION_PROPERTY_TRANSFORM;
 using mojo::AnimationProperty;
 
 namespace view_manager {
 namespace {
 
 using Sequences = std::vector<ScheduledAnimationSequence>;
 
 // Gets the value of |property| from |view| into |value|.
 void GetValueFromView(const ServerView* view,
                       AnimationProperty property,
                       ScheduledAnimationValue* value) {
   switch (property) {
-    case ANIMATION_PROPERTY_NONE:
+    case AnimationProperty::NONE:
       NOTREACHED();
       break;
-    case ANIMATION_PROPERTY_OPACITY:
+    case AnimationProperty::OPACITY:
       value->float_value = view->opacity();
       break;
-    case ANIMATION_PROPERTY_TRANSFORM:
+    case AnimationProperty::TRANSFORM:
       value->transform = view->transform();
       break;
   }
 }
 
 // Sets the value of |property| from |value| into |view|.
 void SetViewPropertyFromValue(ServerView* view,
                               AnimationProperty property,
                               const ScheduledAnimationValue& value) {
   switch (property) {
-    case ANIMATION_PROPERTY_NONE:
+    case AnimationProperty::NONE:
       break;
-    case ANIMATION_PROPERTY_OPACITY:
+    case AnimationProperty::OPACITY:
       view->SetOpacity(value.float_value);
       break;
-    case ANIMATION_PROPERTY_TRANSFORM:
+    case AnimationProperty::TRANSFORM:
       view->SetTransform(value.transform);
       break;
   }
 }
 
 // Sets the value of |property| into |view| between two points.
 void SetViewPropertyFromValueBetween(ServerView* view,
                                      AnimationProperty property,
                                      double value,
                                      gfx::Tween::Type tween_type,
                                      const ScheduledAnimationValue& start,
                                      const ScheduledAnimationValue& target) {
   const double tween_value = gfx::Tween::CalculateValue(tween_type, value);
   switch (property) {
-    case ANIMATION_PROPERTY_NONE:
+    case AnimationProperty::NONE:
       break;
-    case ANIMATION_PROPERTY_OPACITY:
+    case AnimationProperty::OPACITY:
       view->SetOpacity(gfx::Tween::FloatValueBetween(
           tween_value, start.float_value, target.float_value));
       break;
-    case ANIMATION_PROPERTY_TRANSFORM:
+    case AnimationProperty::TRANSFORM:
       view->SetTransform(gfx::Tween::TransformValueBetween(
           tween_value, start.transform, target.transform));
       break;
   }
 }
 
 gfx::Tween::Type AnimationTypeToTweenType(mojo::AnimationTweenType type) {
   switch (type) {
-    case mojo::ANIMATION_TWEEN_TYPE_LINEAR:
+    case mojo::AnimationTweenType::LINEAR:
       return gfx::Tween::LINEAR;
-    case mojo::ANIMATION_TWEEN_TYPE_EASE_IN:
+    case mojo::AnimationTweenType::EASE_IN:
       return gfx::Tween::EASE_IN;
-    case mojo::ANIMATION_TWEEN_TYPE_EASE_OUT:
+    case mojo::AnimationTweenType::EASE_OUT:
       return gfx::Tween::EASE_OUT;
-    case mojo::ANIMATION_TWEEN_TYPE_EASE_IN_OUT:
+    case mojo::AnimationTweenType::EASE_IN_OUT:
       return gfx::Tween::EASE_IN_OUT;
   }
   return gfx::Tween::LINEAR;
 }
 
 void ConvertToScheduledValue(const mojo::AnimationValue& transport_value,
                              ScheduledAnimationValue* value) {
   value->float_value = transport_value.float_value;
   value->transform = transport_value.transform.To<gfx::Transform>();
 }
 
 void ConvertToScheduledElement(const mojo::AnimationElement& transport_element,
                                ScheduledAnimationElement* element) {
   element->property = transport_element.property;
   element->duration =
       base::TimeDelta::FromMicroseconds(transport_element.duration);
   element->tween_type = AnimationTypeToTweenType(transport_element.tween_type);
-  if (transport_element.property != ANIMATION_PROPERTY_NONE) {
+  if (transport_element.property != AnimationProperty::NONE) {
     if (transport_element.start_value.get()) {
       element->is_start_valid = true;
       ConvertToScheduledValue(*transport_element.start_value,
                               &(element->start_value));
     } else {
       element->is_start_valid = false;
     }
     ConvertToScheduledValue(*transport_element.target_value,
                             &(element->target_value));
   }
 }
 
 bool IsAnimationValueValid(AnimationProperty property,
                            const mojo::AnimationValue& value) {
   switch (property) {
-    case ANIMATION_PROPERTY_NONE:
+    case AnimationProperty::NONE:
       NOTREACHED();
       return false;
-    case ANIMATION_PROPERTY_OPACITY:
+    case AnimationProperty::OPACITY:
       return value.float_value >= 0.f && value.float_value <= 1.f;
-    case ANIMATION_PROPERTY_TRANSFORM:
+    case AnimationProperty::TRANSFORM:
       return value.transform.get() && value.transform->matrix.size() == 16u;
   }
   return false;
 }
 
 bool IsAnimationElementValid(const mojo::AnimationElement& element) {
-  if (element.property == ANIMATION_PROPERTY_NONE)
+  if (element.property == AnimationProperty::NONE)
     return true;  // None is a pause and doesn't need any values.
   if (element.start_value.get() &&
       !IsAnimationValueValid(element.property, *element.start_value))
     return false;
   // For all other properties we require a target.
   return element.target_value.get() &&
          IsAnimationValueValid(element.property, *element.target_value);
 }
 
 bool IsAnimationSequenceValid(const mojo::AnimationSequence& sequence) {
@@ skipping 14 matching lines @@
     if (!IsAnimationSequenceValid(*transport_group.sequences[i]))
       return false;
   }
   return true;
 }
 
 // If the start value for |element| isn't valid, the value for the property
 // is obtained from |view| and placed into |element|.
 void GetStartValueFromViewIfNecessary(const ServerView* view,
                                       ScheduledAnimationElement* element) {
-  if (element->property != ANIMATION_PROPERTY_NONE &&
+  if (element->property != AnimationProperty::NONE &&
       !element->is_start_valid) {
     GetValueFromView(view, element->property, &(element->start_value));
   }
 }
 
 void GetScheduledAnimationProperties(const Sequences& sequences,
                                      std::set<AnimationProperty>* properties) {
   for (const ScheduledAnimationSequence& sequence : sequences) {
     for (const ScheduledAnimationElement& element : sequence.elements)
       properties->insert(element.property);
@@ skipping 81 matching lines @@
 }
 
 }  // namespace
 
 ScheduledAnimationValue::ScheduledAnimationValue() {
 }
 ScheduledAnimationValue::~ScheduledAnimationValue() {
 }
 
 ScheduledAnimationElement::ScheduledAnimationElement()
-    : property(ANIMATION_PROPERTY_OPACITY),
+    : property(AnimationProperty::OPACITY),
       tween_type(gfx::Tween::EASE_IN),
       is_start_valid(false) {
 }
 ScheduledAnimationElement::~ScheduledAnimationElement() {
 }
 
 ScheduledAnimationSequence::ScheduledAnimationSequence()
     : run_until_stopped(false), cycle_count(0), current_index(0u) {
 }
 ScheduledAnimationSequence::~ScheduledAnimationSequence() {
@@ skipping 31 matching lines @@
 void ScheduledAnimationGroup::SetValuesToTargetValuesForPropertiesNotIn(
     const ScheduledAnimationGroup& other) {
   std::set<AnimationProperty> our_properties;
   GetScheduledAnimationProperties(sequences_, &our_properties);
 
   std::set<AnimationProperty> other_properties;
   GetScheduledAnimationProperties(other.sequences_, &other_properties);
 
   for (AnimationProperty property : our_properties) {
     if (other_properties.count(property) == 0 &&
-        property != ANIMATION_PROPERTY_NONE) {
+        property != AnimationProperty::NONE) {
       SetPropertyToTargetProperty(view_, property, sequences_);
     }
   }
 }
 
 bool ScheduledAnimationGroup::Tick(base::TimeTicks time) {
   for (Sequences::iterator i = sequences_.begin(); i != sequences_.end();) {
     if (!AdvanceSequence(view_, &(*i), time)) {
       i = sequences_.erase(i);
       continue;
@@ skipping 11 matching lines @@
   return sequences_.empty();
 }
 
 ScheduledAnimationGroup::ScheduledAnimationGroup(ServerView* view,
                                                  uint32_t id,
                                                  base::TimeTicks time_scheduled)
     : view_(view), id_(id), time_scheduled_(time_scheduled) {
 }
 
 }  // namespace view_manager