Remove SkFloatToScalar.

Now that SkScalar is always float (it may someday be double, but
float to double is trivial), remove callers of SkFloatToScalar,
which is deprecated in Skia.

BUG:13694396

Change-Id: I524a9bb6f7702bc810bac55fb9d2cd5361a01cf7

15 files changed, 192 insertions, 375 deletions

diff --git a/core/jni/android/graphics/Camera.cpp b/core/jni/android/graphics/Camera.cpp
index 54d448e..ef57e3d 100644
--- a/core/jni/android/graphics/Camera.cpp
+++ b/core/jni/android/graphics/Camera.cpp
@@ -32,39 +32,39 @@ static void Camera_translate(JNIEnv* env, jobject obj,
                              jfloat dx, jfloat dy, jfloat dz) {
     jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
     Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
-    v->translate(SkFloatToScalar(dx), SkFloatToScalar(dy), SkFloatToScalar(dz));
+    v->translate(dx, dy, dz);
 }
 
 static void Camera_rotateX(JNIEnv* env, jobject obj, jfloat degrees) {
     jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
     Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
-    v->rotateX(SkFloatToScalar(degrees));
+    v->rotateX(degrees);
 }
 
 static void Camera_rotateY(JNIEnv* env, jobject obj, jfloat degrees) {
     jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
     Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
-    v->rotateY(SkFloatToScalar(degrees));
+    v->rotateY(degrees);
 }
 
 static void Camera_rotateZ(JNIEnv* env, jobject obj, jfloat degrees) {
     jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
     Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
-    v->rotateZ(SkFloatToScalar(degrees));
+    v->rotateZ(degrees);
 }
 
 static void Camera_rotate(JNIEnv* env, jobject obj, jfloat x, jfloat y, jfloat z) {
     jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
     Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
-    v->rotateX(SkFloatToScalar(x));
-    v->rotateY(SkFloatToScalar(y));
-    v->rotateZ(SkFloatToScalar(z));
+    v->rotateX(x);
+    v->rotateY(y);
+    v->rotateZ(z);
 }
 
 static void Camera_setLocation(JNIEnv* env, jobject obj, jfloat x, jfloat y, jfloat z) {
     jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
     Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
-    v->setCameraLocation(SkFloatToScalar(x), SkFloatToScalar(y), SkFloatToScalar(z));
+    v->setCameraLocation(x, y, z);
 }
 
 static jfloat Camera_getLocationX(JNIEnv* env, jobject obj) {
@@ -103,8 +103,7 @@ static jfloat Camera_dotWithNormal(JNIEnv* env, jobject obj,
                                   jfloat x, jfloat y, jfloat z) {
     jlong viewHandle = env->GetLongField(obj, gNativeInstanceFieldID);
     Sk3DView* v = reinterpret_cast<Sk3DView*>(viewHandle);
-    SkScalar dot = v->dotWithNormal(SkFloatToScalar(x), SkFloatToScalar(y),
-                                    SkFloatToScalar(z));
+    SkScalar dot = v->dotWithNormal(x, y, z);
     return SkScalarToFloat(dot);
 }
 
diff --git a/core/jni/android/graphics/Canvas.cpp b/core/jni/android/graphics/Canvas.cpp
index 27ed0f6..5148266 100644
--- a/core/jni/android/graphics/Canvas.cpp
+++ b/core/jni/android/graphics/Canvas.cpp
@@ -179,8 +179,7 @@ public:
         SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
         SkPaint* paint  = reinterpret_cast<SkPaint*>(paintHandle);
         SkRect bounds;
-        bounds.set(SkFloatToScalar(l), SkFloatToScalar(t), SkFloatToScalar(r),
-                   SkFloatToScalar(b));
+        bounds.set(l, t, r, b);
         int result = canvas->saveLayer(&bounds, paint,
                                       static_cast<SkCanvas::SaveFlags>(flags));
         return static_cast<jint>(result);
@@ -205,8 +204,7 @@ public:
                                 jint alpha, jint flags) {
         SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
         SkRect  bounds;
-        bounds.set(SkFloatToScalar(l), SkFloatToScalar(t), SkFloatToScalar(r),
-                   SkFloatToScalar(b));
+        bounds.set(l, t, r, b);
         int result = canvas->saveLayerAlpha(&bounds, alpha,
                                       static_cast<SkCanvas::SaveFlags>(flags));
         return static_cast<jint>(result);
@@ -240,29 +238,22 @@ public:
 
     static void translate(JNIEnv* env, jobject jcanvas, jfloat dx, jfloat dy) {
         NPE_CHECK_RETURN_VOID(env, jcanvas);
-        SkScalar dx_ = SkFloatToScalar(dx);
-        SkScalar dy_ = SkFloatToScalar(dy);
-        (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->translate(dx_, dy_);
+        (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->translate(dx, dy);
     }
 
     static void scale__FF(JNIEnv* env, jobject jcanvas, jfloat sx, jfloat sy) {
         NPE_CHECK_RETURN_VOID(env, jcanvas);
-        SkScalar sx_ = SkFloatToScalar(sx);
-        SkScalar sy_ = SkFloatToScalar(sy);
-        (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->scale(sx_, sy_);
+        (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->scale(sx, sy);
     }
 
     static void rotate__F(JNIEnv* env, jobject jcanvas, jfloat degrees) {
         NPE_CHECK_RETURN_VOID(env, jcanvas);
-        SkScalar degrees_ = SkFloatToScalar(degrees);
-        (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->rotate(degrees_);
+        (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->rotate(degrees);
     }
 
     static void skew__FF(JNIEnv* env, jobject jcanvas, jfloat sx, jfloat sy) {
         NPE_CHECK_RETURN_VOID(env, jcanvas);
-        SkScalar sx_ = SkFloatToScalar(sx);
-        SkScalar sy_ = SkFloatToScalar(sy);
-        (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->skew(sx_, sy_);
+        (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->skew(sx, sy);
     }
 
     static void concat(JNIEnv* env, jobject, jlong canvasHandle,
@@ -287,8 +278,7 @@ public:
                                   jfloat top, jfloat right, jfloat bottom) {
         NPE_CHECK_RETURN_ZERO(env, jcanvas);
         SkRect  r;
-        r.set(SkFloatToScalar(left), SkFloatToScalar(top),
-              SkFloatToScalar(right), SkFloatToScalar(bottom));
+        r.set(left, top, right, bottom);
         SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas);
         c->clipRect(r);
         return hasNonEmptyClip(*c);
@@ -329,8 +319,7 @@ public:
                              jint op) {
         SkRect rect;
         SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
-        rect.set(SkFloatToScalar(left), SkFloatToScalar(top),
-                 SkFloatToScalar(right), SkFloatToScalar(bottom));
+        rect.set(left, top, right, bottom);
         canvas->clipRect(rect, static_cast<SkRegion::Op>(op));
         return hasNonEmptyClip(*canvas);
     }
@@ -378,8 +367,7 @@ public:
                                        jfloat bottom) {
         SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
         SkRect r;
-        r.set(SkFloatToScalar(left), SkFloatToScalar(top),
-              SkFloatToScalar(right), SkFloatToScalar(bottom));
+        r.set(left, top, right, bottom);
         bool result = canvas->quickReject(r);
         return result ? JNI_TRUE : JNI_FALSE;
     }
@@ -441,7 +429,7 @@ public:
         SkPoint* pts = storage.get();
         const float* src = floats + offset;
         for (int i = 0; i < count; i++) {
-            pts[i].set(SkFloatToScalar(src[0]), SkFloatToScalar(src[1]));
+            pts[i].set(src[0], src[1]);
             src += 2;
         }
         canvas->drawPoints(mode, count, pts, paint);
@@ -466,7 +454,7 @@ public:
         SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
         const SkPaint& paint = *GraphicsJNI::getNativePaint(env, jpaint);
 
-        canvas->drawPoint(SkFloatToScalar(x), SkFloatToScalar(y), paint);
+        canvas->drawPoint(x, y, paint);
     }
 
     static void drawLine__FFFFPaint(JNIEnv* env, jobject, jlong canvasHandle,
@@ -474,9 +462,7 @@ public:
                                     jfloat stopY, jlong paintHandle) {
         SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
         SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
-        canvas->drawLine(SkFloatToScalar(startX), SkFloatToScalar(startY),
-                         SkFloatToScalar(stopX), SkFloatToScalar(stopY),
-                         *paint);
+        canvas->drawLine(startX, startY, stopX, stopY, *paint);
     }
 
     static void drawRect__RectFPaint(JNIEnv* env, jobject, jlong canvasHandle,
@@ -493,11 +479,7 @@ public:
                                     jfloat bottom, jlong paintHandle) {
         SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
         SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
-        SkScalar left_ = SkFloatToScalar(left);
-        SkScalar top_ = SkFloatToScalar(top);
-        SkScalar right_ = SkFloatToScalar(right);
-        SkScalar bottom_ = SkFloatToScalar(bottom);
-        canvas->drawRectCoords(left_, top_, right_, bottom_, *paint);
+        canvas->drawRectCoords(left, top, right, bottom, *paint);
     }
 
     static void drawOval(JNIEnv* env, jobject, jlong canvasHandle, jobject joval,
@@ -513,8 +495,7 @@ public:
                            jfloat cy, jfloat radius, jlong paintHandle) {
         SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
         SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
-        canvas->drawCircle(SkFloatToScalar(cx), SkFloatToScalar(cy),
-                           SkFloatToScalar(radius), *paint);
+        canvas->drawCircle(cx, cy, radius, *paint);
     }
 
     static void drawArc(JNIEnv* env, jobject, jlong canvasHandle, jobject joval,
@@ -524,8 +505,7 @@ public:
         SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
         SkRect oval;
         GraphicsJNI::jrectf_to_rect(env, joval, &oval);
-        canvas->drawArc(oval, SkFloatToScalar(startAngle),
-                        SkFloatToScalar(sweepAngle), useCenter, *paint);
+        canvas->drawArc(oval, startAngle, sweepAngle, useCenter, *paint);
     }
 
     static void drawRoundRect(JNIEnv* env, jobject, jlong canvasHandle,
@@ -535,8 +515,7 @@ public:
         SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
         SkRect rect;
         GraphicsJNI::jrectf_to_rect(env, jrect, &rect);
-        canvas->drawRoundRect(rect, SkFloatToScalar(rx), SkFloatToScalar(ry),
-                              *paint);
+        canvas->drawRoundRect(rect, rx, ry, *paint);
     }
 
     static void drawPath(JNIEnv* env, jobject, jlong canvasHandle, jlong pathHandle,
@@ -555,8 +534,6 @@ public:
         SkCanvas* canvas = reinterpret_cast<SkCanvas*>(canvasHandle);
         SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
         SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
-        SkScalar left_ = SkFloatToScalar(left);
-        SkScalar top_ = SkFloatToScalar(top);
 
         if (canvasDensity == bitmapDensity || canvasDensity == 0
                 || bitmapDensity == 0) {
@@ -566,14 +543,14 @@ public:
                     filteredPaint = *paint;
                 }
                 filteredPaint.setFilterLevel(SkPaint::kLow_FilterLevel);
-                canvas->drawBitmap(*bitmap, left_, top_, &filteredPaint);
+                canvas->drawBitmap(*bitmap, left, top, &filteredPaint);
             } else {
-                canvas->drawBitmap(*bitmap, left_, top_, paint);
+                canvas->drawBitmap(*bitmap, left, top, paint);
             }
         } else {
             canvas->save();
-            SkScalar scale = SkFloatToScalar(canvasDensity / (float)bitmapDensity);
-            canvas->translate(left_, top_);
+            SkScalar scale = canvasDensity / (float)bitmapDensity;
+            canvas->translate(left, top);
             canvas->scale(scale, scale);
 
             SkPaint filteredPaint;
@@ -655,8 +632,7 @@ public:
             return;
         }
 
-        canvas->drawBitmap(bitmap, SkFloatToScalar(x), SkFloatToScalar(y),
-                           paint);
+        canvas->drawBitmap(bitmap, x, y, paint);
     }
 
     static void drawBitmapMatrix(JNIEnv* env, jobject, jlong canvasHandle,
@@ -858,8 +834,8 @@ public:
             MinikinFontSkia *mfs = static_cast<MinikinFontSkia *>(layout->getFont(i));
             skFace = mfs->GetSkTypeface();
             glyphs[i] = layout->getGlyphId(i);
-            pos[i].fX = SkFloatToScalar(x + layout->getX(i));
-            pos[i].fY = SkFloatToScalar(y + layout->getY(i));
+            pos[i].fX = x + layout->getX(i);
+            pos[i].fY = y + layout->getY(i);
             if (i > 0 && skFace != lastFace) {
                 paint->setTypeface(lastFace);
                 canvas->drawPosText(glyphs + start, (i - start) << 1, pos + start, *paint);
@@ -936,22 +912,18 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l
         flags = paint->getFlags();
     }
     if (flags & (SkPaint::kUnderlineText_Flag | SkPaint::kStrikeThruText_Flag)) {
-        SkScalar left = SkFloatToScalar(x);
-        SkScalar right = SkFloatToScalar(x + length);
+        SkScalar left = x;
+        SkScalar right = x + length;
         float textSize = paint->getTextSize();
         float strokeWidth = fmax(textSize * kStdUnderline_Thickness, 1.0f);
         if (flags & SkPaint::kUnderlineText_Flag) {
-            SkScalar top = SkFloatToScalar(y + textSize * kStdUnderline_Offset
-                    - 0.5f * strokeWidth);
-            SkScalar bottom = SkFloatToScalar(y + textSize * kStdUnderline_Offset
-                    + 0.5f * strokeWidth);
+            SkScalar top = y + textSize * kStdUnderline_Offset - 0.5f * strokeWidth;
+            SkScalar bottom = y + textSize * kStdUnderline_Offset + 0.5f * strokeWidth;
             canvas->drawRectCoords(left, top, right, bottom, *paint);
         }
         if (flags & SkPaint::kStrikeThruText_Flag) {
-            SkScalar top = SkFloatToScalar(y + textSize * kStdStrikeThru_Offset
-                    - 0.5f * strokeWidth);
-            SkScalar bottom = SkFloatToScalar(y + textSize * kStdStrikeThru_Offset
-                    + 0.5f * strokeWidth);
+            SkScalar top = y + textSize * kStdStrikeThru_Offset - 0.5f * strokeWidth;
+            SkScalar bottom = y + textSize * kStdStrikeThru_Offset + 0.5f * strokeWidth;
             canvas->drawRectCoords(left, top, right, bottom, *paint);
         }
     }
@@ -967,8 +939,8 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l
             int index, int count, jfloat x, jfloat y, int flags, SkPaint* paint) {
         SkPoint* posPtr = new SkPoint[count];
         for (int indx = 0; indx < count; indx++) {
-            posPtr[indx].fX = SkFloatToScalar(x + posArray[indx * 2]);
-            posPtr[indx].fY = SkFloatToScalar(y + posArray[indx * 2 + 1]);
+            posPtr[indx].fX = x + posArray[indx * 2];
+            posPtr[indx].fY = y + posArray[indx * 2 + 1];
         }
         canvas->drawPosText(glyphArray, count << 1, posPtr, *paint);
         delete[] posPtr;
@@ -1016,8 +988,8 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l
         SkPoint* posPtr = posCount > 0 ? new SkPoint[posCount] : NULL;
         int indx;
         for (indx = 0; indx < posCount; indx++) {
-            posPtr[indx].fX = SkFloatToScalar(posArray[indx << 1]);
-            posPtr[indx].fY = SkFloatToScalar(posArray[(indx << 1) + 1]);
+            posPtr[indx].fX = posArray[indx << 1];
+            posPtr[indx].fY = posArray[(indx << 1) + 1];
         }
 
         SkPaint::TextEncoding encoding = paint->getTextEncoding();
@@ -1047,8 +1019,8 @@ static void doDrawTextDecorations(SkCanvas* canvas, jfloat x, jfloat y, jfloat l
         SkPoint* posPtr = posCount > 0 ? new SkPoint[posCount] : NULL;
 
         for (int indx = 0; indx < posCount; indx++) {
-            posPtr[indx].fX = SkFloatToScalar(posArray[indx << 1]);
-            posPtr[indx].fY = SkFloatToScalar(posArray[(indx << 1) + 1]);
+            posPtr[indx].fX = posArray[indx << 1];
+            posPtr[indx].fY = posArray[(indx << 1) + 1];
         }
 
         SkPaint::TextEncoding encoding = paint->getTextEncoding();
diff --git a/core/jni/android/graphics/Graphics.cpp b/core/jni/android/graphics/Graphics.cpp
index 2883be9..e4c74b2 100644
--- a/core/jni/android/graphics/Graphics.cpp
+++ b/core/jni/android/graphics/Graphics.cpp
@@ -228,10 +228,10 @@ SkRect* GraphicsJNI::jrectf_to_rect(JNIEnv* env, jobject obj, SkRect* r)
 {
     SkASSERT(env->IsInstanceOf(obj, gRectF_class));
 
-    r->set(SkFloatToScalar(env->GetFloatField(obj, gRectF_leftFieldID)),
-           SkFloatToScalar(env->GetFloatField(obj, gRectF_topFieldID)),
-           SkFloatToScalar(env->GetFloatField(obj, gRectF_rightFieldID)),
-           SkFloatToScalar(env->GetFloatField(obj, gRectF_bottomFieldID)));
+    r->set(env->GetFloatField(obj, gRectF_leftFieldID),
+           env->GetFloatField(obj, gRectF_topFieldID),
+           env->GetFloatField(obj, gRectF_rightFieldID),
+           env->GetFloatField(obj, gRectF_bottomFieldID));
     return r;
 }
 
@@ -277,8 +277,8 @@ SkPoint* GraphicsJNI::jpointf_to_point(JNIEnv* env, jobject obj, SkPoint* point)
 {
     SkASSERT(env->IsInstanceOf(obj, gPointF_class));
 
-    point->set(SkFloatToScalar(env->GetIntField(obj, gPointF_xFieldID)),
-               SkFloatToScalar(env->GetIntField(obj, gPointF_yFieldID)));
+    point->set(env->GetIntField(obj, gPointF_xFieldID),
+               env->GetIntField(obj, gPointF_yFieldID));
     return point;
 }
 
diff --git a/core/jni/android/graphics/Interpolator.cpp b/core/jni/android/graphics/Interpolator.cpp
index ca04dfe..455f867 100644
--- a/core/jni/android/graphics/Interpolator.cpp
+++ b/core/jni/android/graphics/Interpolator.cpp
@@ -25,26 +25,15 @@ static void Interpolator_reset(JNIEnv* env, jobject clazz, jlong interpHandle, j
 static void Interpolator_setKeyFrame(JNIEnv* env, jobject clazz, jlong interpHandle, jint index, jint msec, jfloatArray valueArray, jfloatArray blendArray)
 {
     SkInterpolator* interp = reinterpret_cast<SkInterpolator*>(interpHandle);
-    SkScalar    blendStorage[4];
-    SkScalar*   blend = NULL;
 
-    AutoJavaFloatArray  autoValues(env, valueArray);
-    float* values = autoValues.ptr();
-    int i, n = autoValues.length();
-
-    SkAutoSTMalloc<16, SkScalar>  storage(n);
-    SkScalar*                     scalars = storage.get();
-
-    for (i = 0; i < n; i++)
-        scalars[i] = SkFloatToScalar(values[i]);
-
-    if (blendArray != NULL) {
-        AutoJavaFloatArray autoBlend(env, blendArray, 4);
-        values = autoBlend.ptr();
-        for (i = 0; i < 4; i++)
-            blendStorage[i] = SkFloatToScalar(values[i]);
-        blend = blendStorage;
-    }
+    AutoJavaFloatArray autoValues(env, valueArray);
+    AutoJavaFloatArray autoBlend(env, blendArray, 4);
+#ifdef SK_SCALAR_IS_FLOAT
+    SkScalar* scalars = autoValues.ptr();
+    SkScalar* blend = autoBlend.ptr();
+#else
+    #error Need to convert float array to SkScalar array before calling the following function.
+#endif
 
     interp->setKeyFrame(index, msec, scalars, blend);
 }
@@ -55,7 +44,7 @@ static void Interpolator_setRepeatMirror(JNIEnv* env, jobject clazz, jlong inter
     if (repeatCount > 32000)
         repeatCount = 32000;
 
-    interp->setRepeatCount(SkFloatToScalar(repeatCount));
+    interp->setRepeatCount(repeatCount);
     interp->setMirror(mirror != 0);
 }
 
diff --git a/core/jni/android/graphics/LayerRasterizer.cpp b/core/jni/android/graphics/LayerRasterizer.cpp
index 29e7db1..79dc275 100644
--- a/core/jni/android/graphics/LayerRasterizer.cpp
+++ b/core/jni/android/graphics/LayerRasterizer.cpp
@@ -12,7 +12,7 @@ public:
         const SkPaint* paint = reinterpret_cast<SkPaint *>(paintHandle);
         SkASSERT(layer);
         SkASSERT(paint);
-        layer->addLayer(*paint, SkFloatToScalar(dx), SkFloatToScalar(dy));
+        layer->addLayer(*paint, dx, dy);
     }
 };
 
diff --git a/core/jni/android/graphics/MaskFilter.cpp b/core/jni/android/graphics/MaskFilter.cpp
index 7dc0446..2113330 100644
--- a/core/jni/android/graphics/MaskFilter.cpp
+++ b/core/jni/android/graphics/MaskFilter.cpp
@@ -20,7 +20,7 @@ public:
     }
 
     static jlong createBlur(JNIEnv* env, jobject, jfloat radius, jint blurStyle) {
-        SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(SkFloatToScalar(radius));
+        SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(radius);
         SkMaskFilter* filter = SkBlurMaskFilter::Create(
                 (SkBlurMaskFilter::BlurStyle)blurStyle, sigma);
         ThrowIAE_IfNull(env, filter);
@@ -33,12 +33,12 @@ public:
         AutoJavaFloatArray autoDir(env, dirArray, 3);
         float* values = autoDir.ptr();
         for (int i = 0; i < 3; i++) {
-            direction[i] = SkFloatToScalar(values[i]);
+            direction[i] = values[i];
         }
 
-        SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(SkFloatToScalar(radius));
+        SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(radius);
         SkMaskFilter* filter =  SkBlurMaskFilter::CreateEmboss(sigma,
-                direction, SkFloatToScalar(ambient), SkFloatToScalar(specular));
+                direction, ambient, specular);
         ThrowIAE_IfNull(env, filter);
         return reinterpret_cast<jlong>(filter);
     }
diff --git a/core/jni/android/graphics/Matrix.cpp b/core/jni/android/graphics/Matrix.cpp
index d573aa8..23af860 100644
--- a/core/jni/android/graphics/Matrix.cpp
+++ b/core/jni/android/graphics/Matrix.cpp
@@ -65,63 +65,39 @@ public:
     }
      static void setTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar dx_ = SkFloatToScalar(dx);
-        SkScalar dy_ = SkFloatToScalar(dy);
-        obj->setTranslate(dx_, dy_);
+        obj->setTranslate(dx, dy);
     }
      static void setScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar sx_ = SkFloatToScalar(sx);
-        SkScalar sy_ = SkFloatToScalar(sy);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        obj->setScale(sx_, sy_, px_, py_);
+        obj->setScale(sx, sy, px, py);
     }
      static void setScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar sx_ = SkFloatToScalar(sx);
