Revert "Pull chromium at 2c3ffb2355a27c32f45e508ef861416b820c823b"

cc/animation/transform_operation.cc

 // Copyright 2013 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.
 
 // Needed on Windows to get |M_PI| from <cmath>
 #ifdef _WIN32
 #define _USE_MATH_DEFINES
 #endif
 
 #include <algorithm>
@@ skipping 81 matching lines @@
 
 bool TransformOperation::BlendTransformOperations(
     const TransformOperation* from,
     const TransformOperation* to,
     SkMScalar progress,
     gfx::Transform* result) {
   if (IsOperationIdentity(from) && IsOperationIdentity(to))
     return true;
 
   TransformOperation::Type interpolation_type =
-      TransformOperation::TRANSFORM_OPERATION_IDENTITY;
+      TransformOperation::TransformOperationIdentity;
   if (IsOperationIdentity(to))
     interpolation_type = from->type;
   else
     interpolation_type = to->type;
 
   switch (interpolation_type) {
-    case TransformOperation::TRANSFORM_OPERATION_TRANSLATE: {
+  case TransformOperation::TransformOperationTranslate: {
     SkMScalar from_x = IsOperationIdentity(from) ? 0 : from->translate.x;
     SkMScalar from_y = IsOperationIdentity(from) ? 0 : from->translate.y;
     SkMScalar from_z = IsOperationIdentity(from) ? 0 : from->translate.z;
     SkMScalar to_x = IsOperationIdentity(to) ? 0 : to->translate.x;
     SkMScalar to_y = IsOperationIdentity(to) ? 0 : to->translate.y;
     SkMScalar to_z = IsOperationIdentity(to) ? 0 : to->translate.z;
     result->Translate3d(BlendSkMScalars(from_x, to_x, progress),
                         BlendSkMScalars(from_y, to_y, progress),
                         BlendSkMScalars(from_z, to_z, progress));
     break;
   }
-  case TransformOperation::TRANSFORM_OPERATION_ROTATE: {
+  case TransformOperation::TransformOperationRotate: {
     SkMScalar axis_x = 0;
     SkMScalar axis_y = 0;
     SkMScalar axis_z = 1;
     SkMScalar from_angle = 0;
     SkMScalar to_angle = IsOperationIdentity(to) ? 0 : to->rotate.angle;
     if (ShareSameAxis(from, to, &axis_x, &axis_y, &axis_z, &from_angle)) {
       result->RotateAbout(gfx::Vector3dF(axis_x, axis_y, axis_z),
                           BlendSkMScalars(from_angle, to_angle, progress));
     } else {
       gfx::Transform to_matrix;
       if (!IsOperationIdentity(to))
         to_matrix = to->matrix;
       gfx::Transform from_matrix;
       if (!IsOperationIdentity(from))
         from_matrix = from->matrix;
       *result = to_matrix;
       if (!result->Blend(from_matrix, progress))
         return false;
     }
     break;
   }
-  case TransformOperation::TRANSFORM_OPERATION_SCALE: {
+  case TransformOperation::TransformOperationScale: {
     SkMScalar from_x = IsOperationIdentity(from) ? 1 : from->scale.x;
     SkMScalar from_y = IsOperationIdentity(from) ? 1 : from->scale.y;
     SkMScalar from_z = IsOperationIdentity(from) ? 1 : from->scale.z;
     SkMScalar to_x = IsOperationIdentity(to) ? 1 : to->scale.x;
     SkMScalar to_y = IsOperationIdentity(to) ? 1 : to->scale.y;
     SkMScalar to_z = IsOperationIdentity(to) ? 1 : to->scale.z;
     result->Scale3d(BlendSkMScalars(from_x, to_x, progress),
                     BlendSkMScalars(from_y, to_y, progress),
                     BlendSkMScalars(from_z, to_z, progress));
     break;
   }
-  case TransformOperation::TRANSFORM_OPERATION_SKEW: {
+  case TransformOperation::TransformOperationSkew: {
     SkMScalar from_x = IsOperationIdentity(from) ? 0 : from->skew.x;
     SkMScalar from_y = IsOperationIdentity(from) ? 0 : from->skew.y;
     SkMScalar to_x = IsOperationIdentity(to) ? 0 : to->skew.x;
     SkMScalar to_y = IsOperationIdentity(to) ? 0 : to->skew.y;
     result->SkewX(BlendSkMScalars(from_x, to_x, progress));
     result->SkewY(BlendSkMScalars(from_y, to_y, progress));
     break;
   }
-  case TransformOperation::TRANSFORM_OPERATION_PERSPECTIVE: {
+  case TransformOperation::TransformOperationPerspective: {
     SkMScalar from_perspective_depth =
         IsOperationIdentity(from) ? std::numeric_limits<SkMScalar>::max()
                                   : from->perspective_depth;
     SkMScalar to_perspective_depth =
         IsOperationIdentity(to) ? std::numeric_limits<SkMScalar>::max()
                                 : to->perspective_depth;
     if (from_perspective_depth == 0.f || to_perspective_depth == 0.f)
       return false;
 
     SkMScalar blended_perspective_depth = BlendSkMScalars(
         1.f / from_perspective_depth, 1.f / to_perspective_depth, progress);
 
     if (blended_perspective_depth == 0.f)
       return false;
 
     result->ApplyPerspectiveDepth(1.f / blended_perspective_depth);
     break;
   }
-  case TransformOperation::TRANSFORM_OPERATION_MATRIX: {
+  case TransformOperation::TransformOperationMatrix: {
     gfx::Transform to_matrix;
     if (!IsOperationIdentity(to))
       to_matrix = to->matrix;
     gfx::Transform from_matrix;
     if (!IsOperationIdentity(from))
       from_matrix = from->matrix;
     *result = to_matrix;
     if (!result->Blend(from_matrix, progress))
       return false;
     break;
   }
-  case TransformOperation::TRANSFORM_OPERATION_IDENTITY:
+  case TransformOperation::TransformOperationIdentity:
     // Do nothing.
     break;
   }
 
   return true;
 }
 
 // If p = (px, py) is a point in the plane being rotated about (0, 0, nz), this
 // function computes the angles we would have to rotate from p to get to
 // (length(p), 0), (-length(p), 0), (0, length(p)), (0, -length(p)). If nz is
@@ skipping 162 matching lines @@
                                              SkMScalar max_progress,
                                              gfx::BoxF* bounds) {
   bool is_identity_from = IsOperationIdentity(from);
   bool is_identity_to = IsOperationIdentity(to);
   if (is_identity_from && is_identity_to) {
     *bounds = box;
     return true;
   }
 
   TransformOperation::Type interpolation_type =
-      TransformOperation::TRANSFORM_OPERATION_IDENTITY;
+      TransformOperation::TransformOperationIdentity;
   if (is_identity_to)
     interpolation_type = from->type;
   else
     interpolation_type = to->type;
 
   switch (interpolation_type) {
-    case TransformOperation::TRANSFORM_OPERATION_IDENTITY:
+    case TransformOperation::TransformOperationIdentity:
       *bounds = box;
       return true;
-    case TransformOperation::TRANSFORM_OPERATION_TRANSLATE:
-    case TransformOperation::TRANSFORM_OPERATION_SKEW:
-    case TransformOperation::TRANSFORM_OPERATION_PERSPECTIVE:
-    case TransformOperation::TRANSFORM_OPERATION_SCALE: {
+    case TransformOperation::TransformOperationTranslate:
+    case TransformOperation::TransformOperationSkew:
+    case TransformOperation::TransformOperationPerspective:
+    case TransformOperation::TransformOperationScale: {
       gfx::Transform from_transform;
       gfx::Transform to_transform;
       if (!BlendTransformOperations(from, to, min_progress, &from_transform) ||
           !BlendTransformOperations(from, to, max_progress, &to_transform))
         return false;
 
       *bounds = box;
       from_transform.TransformBox(bounds);
 
       gfx::BoxF to_box = box;
       to_transform.TransformBox(&to_box);
       bounds->ExpandTo(to_box);
 
       return true;
     }
-    case TransformOperation::TRANSFORM_OPERATION_ROTATE: {
+    case TransformOperation::TransformOperationRotate: {
       SkMScalar axis_x = 0;
       SkMScalar axis_y = 0;
       SkMScalar axis_z = 1;
       SkMScalar from_angle = 0;
       if (!ShareSameAxis(from, to, &axis_x, &axis_y, &axis_z, &from_angle))
         return false;
 
       bool first_point = true;
       for (int i = 0; i < 8; ++i) {
         gfx::Point3F corner = box.origin();
         corner += gfx::Vector3dF(i & 1 ? box.width() : 0.f,
                                  i & 2 ? box.height() : 0.f,
                                  i & 4 ? box.depth() : 0.f);
         gfx::BoxF box_for_arc;
         BoundingBoxForArc(
             corner, from, to, min_progress, max_progress, &box_for_arc);
         if (first_point)
           *bounds = box_for_arc;
         else
           bounds->Union(box_for_arc);
         first_point = false;
       }
       return true;
     }
-    case TransformOperation::TRANSFORM_OPERATION_MATRIX:
+    case TransformOperation::TransformOperationMatrix:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace cc