Type conversion fixes, ui/gfx/ edition.

ui/gfx/transform.cc

 // Copyright (c) 2012 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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "ui/gfx/transform.h"
 
 #include <cmath>
@@ skipping 135 matching lines @@
                0, 0, 1);
     matrix_.preConcat(rot);
   }
 }
 
 void Transform::RotateAbout(const Vector3dF& axis, double degrees) {
   if (matrix_.isIdentity()) {
     matrix_.setRotateDegreesAbout(SkFloatToMScalar(axis.x()),
                                   SkFloatToMScalar(axis.y()),
                                   SkFloatToMScalar(axis.z()),
-                                  degrees);
+                                  SkDoubleToMScalar(degrees));
   } else {
     SkMatrix44 rot(SkMatrix44::kUninitialized_Constructor);
     rot.setRotateDegreesAbout(SkFloatToMScalar(axis.x()),
                               SkFloatToMScalar(axis.y()),
                               SkFloatToMScalar(axis.z()),
-                              degrees);
+                              SkDoubleToMScalar(degrees));
     matrix_.preConcat(rot);
   }
 }
 
 void Transform::Scale(SkMScalar x, SkMScalar y) { matrix_.preScale(x, y, 1); }
 
 void Transform::Scale3d(SkMScalar x, SkMScalar y, SkMScalar z) {
   matrix_.preScale(x, y, z);
 }
 
 void Transform::Translate(SkMScalar x, SkMScalar y) {
   matrix_.preTranslate(x, y, 0);
 }
 
 void Transform::Translate3d(SkMScalar x, SkMScalar y, SkMScalar z) {
   matrix_.preTranslate(x, y, z);
 }
 
 void Transform::SkewX(double angle_x) {
-  if (matrix_.isIdentity())
+  if (matrix_.isIdentity()) {
     matrix_.set(0, 1, TanDegrees(angle_x));
-  else {
+  } else {
     SkMatrix44 skew(SkMatrix44::kIdentity_Constructor);
     skew.set(0, 1, TanDegrees(angle_x));
     matrix_.preConcat(skew);
   }
 }
 
 void Transform::SkewY(double angle_y) {
-  if (matrix_.isIdentity())
+  if (matrix_.isIdentity()) {
     matrix_.set(1, 0, TanDegrees(angle_y));
-  else {
+  } else {
     SkMatrix44 skew(SkMatrix44::kIdentity_Constructor);
     skew.set(1, 0, TanDegrees(angle_y));
     matrix_.preConcat(skew);
   }
 }
 
 void Transform::ApplyPerspectiveDepth(SkMScalar depth) {
   if (depth == 0)
     return;
-  if (matrix_.isIdentity())
-    matrix_.set(3, 2, -1.0 / depth);
-  else {
+  if (matrix_.isIdentity()) {
+    matrix_.set(3, 2, -SK_MScalar1 / depth);
+  } else {
     SkMatrix44 m(SkMatrix44::kIdentity_Constructor);
-    m.set(3, 2, -1.0 / depth);
+    m.set(3, 2, -SK_MScalar1 / depth);
     matrix_.preConcat(m);
   }
 }
 
 void Transform::PreconcatTransform(const Transform& transform) {
   matrix_.preConcat(transform.matrix_);
 }
 
 void Transform::ConcatTransform(const Transform& transform) {
   matrix_.postConcat(transform.matrix_);
@@ skipping 290 matching lines @@
   } else {
     point->SetPoint(p[0], p[1], p[2]);
   }
 }
 
 void Transform::TransformPointInternal(const SkMatrix44& xform,
                                        Point* point) const {
   if (xform.isIdentity())
     return;
 
-  SkMScalar p[4] = {SkFloatToMScalar(point->x()), SkFloatToMScalar(point->y()),
+  SkMScalar p[4] = {SkIntToMScalar(point->x()), SkIntToMScalar(point->y()),
                     0, 1};
 
   xform.mapMScalars(p);
 
   point->SetPoint(ToRoundedInt(p[0]), ToRoundedInt(p[1]));
 }
 
 std::string Transform::ToString() const {
   return base::StringPrintf(
       "[ %+0.4f %+0.4f %+0.4f %+0.4f  \n"
@@ skipping 12 matching lines @@
       matrix_.get(2, 1),
       matrix_.get(2, 2),
       matrix_.get(2, 3),
       matrix_.get(3, 0),
       matrix_.get(3, 1),
       matrix_.get(3, 2),
       matrix_.get(3, 3));
 }
 
 }  // namespace gfx