-        SkScalar sy_ = SkFloatToScalar(sy);
-        obj->setScale(sx_, sy_);
+        obj->setScale(sx, sy);
     }
      static void setRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar degrees_ = SkFloatToScalar(degrees);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        obj->setRotate(degrees_, px_, py_);
+        obj->setRotate(degrees, px, py);
     }
      static void setRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar degrees_ = SkFloatToScalar(degrees);
-        obj->setRotate(degrees_);
+        obj->setRotate(degrees);
     }
      static void setSinCos__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sinValue, jfloat cosValue, jfloat px, jfloat py) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar sinValue_ = SkFloatToScalar(sinValue);
-        SkScalar cosValue_ = SkFloatToScalar(cosValue);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        obj->setSinCos(sinValue_, cosValue_, px_, py_);
+        obj->setSinCos(sinValue, cosValue, px, py);
     }
      static void setSinCos__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sinValue, jfloat cosValue) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar sinValue_ = SkFloatToScalar(sinValue);
-        SkScalar cosValue_ = SkFloatToScalar(cosValue);
-        obj->setSinCos(sinValue_, cosValue_);
+        obj->setSinCos(sinValue, cosValue);
     }
      static void setSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar kx_ = SkFloatToScalar(kx);
-        SkScalar ky_ = SkFloatToScalar(ky);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        obj->setSkew(kx_, ky_, px_, py_);
+        obj->setSkew(kx, ky, px, py);
     }
      static void setSkew__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar kx_ = SkFloatToScalar(kx);
