auto import from //branches/cupcake/...@130745

6 files changed, 116 insertions, 33 deletions

diff --git a/core/jni/android/graphics/BitmapFactory.cpp b/core/jni/android/graphics/BitmapFactory.cpp
index be8526d..332b01c 100644
--- a/core/jni/android/graphics/BitmapFactory.cpp
+++ b/core/jni/android/graphics/BitmapFactory.cpp
@@ -1,3 +1,5 @@
+#define LOG_TAG "BitmapFactory"
+
 #include "SkImageDecoder.h"
 #include "SkPixelRef.h"
 #include "SkStream.h"
@@ -481,6 +483,48 @@ static void nativeRequestCancel(JNIEnv*, jobject joptions) {
     (void)AutoDecoderCancel::RequestCancel(joptions);
 }
 
+static jbyteArray nativeScaleNinePatch(JNIEnv* env, jobject, jbyteArray chunkObject, jfloat scale,
+        jobject padding) {
+
+    jbyte* array = env->GetByteArrayElements(chunkObject, 0);
+    if (array != NULL) {
+        size_t chunkSize = env->GetArrayLength(chunkObject);
+        void* storage = alloca(chunkSize);
+        android::Res_png_9patch* chunk = static_cast<android::Res_png_9patch*>(storage);
+        memcpy(chunk, array, chunkSize);
+        android::Res_png_9patch::deserialize(chunk);
+
+        chunk->paddingLeft = int(chunk->paddingLeft * scale + 0.5f);
+        chunk->paddingTop = int(chunk->paddingTop * scale + 0.5f);
+        chunk->paddingRight = int(chunk->paddingRight * scale + 0.5f);
+        chunk->paddingBottom = int(chunk->paddingBottom * scale + 0.5f);
+
+        for (int i = 0; i < chunk->numXDivs; i++) {
+            chunk->xDivs[i] = int(chunk->xDivs[i] * scale + 0.5f);
+            if (i > 0 && chunk->xDivs[i] == chunk->xDivs[i - 1]) {
+                chunk->xDivs[i]++;
+            }
+        }
+
+        for (int i = 0; i < chunk->numYDivs; i++) {
+            chunk->yDivs[i] = int(chunk->yDivs[i] * scale + 0.5f);            
+            if (i > 0 && chunk->yDivs[i] == chunk->yDivs[i - 1]) {
+                chunk->yDivs[i]++;
+            }
+        }
+
+        memcpy(array, chunk, chunkSize);
+
+        if (padding) {
+            GraphicsJNI::set_jrect(env, padding, chunk->paddingLeft, chunk->paddingTop,
+                    chunk->paddingRight, chunk->paddingBottom);
+        }
+
+        env->ReleaseByteArrayElements(chunkObject, array, 0);
+    }
+    return chunkObject;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 static JNINativeMethod gMethods[] = {
@@ -502,7 +546,13 @@ static JNINativeMethod gMethods[] = {
     {   "nativeDecodeByteArray",
         "([BIILandroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;",
         (void*)nativeDecodeByteArray
+    },
+
+    {   "nativeScaleNinePatch",
+        "([BFLandroid/graphics/Rect;)[B",
+        (void*)nativeScaleNinePatch
     }
+
 };
 
 static JNINativeMethod gOptionsMethods[] = {
diff --git a/core/jni/android/graphics/Canvas.cpp b/core/jni/android/graphics/Canvas.cpp
index b9e5f67..605e4b8 100644
--- a/core/jni/android/graphics/Canvas.cpp
+++ b/core/jni/android/graphics/Canvas.cpp
@@ -93,7 +93,7 @@ public:
         SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
         return canvas->getDevice()->accessBitmap(false).height();
     }
-    
+
     static void setViewport(JNIEnv* env, jobject, SkCanvas* canvas,
                             int width, int height) {
         canvas->setViewport(width, height);
@@ -454,13 +454,32 @@ public:
 #endif
     }
 
-    static void drawBitmap__BitmapFFPaint(JNIEnv* env, jobject,
+    static void drawBitmap__BitmapFFPaint(JNIEnv* env, jobject jcanvas,
                                           SkCanvas* canvas, SkBitmap* bitmap,
                                           jfloat left, jfloat top,
-                                          SkPaint* paint) {
+                                          SkPaint* paint,
+                                          jboolean autoScale, jfloat densityScale) {
         SkScalar left_ = SkFloatToScalar(left);
         SkScalar top_ = SkFloatToScalar(top);
-        canvas->drawBitmap(*bitmap, left_, top_, paint);
+
+        if (!autoScale || densityScale <= 0.0f) {
+            canvas->drawBitmap(*bitmap, left_, top_, paint);
+        } else {
+            canvas->save();
+            SkScalar canvasScale = GraphicsJNI::getCanvasDensityScale(env, jcanvas);
+            SkScalar scale = canvasScale / SkFloatToScalar(densityScale);
+            canvas->scale(scale, scale);
+
+            SkPaint filteredPaint;
+            if (paint) {
+                filteredPaint = *paint;
+            }
+            filteredPaint.setFilterBitmap(true);
+
+            canvas->drawBitmap(*bitmap, left_, top_, &filteredPaint);
+
+            canvas->restore();
+        }
     }
 
     static void doDrawBitmap(JNIEnv* env, SkCanvas* canvas, SkBitmap* bitmap,
@@ -492,7 +511,7 @@ public:
     
     static void drawBitmapArray(JNIEnv* env, jobject, SkCanvas* canvas,
                                 jintArray jcolors, int offset, int stride,
-                                int x, int y, int width, int height,
+                                jfloat x, jfloat y, int width, int height,
                                 jboolean hasAlpha, SkPaint* paint)
     {
         SkBitmap    bitmap;
@@ -508,7 +527,8 @@ public:
             return;
         }
         
-        canvas->drawBitmap(bitmap, SkIntToScalar(x), SkIntToScalar(y), paint);
+        canvas->drawBitmap(bitmap, SkFloatToScalar(x), SkFloatToScalar(y),
+                           paint);
     }
     
     static void drawBitmapMatrix(JNIEnv* env, jobject, SkCanvas* canvas,
@@ -882,13 +902,13 @@ static JNINativeMethod gCanvasMethods[] = {
     {"native_drawRoundRect","(ILandroid/graphics/RectF;FFI)V",
         (void*) SkCanvasGlue::drawRoundRect},
     {"native_drawPath","(III)V", (void*) SkCanvasGlue::drawPath},
-    {"native_drawBitmap","(IIFFI)V",
+    {"native_drawBitmap","(IIFFIZF)V",
         (void*) SkCanvasGlue::drawBitmap__BitmapFFPaint},
     {"native_drawBitmap","(IILandroid/graphics/Rect;Landroid/graphics/RectF;I)V",
         (void*) SkCanvasGlue::drawBitmapRF},
     {"native_drawBitmap","(IILandroid/graphics/Rect;Landroid/graphics/Rect;I)V",
         (void*) SkCanvasGlue::drawBitmapRR},
-    {"native_drawBitmap", "(I[IIIIIIIZI)V",
+    {"native_drawBitmap", "(I[IIIFFIIZI)V",
     (void*)SkCanvasGlue::drawBitmapArray},
     
     {"nativeDrawBitmapMatrix", "(IIII)V",
diff --git a/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.cpp b/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.cpp
index 65c2326..a285def 100644
--- a/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.cpp
+++ b/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.cpp
@@ -56,11 +56,14 @@ public:
                 break;  // eof
             }
             
-            const jbyte* array = env->GetByteArrayElements(fJavaByteArray,
-                                                           NULL);
-            memcpy(buffer, array, n);
-            env->ReleaseByteArrayElements(fJavaByteArray,
-                                          const_cast<jbyte*>(array), JNI_ABORT);
+            env->GetByteArrayRegion(fJavaByteArray, 0, n,
+                                    reinterpret_cast<jbyte*>(buffer));
+            if (env->ExceptionCheck()) {
+                env->ExceptionDescribe();
+                env->ExceptionClear();
+                SkDebugf("---- read:GetByteArrayRegion threw an exception\n");
+                return 0;
+            }
             
             buffer = (void*)((char*)buffer + n);
             bytesRead += n;
@@ -189,10 +192,15 @@ public:
                 requested = fCapacity;
             }
 
-            jbyte* array = env->GetByteArrayElements(storage, NULL);
-            memcpy(array, buffer, requested);
-            env->ReleaseByteArrayElements(storage, array, 0);
-
+            env->SetByteArrayRegion(storage, 0, requested,
+                                    reinterpret_cast<const jbyte*>(buffer));
+            if (env->ExceptionCheck()) {
+                env->ExceptionDescribe();
+                env->ExceptionClear();
+                SkDebugf("--- write:SetByteArrayElements threw an exception\n");
+                return false;
+            }
+            
             fEnv->CallVoidMethod(fJavaOutputStream, gOutputStream_writeMethodID,
                                  storage, 0, requested);
             if (env->ExceptionCheck()) {
diff --git a/core/jni/android/graphics/Graphics.cpp b/core/jni/android/graphics/Graphics.cpp
index 44113e5..6eebbdc 100644
--- a/core/jni/android/graphics/Graphics.cpp
+++ b/core/jni/android/graphics/Graphics.cpp
@@ -162,6 +162,7 @@ static jfieldID gBitmapConfig_nativeInstanceID;
 
 static jclass   gCanvas_class;
 static jfieldID gCanvas_nativeInstanceID;
+static jfieldID gCanvas_densityScaleID;
 
 static jclass   gPaint_class;
 static jfieldID gPaint_nativeInstanceID;
@@ -318,6 +319,13 @@ SkCanvas* GraphicsJNI::getNativeCanvas(JNIEnv* env, jobject canvas) {
     return c;
 }
 
+SkScalar GraphicsJNI::getCanvasDensityScale(JNIEnv* env, jobject canvas) {
+    SkASSERT(env);
+    SkASSERT(canvas);
+    SkASSERT(env->IsInstanceOf(canvas, gCanvas_class));
+    return SkFloatToScalar(env->GetFloatField(canvas, gCanvas_densityScaleID));
+}
+
 SkPaint* GraphicsJNI::getNativePaint(JNIEnv* env, jobject paint) {
     SkASSERT(env);
     SkASSERT(paint);
@@ -543,7 +551,8 @@ int register_android_graphics_Graphics(JNIEnv* env)
 
     gCanvas_class = make_globalref(env, "android/graphics/Canvas");
     gCanvas_nativeInstanceID = getFieldIDCheck(env, gCanvas_class, "mNativeCanvas", "I");
-    
+    gCanvas_densityScaleID = getFieldIDCheck(env, gCanvas_class, "mDensityScale", "F");
+
     gPaint_class = make_globalref(env, "android/graphics/Paint");
     gPaint_nativeInstanceID = getFieldIDCheck(env, gPaint_class, "mNativePaint", "I");
     
diff --git a/core/jni/android/graphics/GraphicsJNI.h b/core/jni/android/graphics/GraphicsJNI.h
index e67b20b..e2dc9ac 100644
--- a/core/jni/android/graphics/GraphicsJNI.h
+++ b/core/jni/android/graphics/GraphicsJNI.h
@@ -38,6 +38,7 @@ public:
     static SkBitmap* getNativeBitmap(JNIEnv*, jobject bitmap);
     static SkPicture* getNativePicture(JNIEnv*, jobject picture);
     static SkRegion* getNativeRegion(JNIEnv*, jobject region);
+    static SkScalar getCanvasDensityScale(JNIEnv*, jobject canvas);
     
     /** Return the corresponding native config from the java Config enum,
         or kNo_Config if the java object is null.
diff --git a/core/jni/android/graphics/NinePatch.cpp b/core/jni/android/graphics/NinePatch.cpp
index 9e943f3..b11edfc 100644
--- a/core/jni/android/graphics/NinePatch.cpp
+++ b/core/jni/android/graphics/NinePatch.cpp
@@ -47,19 +47,17 @@ public:
     static void draw(JNIEnv* env, SkCanvas* canvas, SkRect& bounds,
                       const SkBitmap* bitmap, jbyteArray chunkObj, const SkPaint* paint)
     {
-        const jbyte* array = env->GetByteArrayElements(chunkObj, 0);
-        if (array != NULL) {
-            size_t chunkSize = env->GetArrayLength(chunkObj);
+        size_t chunkSize = env->GetArrayLength(chunkObj);
+        void* storage = alloca(chunkSize);
+        env->GetByteArrayRegion(chunkObj, 0, chunkSize,
+                                reinterpret_cast<jbyte*>(storage));
+        if (!env->ExceptionCheck()) {
             // need to deserialize the chunk
-            void* storage = alloca(chunkSize);
             Res_png_9patch* chunk = static_cast<Res_png_9patch*>(storage);
-            memcpy(chunk, array, chunkSize);
             assert(chunkSize == chunk->serializedSize());
             // this relies on deserialization being done in place
             Res_png_9patch::deserialize(chunk);            
             NinePatch_Draw(canvas, bounds, *bitmap, *chunk, paint, NULL);
-            env->ReleaseByteArrayElements(chunkObj, const_cast<jbyte*>(array),
-                                          JNI_ABORT);
         }
     } 
 
@@ -102,23 +100,20 @@ public:
         
         SkRect      bounds;
         GraphicsJNI::jrect_to_rect(env, boundsRect, &bounds);
-        const jbyte* array = (jbyte*)env->GetByteArrayElements(chunkObj, 0);
-        if (array != NULL) {
-            size_t chunkSize = env->GetArrayLength(chunkObj);
+        size_t chunkSize = env->GetArrayLength(chunkObj);
+        void* storage = alloca(chunkSize);
+        env->GetByteArrayRegion(chunkObj, 0, chunkSize,
+                                reinterpret_cast<jbyte*>(storage));
+        if (!env->ExceptionCheck()) {
             // need to deserialize the chunk
-            void* storage = alloca(chunkSize);
             Res_png_9patch* chunk = static_cast<Res_png_9patch*>(storage);
-            memcpy(chunk, array, chunkSize);
             assert(chunkSize == chunk->serializedSize());
             // this relies on deserialization being done in place
             Res_png_9patch::deserialize(chunk);
             SkRegion* region = NULL;
             NinePatch_Draw(NULL, bounds, *bitmap, *chunk, NULL, &region);
-            env->ReleaseByteArrayElements(chunkObj, const_cast<jbyte*>(array),
-                                          JNI_ABORT);
             return (jint)region;
         }
-        
         return 0;
     }