-        SkScalar ky_ = SkFloatToScalar(ky);
-        obj->setSkew(kx_, ky_);
+        obj->setSkew(kx, ky);
     }
      static void setConcat(JNIEnv* env, jobject clazz, jlong objHandle, jlong aHandle, jlong bHandle) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
@@ -132,55 +108,37 @@ public:
 
     static void preTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar dx_ = SkFloatToScalar(dx);
-        SkScalar dy_ = SkFloatToScalar(dy);
-        obj->preTranslate(dx_, dy_);
+        obj->preTranslate(dx, dy);
     }
 
     static void preScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar sx_ = SkFloatToScalar(sx);
-        SkScalar sy_ = SkFloatToScalar(sy);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        obj->preScale(sx_, sy_, px_, py_);
+        obj->preScale(sx, sy, px, py);
     }
 
     static void preScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar sx_ = SkFloatToScalar(sx);
-        SkScalar sy_ = SkFloatToScalar(sy);
-        obj->preScale(sx_, sy_);
+        obj->preScale(sx, sy);
     }
 
     static void preRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar degrees_ = SkFloatToScalar(degrees);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        obj->preRotate(degrees_, px_, py_);
+        obj->preRotate(degrees, px, py);
     }
 
     static void preRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar degrees_ = SkFloatToScalar(degrees);
-        obj->preRotate(degrees_);
+        obj->preRotate(degrees);
     }
 
     static void preSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar kx_ = SkFloatToScalar(kx);
-        SkScalar ky_ = SkFloatToScalar(ky);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        obj->preSkew(kx_, ky_, px_, py_);
+        obj->preSkew(kx, ky, px, py);
     }
 
     static void preSkew__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar kx_ = SkFloatToScalar(kx);
-        SkScalar ky_ = SkFloatToScalar(ky);
-        obj->preSkew(kx_, ky_);
+        obj->preSkew(kx, ky);
     }
 
     static void preConcat(JNIEnv* env, jobject clazz, jlong objHandle, jlong otherHandle) {
@@ -191,55 +149,37 @@ public:
 
     static void postTranslate(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar dx_ = SkFloatToScalar(dx);
-        SkScalar dy_ = SkFloatToScalar(dy);
-        obj->postTranslate(dx_, dy_);
+        obj->postTranslate(dx, dy);
     }
 
     static void postScale__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy, jfloat px, jfloat py) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar sx_ = SkFloatToScalar(sx);
-        SkScalar sy_ = SkFloatToScalar(sy);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        obj->postScale(sx_, sy_, px_, py_);
+        obj->postScale(sx, sy, px, py);
     }
 
     static void postScale__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat sx, jfloat sy) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar sx_ = SkFloatToScalar(sx);
-        SkScalar sy_ = SkFloatToScalar(sy);
-        obj->postScale(sx_, sy_);
+        obj->postScale(sx, sy);
     }
 
     static void postRotate__FFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees, jfloat px, jfloat py) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar degrees_ = SkFloatToScalar(degrees);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        obj->postRotate(degrees_, px_, py_);
+        obj->postRotate(degrees, px, py);
     }
 
     static void postRotate__F(JNIEnv* env, jobject clazz, jlong objHandle, jfloat degrees) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar degrees_ = SkFloatToScalar(degrees);
-        obj->postRotate(degrees_);
+        obj->postRotate(degrees);
     }
 
     static void postSkew__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat kx, jfloat ky, jfloat px, jfloat py) {
         SkMatrix* obj = reinterpret_cast<SkMatrix*>(objHandle);
-        SkScalar kx_ = SkFloatToScalar(kx);
-        SkScalar ky_ = SkFloatToScalar(ky);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        obj->postSkew(kx_, ky_, px_, py_);
+        obj->postSkew(kx, ky, px, py);
     }
 
     static void postSkew__FF(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloat kx, jfloat ky) {
         SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
-        SkScalar kx_ = SkFloatToScalar(kx);
-        SkScalar ky_ = SkFloatToScalar(ky);
-        matrix->postSkew(kx_, ky_);
+        matrix->postSkew(kx, ky);
     }
 
     static void postConcat(JNIEnv* env, jobject clazz, jlong matrixHandle, jlong otherHandle) {
@@ -321,7 +261,7 @@ public:
     static jfloat mapRadius(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloat radius) {
         SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
         float result;
-        result = SkScalarToFloat(matrix->mapRadius(SkFloatToScalar(radius)));
+        result = SkScalarToFloat(matrix->mapRadius(radius));
         return static_cast<jfloat>(result);
     }
     static void getValues(JNIEnv* env, jobject clazz, jlong matrixHandle, jfloatArray values) {
diff --git a/core/jni/android/graphics/Movie.cpp b/core/jni/android/graphics/Movie.cpp
index 461f723..5f9a9b7 100644
--- a/core/jni/android/graphics/Movie.cpp
+++ b/core/jni/android/graphics/Movie.cpp
@@ -74,12 +74,10 @@ static void movie_draw(JNIEnv* env, jobject movie, jobject canvas,
 
     SkMovie* m = J2Movie(env, movie);
     SkCanvas* c = GraphicsJNI::getNativeCanvas(env, canvas);
-    SkScalar sx = SkFloatToScalar(fx);
-    SkScalar sy = SkFloatToScalar(fy);
     const SkBitmap& b = m->bitmap();
     const SkPaint* p = jpaint ? GraphicsJNI::getNativePaint(env, jpaint) : NULL;
 
-    c->drawBitmap(b, sx, sy, p);
+    c->drawBitmap(b, fx, fy, p);
 }
 
 static jobject movie_decodeAsset(JNIEnv* env, jobject clazz, jlong native_asset) {
diff --git a/core/jni/android/graphics/NinePatch.cpp b/core/jni/android/graphics/NinePatch.cpp
index 871e24d..855d267 100644
--- a/core/jni/android/graphics/NinePatch.cpp
+++ b/core/jni/android/graphics/NinePatch.cpp
@@ -97,7 +97,7 @@ public:
         } else {
             canvas->save();
 
-            SkScalar scale = SkFloatToScalar(destDensity / (float)srcDensity);
+            SkScalar scale = destDensity / (float)srcDensity;
             canvas->translate(bounds.fLeft, bounds.fTop);
             canvas->scale(scale, scale);
 
diff --git a/core/jni/android/graphics/Paint.cpp b/core/jni/android/graphics/Paint.cpp
index 1167bfe..f77a389 100644
--- a/core/jni/android/graphics/Paint.cpp
+++ b/core/jni/android/graphics/Paint.cpp
@@ -206,7 +206,7 @@ public:
 
     static void setStrokeWidth(JNIEnv* env, jobject paint, jfloat width) {
         NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setStrokeWidth(SkFloatToScalar(width));
+        GraphicsJNI::getNativePaint(env, paint)->setStrokeWidth(width);
     }
 
     static jfloat getStrokeMiter(JNIEnv* env, jobject paint) {
@@ -216,7 +216,7 @@ public:
 
     static void setStrokeMiter(JNIEnv* env, jobject paint, jfloat miter) {
         NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setStrokeMiter(SkFloatToScalar(miter));
+        GraphicsJNI::getNativePaint(env, paint)->setStrokeMiter(miter);
     }
 
     static jint getStrokeCap(JNIEnv* env, jobject clazz, jlong objHandle) {
@@ -364,7 +364,7 @@ public:
 
     static void setTextSize(JNIEnv* env, jobject paint, jfloat textSize) {
         NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setTextSize(SkFloatToScalar(textSize));
+        GraphicsJNI::getNativePaint(env, paint)->setTextSize(textSize);
     }
 
     static jfloat getTextScaleX(JNIEnv* env, jobject paint) {
@@ -374,7 +374,7 @@ public:
 
     static void setTextScaleX(JNIEnv* env, jobject paint, jfloat scaleX) {
         NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setTextScaleX(SkFloatToScalar(scaleX));
+        GraphicsJNI::getNativePaint(env, paint)->setTextScaleX(scaleX);
     }
 
     static jfloat getTextSkewX(JNIEnv* env, jobject paint) {
@@ -384,7 +384,7 @@ public:
 
     static void setTextSkewX(JNIEnv* env, jobject paint, jfloat skewX) {
         NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setTextSkewX(SkFloatToScalar(skewX));
+        GraphicsJNI::getNativePaint(env, paint)->setTextSkewX(skewX);
     }
 
     static jfloat ascent(JNIEnv* env, jobject paint) {
@@ -747,10 +747,7 @@ public:
             paint->setLooper(NULL);
         }
         else {
-            paint->setLooper(new SkBlurDrawLooper(SkFloatToScalar(radius),
-                                                  SkFloatToScalar(dx),
-                                                  SkFloatToScalar(dy),
-                                                  (SkColor)color))->unref();
+            paint->setLooper(new SkBlurDrawLooper(radius, dx, dy, (SkColor)color))->unref();
         }
     }
 
@@ -764,7 +761,7 @@ public:
         }
         SkScalar     measured;
         size_t       bytes = paint.breakText(value->getGlyphs(), value->getGlyphsCount() << 1,
-                                   SkFloatToScalar(maxWidth), &measured, tbd);
+                maxWidth, &measured, tbd);
         SkASSERT((bytes & 1) == 0);
 
         if (jmeasured && env->GetArrayLength(jmeasured) > 0) {
diff --git a/core/jni/android/graphics/Path.cpp b/core/jni/android/graphics/Path.cpp
index e580d36..1ad1a8a 100644
--- a/core/jni/android/graphics/Path.cpp
+++ b/core/jni/android/graphics/Path.cpp
@@ -93,18 +93,18 @@ public:
         return obj->isEmpty();
     }
  
-    static jboolean isRect(JNIEnv* env, jobject clazz, jlong objHandle, jobject rect) {
-        SkRect rect_;
+    static jboolean isRect(JNIEnv* env, jobject clazz, jlong objHandle, jobject jrect) {
+        SkRect rect;
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
-        jboolean result = obj->isRect(&rect_);
-        GraphicsJNI::rect_to_jrectf(rect_, env, rect);
+        jboolean result = obj->isRect(&rect);
+        GraphicsJNI::rect_to_jrectf(rect, env, jrect);
         return result;
     }
  
-    static void computeBounds(JNIEnv* env, jobject clazz, jlong objHandle, jobject bounds) {
+    static void computeBounds(JNIEnv* env, jobject clazz, jlong objHandle, jobject jbounds) {
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
-        const SkRect& bounds_ = obj->getBounds();
-        GraphicsJNI::rect_to_jrectf(bounds_, env, bounds);
+        const SkRect& bounds = obj->getBounds();
+        GraphicsJNI::rect_to_jrectf(bounds, env, jbounds);
     }
  
     static void incReserve(JNIEnv* env, jobject clazz, jlong objHandle, jint extraPtCount) {
@@ -114,79 +114,49 @@ public:
  
     static void moveTo__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x, jfloat y) {
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
-        SkScalar x_ = SkFloatToScalar(x);
-        SkScalar y_ = SkFloatToScalar(y);
-        obj->moveTo(x_, y_);
+        obj->moveTo(x, y);
     }
  
     static void rMoveTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
-        SkScalar dx_ = SkFloatToScalar(dx);
-        SkScalar dy_ = SkFloatToScalar(dy);
-        obj->rMoveTo(dx_, dy_);
+        obj->rMoveTo(dx, dy);
     }
  
     static void lineTo__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x, jfloat y) {
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
-        SkScalar x_ = SkFloatToScalar(x);
-        SkScalar y_ = SkFloatToScalar(y);
-        obj->lineTo(x_, y_);
+        obj->lineTo(x, y);
     }
  
     static void rLineTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
-        SkScalar dx_ = SkFloatToScalar(dx);
-        SkScalar dy_ = SkFloatToScalar(dy);
-        obj->rLineTo(dx_, dy_);
+        obj->rLineTo(dx, dy);
     }
  
     static void quadTo__FFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x1, jfloat y1, jfloat x2, jfloat y2) {
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
-        SkScalar x1_ = SkFloatToScalar(x1);
-        SkScalar y1_ = SkFloatToScalar(y1);
-        SkScalar x2_ = SkFloatToScalar(x2);
-        SkScalar y2_ = SkFloatToScalar(y2);
-        obj->quadTo(x1_, y1_, x2_, y2_);
+        obj->quadTo(x1, y1, x2, y2);
     }
  
     static void rQuadTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx1, jfloat dy1, jfloat dx2, jfloat dy2) {
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
-        SkScalar dx1_ = SkFloatToScalar(dx1);
-        SkScalar dy1_ = SkFloatToScalar(dy1);
-        SkScalar dx2_ = SkFloatToScalar(dx2);
-        SkScalar dy2_ = SkFloatToScalar(dy2);
-        obj->rQuadTo(dx1_, dy1_, dx2_, dy2_);
+        obj->rQuadTo(dx1, dy1, dx2, dy2);
     }
  
     static void cubicTo__FFFFFF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) {
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
-        SkScalar x1_ = SkFloatToScalar(x1);
-        SkScalar y1_ = SkFloatToScalar(y1);
-        SkScalar x2_ = SkFloatToScalar(x2);
-        SkScalar y2_ = SkFloatToScalar(y2);
-        SkScalar x3_ = SkFloatToScalar(x3);
-        SkScalar y3_ = SkFloatToScalar(y3);
-        obj->cubicTo(x1_, y1_, x2_, y2_, x3_, y3_);
+        obj->cubicTo(x1, y1, x2, y2, x3, y3);
     }
  
     static void rCubicTo(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) {
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
-        SkScalar x1_ = SkFloatToScalar(x1);
-        SkScalar y1_ = SkFloatToScalar(y1);
-        SkScalar x2_ = SkFloatToScalar(x2);
-        SkScalar y2_ = SkFloatToScalar(y2);
-        SkScalar x3_ = SkFloatToScalar(x3);
-        SkScalar y3_ = SkFloatToScalar(y3);
-        obj->rCubicTo(x1_, y1_, x2_, y2_, x3_, y3_);
+        obj->rCubicTo(x1, y1, x2, y2, x3, y3);
     }
  
     static void arcTo(JNIEnv* env, jobject clazz, jlong objHandle, jobject oval, jfloat startAngle, jfloat sweepAngle, jboolean forceMoveTo) {
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
         SkRect oval_;
         GraphicsJNI::jrectf_to_rect(env, oval, &oval_);
-        SkScalar startAngle_ = SkFloatToScalar(startAngle);
-        SkScalar sweepAngle_ = SkFloatToScalar(sweepAngle);
-        obj->arcTo(oval_, startAngle_, sweepAngle_, forceMoveTo);
+        obj->arcTo(oval_, startAngle, sweepAngle, forceMoveTo);
     }
  
     static void close(JNIEnv* env, jobject clazz, jlong objHandle) {
@@ -194,22 +164,18 @@ public:
         obj->close();
     }
  
-    static void addRect__RectFI(JNIEnv* env, jobject clazz, jlong objHandle, jobject rect, jint dirHandle) {
-        SkRect rect_;
+    static void addRect__RectFI(JNIEnv* env, jobject clazz, jlong objHandle, jobject jrect, jint dirHandle) {
+        SkRect rect;
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
         SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
-        GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
-        obj->addRect(rect_, dir);
+        GraphicsJNI::jrectf_to_rect(env, jrect, &rect);
+        obj->addRect(rect, dir);
     }
  
     static void addRect__FFFFI(JNIEnv* env, jobject clazz, jlong objHandle, jfloat left, jfloat top, jfloat right, jfloat bottom, jint dirHandle) {
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
         SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
-        SkScalar left_ = SkFloatToScalar(left);
-        SkScalar top_ = SkFloatToScalar(top);
-        SkScalar right_ = SkFloatToScalar(right);
-        SkScalar bottom_ = SkFloatToScalar(bottom);
-        obj->addRect(left_, top_, right_, bottom_, dir);
+        obj->addRect(left, top, right, bottom, dir);
     }
  
     static void addOval(JNIEnv* env, jobject clazz, jlong objHandle, jobject oval, jint dirHandle) {
@@ -223,54 +189,44 @@ public:
     static void addCircle(JNIEnv* env, jobject clazz, jlong objHandle, jfloat x, jfloat y, jfloat radius, jint dirHandle) {
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
         SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
-        SkScalar x_ = SkFloatToScalar(x);
-        SkScalar y_ = SkFloatToScalar(y);
-        SkScalar radius_ = SkFloatToScalar(radius);
-        obj->addCircle(x_, y_, radius_, dir);
+        obj->addCircle(x, y, radius, dir);
     }
  
     static void addArc(JNIEnv* env, jobject clazz, jlong objHandle, jobject oval, jfloat startAngle, jfloat sweepAngle) {
         SkRect oval_;
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
         GraphicsJNI::jrectf_to_rect(env, oval, &oval_);
-        SkScalar startAngle_ = SkFloatToScalar(startAngle);
-        SkScalar sweepAngle_ = SkFloatToScalar(sweepAngle);
-        obj->addArc(oval_, startAngle_, sweepAngle_);
+        obj->addArc(oval_, startAngle, sweepAngle);
     }
  
-    static void addRoundRectXY(JNIEnv* env, jobject clazz, jlong objHandle, jobject rect,
+    static void addRoundRectXY(JNIEnv* env, jobject clazz, jlong objHandle, jobject jrect,
             jfloat rx, jfloat ry, jint dirHandle) {
-        SkRect rect_;
+        SkRect rect;
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
         SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
-        GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
-        SkScalar rx_ = SkFloatToScalar(rx);
-        SkScalar ry_ = SkFloatToScalar(ry);
-        obj->addRoundRect(rect_, rx_, ry_, dir);
+        GraphicsJNI::jrectf_to_rect(env, jrect, &rect);
+        obj->addRoundRect(rect, rx, ry, dir);
     }
     
-    static void addRoundRect8(JNIEnv* env, jobject, jlong objHandle, jobject rect,
+    static void addRoundRect8(JNIEnv* env, jobject, jlong objHandle, jobject jrect,
             jfloatArray array, jint dirHandle) {
-        SkRect rect_;
+        SkRect rect;
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
         SkPath::Direction dir = static_cast<SkPath::Direction>(dirHandle);
-        GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
+        GraphicsJNI::jrectf_to_rect(env, jrect, &rect);
         AutoJavaFloatArray  afa(env, array, 8);
+#ifdef SK_SCALAR_IS_FLOAT
         const float* src = afa.ptr();
-        SkScalar dst[8];
-        
-        for (int i = 0; i < 8; i++) {
-            dst[i] = SkFloatToScalar(src[i]);
-        }
-        obj->addRoundRect(rect_, dst, dir);
+#else
+        #error Need to convert float array to SkScalar array before calling the following function.
+#endif
+        obj->addRoundRect(rect, src, dir);
     }
     
     static void addPath__PathFF(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle, jfloat dx, jfloat dy) {
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
         SkPath* src = reinterpret_cast<SkPath*>(srcHandle);
-        SkScalar dx_ = SkFloatToScalar(dx);
-        SkScalar dy_ = SkFloatToScalar(dy);
-        obj->addPath(*src, dx_, dy_);
+        obj->addPath(*src, dx, dy);
     }
  
     static void addPath__Path(JNIEnv* env, jobject clazz, jlong objHandle, jlong srcHandle) {
@@ -289,23 +245,17 @@ public:
     static void offset__FFPath(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy, jlong dstHandle) {
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
         SkPath* dst = reinterpret_cast<SkPath*>(dstHandle);
-        SkScalar dx_ = SkFloatToScalar(dx);
-        SkScalar dy_ = SkFloatToScalar(dy);
-        obj->offset(dx_, dy_, dst);
+        obj->offset(dx, dy, dst);
     }
  
     static void offset__FF(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
-        SkScalar dx_ = SkFloatToScalar(dx);
-        SkScalar dy_ = SkFloatToScalar(dy);
-        obj->offset(dx_, dy_);
+        obj->offset(dx, dy);
     }
 
     static void setLastPoint(JNIEnv* env, jobject clazz, jlong objHandle, jfloat dx, jfloat dy) {
         SkPath* obj = reinterpret_cast<SkPath*>(objHandle);
-        SkScalar dx_ = SkFloatToScalar(dx);
-        SkScalar dy_ = SkFloatToScalar(dy);
-        obj->setLastPt(dx_, dy_);
+        obj->setLastPt(dx, dy);
     }
  
     static void transform__MatrixPath(JNIEnv* env, jobject clazz, jlong objHandle, jlong matrixHandle, jlong dstHandle) {
diff --git a/core/jni/android/graphics/PathEffect.cpp b/core/jni/android/graphics/PathEffect.cpp
index 81b46ce..28d881d 100644
--- a/core/jni/android/graphics/PathEffect.cpp
+++ b/core/jni/android/graphics/PathEffect.cpp
@@ -35,15 +35,13 @@ public:
     static jlong Dash_constructor(JNIEnv* env, jobject,
                                       jfloatArray intervalArray, jfloat phase) {
         AutoJavaFloatArray autoInterval(env, intervalArray);
-        int     count = autoInterval.length() & ~1;  // even number
-        float*  values = autoInterval.ptr();
-
-        SkAutoSTMalloc<32, SkScalar>    storage(count);
-        SkScalar*                       intervals = storage.get();
-        for (int i = 0; i < count; i++) {
-            intervals[i] = SkFloatToScalar(values[i]);
-        }
-        SkPathEffect* effect = SkDashPathEffect::Create(intervals, count, SkFloatToScalar(phase));
+        int         count = autoInterval.length() & ~1;  // even number
+#ifdef SK_SCALAR_IS_FLOAT
+        SkScalar*   intervals = autoInterval.ptr();
+#else
+        #error Need to convert float array to SkScalar array before calling the following function.
+#endif
+        SkPathEffect* effect = SkDashPathEffect::Create(intervals, count, phase);
         return reinterpret_cast<jlong>(effect);
     }
 
@@ -51,20 +49,19 @@ public:
                   jlong shapeHandle, jfloat advance, jfloat phase, jint style) {
         const SkPath* shape = reinterpret_cast<SkPath*>(shapeHandle);
         SkASSERT(shape != NULL);
-        SkPathEffect* effect = SkPath1DPathEffect::Create(*shape, SkFloatToScalar(advance),
-                     SkFloatToScalar(phase), (SkPath1DPathEffect::Style)style);
+        SkPathEffect* effect = SkPath1DPathEffect::Create(*shape, advance, phase,
+                (SkPath1DPathEffect::Style)style);
         return reinterpret_cast<jlong>(effect);
     }
 
     static jlong Corner_constructor(JNIEnv* env, jobject, jfloat radius){
-        SkPathEffect* effect = SkCornerPathEffect::Create(SkFloatToScalar(radius));
+        SkPathEffect* effect = SkCornerPathEffect::Create(radius);
         return reinterpret_cast<jlong>(effect);
     }
 
     static jlong Discrete_constructor(JNIEnv* env, jobject,
                                       jfloat length, jfloat deviation) {
-        SkPathEffect* effect = SkDiscretePathEffect::Create(SkFloatToScalar(length),
-                                        SkFloatToScalar(deviation));
+        SkPathEffect* effect = SkDiscretePathEffect::Create(length, deviation);
         return reinterpret_cast<jlong>(effect);
     }
 
diff --git a/core/jni/android/graphics/PathMeasure.cpp b/core/jni/android/graphics/PathMeasure.cpp
index 8478a02..13f68a9 100644
--- a/core/jni/android/graphics/PathMeasure.cpp
+++ b/core/jni/android/graphics/PathMeasure.cpp
@@ -96,7 +96,7 @@ public:
         SkScalar*   posPtr = pos ? tmpPos : NULL;
         SkScalar*   tanPtr = tan ? tmpTan : NULL;
         
-        if (!pair->fMeasure.getPosTan(SkFloatToScalar(dist), (SkPoint*)posPtr, (SkVector*)tanPtr)) {
+        if (!pair->fMeasure.getPosTan(dist, (SkPoint*)posPtr, (SkVector*)tanPtr)) {
             return JNI_FALSE;
         }
     
@@ -113,7 +113,7 @@ public:
                           jlong matrixHandle, jint flags) {
         PathMeasurePair* pair = reinterpret_cast<PathMeasurePair*>(pairHandle);
         SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
-        bool result = pair->fMeasure.getMatrix(SkFloatToScalar(dist), matrix, (SkPathMeasure::MatrixFlags)flags);
+        bool result = pair->fMeasure.getMatrix(dist, matrix, (SkPathMeasure::MatrixFlags)flags);
         return result ? JNI_TRUE : JNI_FALSE;
     }
 
@@ -121,7 +121,7 @@ public:
                                jfloat stopF, jlong dstHandle, jboolean startWithMoveTo) {
         PathMeasurePair* pair = reinterpret_cast<PathMeasurePair*>(pairHandle);
         SkPath* dst = reinterpret_cast<SkPath*>(dstHandle);
-        bool result = pair->fMeasure.getSegment(SkFloatToScalar(startF), SkFloatToScalar(stopF), dst, startWithMoveTo);
+        bool result = pair->fMeasure.getSegment(startF, stopF, dst, startWithMoveTo);
         return result ? JNI_TRUE : JNI_FALSE;
     }
 
diff --git a/core/jni/android/graphics/Shader.cpp b/core/jni/android/graphics/Shader.cpp
index 1fe6358..c5e6053 100644
--- a/core/jni/android/graphics/Shader.cpp
+++ b/core/jni/android/graphics/Shader.cpp
@@ -39,12 +39,11 @@ static void Color_RGBToHSV(JNIEnv* env, jobject, jint red, jint green, jint blue
 static jint Color_HSVToColor(JNIEnv* env, jobject, jint alpha, jfloatArray hsvArray)
 {
     AutoJavaFloatArray  autoHSV(env, hsvArray, 3);
-    float*      values = autoHSV.ptr();;
-    SkScalar    hsv[3];
-
-    for (int i = 0; i < 3; i++) {
-        hsv[i] = SkFloatToScalar(values[i]);
-    }
+#ifdef SK_SCALAR_IS_FLOAT
+    SkScalar*   hsv = autoHSV.ptr();
+#else
+    #error Need to convert float array to SkScalar array before calling the following function.
+#endif
 
     return static_cast<jint>(SkHSVToColor(alpha, hsv));
 }
@@ -120,28 +119,22 @@ static jlong LinearGradient_create1(JNIEnv* env, jobject o,
                                     jintArray colorArray, jfloatArray posArray, jint tileMode)
 {
     SkPoint pts[2];
-    pts[0].set(SkFloatToScalar(x0), SkFloatToScalar(y0));
-    pts[1].set(SkFloatToScalar(x1), SkFloatToScalar(y1));
+    pts[0].set(x0, y0);
+    pts[1].set(x1, y1);
 
     size_t count = env->GetArrayLength(colorArray);
     const jint* colorValues = env->GetIntArrayElements(colorArray, NULL);
 
-    SkAutoSTMalloc<8, SkScalar> storage(posArray ? count : 0);
-    SkScalar* pos = NULL;
-
-    if (posArray) {
-        AutoJavaFloatArray autoPos(env, posArray, count);
-        const float* posValues = autoPos.ptr();
-        pos = (SkScalar*)storage.get();
-        for (size_t i = 0; i < count; i++) {
-            pos[i] = SkFloatToScalar(posValues[i]);
-        }
-    }
+    AutoJavaFloatArray autoPos(env, posArray, count);
+#ifdef SK_SCALAR_IS_FLOAT
+    SkScalar* pos = autoPos.ptr();
+#else
+    #error Need to convert float array to SkScalar array before calling the following function.
+#endif
 
     SkShader* shader = SkGradientShader::CreateLinear(pts,
-                                reinterpret_cast<const SkColor*>(colorValues),
-                                pos, count,
-                                static_cast<SkShader::TileMode>(tileMode));
+            reinterpret_cast<const SkColor*>(colorValues), pos, count,
+            static_cast<SkShader::TileMode>(tileMode));
 
     env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues), JNI_ABORT);
     ThrowIAE_IfNull(env, shader);
@@ -252,8 +245,8 @@ static jlong LinearGradient_create2(JNIEnv* env, jobject o,
                                     jint color0, jint color1, jint tileMode)
 {
     SkPoint pts[2];
-    pts[0].set(SkFloatToScalar(x0), SkFloatToScalar(y0));
-    pts[1].set(SkFloatToScalar(x1), SkFloatToScalar(y1));
+    pts[0].set(x0, y0);
+    pts[1].set(x1, y1);
 
     SkColor colors[2];
     colors[0] = color0;
@@ -270,27 +263,21 @@ static jlong LinearGradient_create2(JNIEnv* env, jobject o,
 static jlong RadialGradient_create1(JNIEnv* env, jobject, jfloat x, jfloat y, jfloat radius,
         jintArray colorArray, jfloatArray posArray, jint tileMode) {
     SkPoint center;
-    center.set(SkFloatToScalar(x), SkFloatToScalar(y));
+    center.set(x, y);
 
     size_t      count = env->GetArrayLength(colorArray);
     const jint* colorValues = env->GetIntArrayElements(colorArray, NULL);
 
-    SkAutoSTMalloc<8, SkScalar> storage(posArray ? count : 0);
-    SkScalar*                   pos = NULL;
-
-    if (posArray) {
-        AutoJavaFloatArray autoPos(env, posArray, count);
-        const float* posValues = autoPos.ptr();
-        pos = (SkScalar*)storage.get();
-        for (size_t i = 0; i < count; i++)
-            pos[i] = SkFloatToScalar(posValues[i]);
-    }
+    AutoJavaFloatArray autoPos(env, posArray, count);
+#ifdef SK_SCALAR_IS_FLOAT
+    SkScalar* pos = autoPos.ptr();
+#else
+    #error Need to convert float array to SkScalar array before calling the following function.
+#endif
 
-    SkShader* shader = SkGradientShader::CreateRadial(center,
-                                SkFloatToScalar(radius),
-                                reinterpret_cast<const SkColor*>(colorValues),
-                                pos, count,
-                                static_cast<SkShader::TileMode>(tileMode));
+    SkShader* shader = SkGradientShader::CreateRadial(center, radius,
+            reinterpret_cast<const SkColor*>(colorValues), pos, count,
+            static_cast<SkShader::TileMode>(tileMode));
     env->ReleaseIntArrayElements(colorArray, const_cast<jint*>(colorValues),
                                  JNI_ABORT);
 
@@ -301,14 +288,14 @@ static jlong RadialGradient_create1(JNIEnv* env, jobject, jfloat x, jfloat y, jf
 static jlong RadialGradient_create2(JNIEnv* env, jobject, jfloat x, jfloat y, jfloat radius,
         jint color0, jint color1, jint tileMode) {
     SkPoint center;
-    center.set(SkFloatToScalar(x), SkFloatToScalar(y));
+    center.set(x, y);
 
     SkColor colors[2];
     colors[0] = color0;
     colors[1] = color1;
 
-    SkShader* s = SkGradientShader::CreateRadial(center, SkFloatToScalar(radius), colors, NULL,
-                                          2, (SkShader::TileMode)tileMode);
+    SkShader* s = SkGradientShader::CreateRadial(center, radius, colors, NULL, 2,
+            (SkShader::TileMode)tileMode);
     ThrowIAE_IfNull(env, s);
     return reinterpret_cast<jlong>(s);
 }
@@ -381,22 +368,15 @@ static jlong SweepGradient_create1(JNIEnv* env, jobject, jfloat x, jfloat y,
     size_t      count = env->GetArrayLength(jcolors);
     const jint* colors = env->GetIntArrayElements(jcolors, NULL);
 
-    SkAutoSTMalloc<8, SkScalar> storage(jpositions ? count : 0);
-    SkScalar*                   pos = NULL;
-
-    if (NULL != jpositions) {
-        AutoJavaFloatArray autoPos(env, jpositions, count);
-        const float* posValues = autoPos.ptr();
-        pos = (SkScalar*)storage.get();
-        for (size_t i = 0; i < count; i++) {
-            pos[i] = SkFloatToScalar(posValues[i]);
-        }
-    }
+    AutoJavaFloatArray autoPos(env, jpositions, count);
+#ifdef SK_SCALAR_IS_FLOAT
+    SkScalar* pos = autoPos.ptr();
+#else
+    #error Need to convert float array to SkScalar array before calling the following function.
+#endif
 
-    SkShader* shader = SkGradientShader::CreateSweep(SkFloatToScalar(x),
-                                     SkFloatToScalar(y),
-                                     reinterpret_cast<const SkColor*>(colors),
-                                     pos, count);
+    SkShader* shader = SkGradientShader::CreateSweep(x, y,
+            reinterpret_cast<const SkColor*>(colors), pos, count);
     env->ReleaseIntArrayElements(jcolors, const_cast<jint*>(colors),
                                  JNI_ABORT);
     ThrowIAE_IfNull(env, shader);
@@ -408,8 +388,7 @@ static jlong SweepGradient_create2(JNIEnv* env, jobject, jfloat x, jfloat y,
     SkColor colors[2];
     colors[0] = color0;
     colors[1] = color1;
-    SkShader* s = SkGradientShader::CreateSweep(SkFloatToScalar(x), SkFloatToScalar(y),
-                                         colors, NULL, 2);
+    SkShader* s = SkGradientShader::CreateSweep(x, y, colors, NULL, 2);
     ThrowIAE_IfNull(env, s);
     return reinterpret_cast<jlong>(s);
 }
diff --git a/core/jni/android/graphics/TextLayout.cpp b/core/jni/android/graphics/TextLayout.cpp
index 34dc3e8..d0b6f7c 100644
--- a/core/jni/android/graphics/TextLayout.cpp
+++ b/core/jni/android/graphics/TextLayout.cpp
@@ -58,10 +58,8 @@ void TextLayout::handleText(SkPaint *paint, const jchar* text, jsize len,
     if (value == NULL) {
         return ;
     }
-    SkScalar x_ = SkFloatToScalar(x);
-    SkScalar y_ = SkFloatToScalar(y);
     // Beware: this needs Glyph encoding (already done on the Paint constructor)
-    paint->getTextPath(value->getGlyphs(), value->getGlyphsCount() * 2, x_, y_, path);
+    paint->getTextPath(value->getGlyphs(), value->getGlyphsCount() * 2, x, y, path);
 }
 
 void TextLayout::getTextRunAdvances(SkPaint* paint, const jchar* chars, jint start,
@@ -90,9 +88,6 @@ void TextLayout::drawTextOnPath(SkPaint* paint, const jchar* text, int count,
                                 int bidiFlags, jfloat hOffset, jfloat vOffset,
                                 SkPath* path, SkCanvas* canvas) {
 
-    SkScalar h_ = SkFloatToScalar(hOffset);
-    SkScalar v_ = SkFloatToScalar(vOffset);
-
     sp<TextLayoutValue> value = TextLayoutEngine::getInstance().getValue(paint,
             text, 0, count, count, bidiFlags);
     if (value == NULL) {
@@ -100,7 +95,8 @@ void TextLayout::drawTextOnPath(SkPaint* paint, const jchar* text, int count,
     }
 
     // Beware: this needs Glyph encoding (already done on the Paint constructor)
-    canvas->drawTextOnPathHV(value->getGlyphs(), value->getGlyphsCount() * 2, *path, h_, v_, *paint);
+    canvas->drawTextOnPathHV(value->getGlyphs(), value->getGlyphsCount() * 2, *path,
+            hOffset, vOffset, *paint);
 }
 
 }