Allow for screen density drawables in compatibility mode.

This change allows us to use drawables that match the current screen
density even when being loaded in compatibility mode.  In this case,
the bitmap is loaded in the screen density, and the bitmap and
nine-patch drawables take care of accounting for the density difference.

This should be safe for existing applications, for the most part, since
they shouldn't really be pulling the bitmap out of the drawable.  For
the small rare chance of them breaking, it worth getting the correct
graphics.  Also this will only happen when there is actually a resource
of the matching density, and no existing apps should have resources for
anything besides the default density (though of course all of the
framework resources will be available in the native density).

As part of this, the bitmap density API has been changed to a single
integer provider the DPI unit density.

4 files changed, 39 insertions, 26 deletions

diff --git a/core/jni/android/graphics/Canvas.cpp b/core/jni/android/graphics/Canvas.cpp
index 93d68cb..52acf04 100644
--- a/core/jni/android/graphics/Canvas.cpp
+++ b/core/jni/android/graphics/Canvas.cpp
@@ -462,17 +462,18 @@ public:
     static void drawBitmap__BitmapFFPaint(JNIEnv* env, jobject jcanvas,
                                           SkCanvas* canvas, SkBitmap* bitmap,
                                           jfloat left, jfloat top,
-                                          SkPaint* paint,
-                                          jboolean autoScale, jfloat densityScale) {
+                                          SkPaint* paint, jint canvasDensity,
+                                          jint bitmapDensity) {
         SkScalar left_ = SkFloatToScalar(left);
         SkScalar top_ = SkFloatToScalar(top);
 
-        if (!autoScale || densityScale <= 0.0f) {
+        if (canvasDensity == bitmapDensity || canvasDensity == 0
+                || bitmapDensity == 0) {
             canvas->drawBitmap(*bitmap, left_, top_, paint);
         } else {
             canvas->save();
-            SkScalar canvasScale = GraphicsJNI::getCanvasDensityScale(env, jcanvas);
-            SkScalar scale = canvasScale / SkFloatToScalar(densityScale);
+            SkScalar scale = SkFloatToScalar(canvasDensity / (float)bitmapDensity);
+            canvas->translate(left_, top_);
             canvas->scale(scale, scale);
 
             SkPaint filteredPaint;
@@ -481,7 +482,7 @@ public:
             }
             filteredPaint.setFilterBitmap(true);
 
-            canvas->drawBitmap(*bitmap, left_, top_, &filteredPaint);
+            canvas->drawBitmap(*bitmap, 0, 0, &filteredPaint);
 
             canvas->restore();
         }
@@ -905,7 +906,7 @@ static JNINativeMethod gCanvasMethods[] = {
     {"native_drawRoundRect","(ILandroid/graphics/RectF;FFI)V",
         (void*) SkCanvasGlue::drawRoundRect},
     {"native_drawPath","(III)V", (void*) SkCanvasGlue::drawPath},
-    {"native_drawBitmap","(IIFFIZF)V",
+    {"native_drawBitmap","(IIFFIII)V",
         (void*) SkCanvasGlue::drawBitmap__BitmapFFPaint},
     {"native_drawBitmap","(IILandroid/graphics/Rect;Landroid/graphics/RectF;I)V",
         (void*) SkCanvasGlue::drawBitmapRF},
diff --git a/core/jni/android/graphics/Graphics.cpp b/core/jni/android/graphics/Graphics.cpp
index 6e159a8..ca1cb7d 100644
--- a/core/jni/android/graphics/Graphics.cpp
+++ b/core/jni/android/graphics/Graphics.cpp
@@ -163,7 +163,6 @@ static jfieldID gBitmapConfig_nativeInstanceID;
 
 static jclass   gCanvas_class;
 static jfieldID gCanvas_nativeInstanceID;
-static jfieldID gCanvas_densityScaleID;
 
 static jclass   gPaint_class;
 static jfieldID gPaint_nativeInstanceID;
@@ -320,13 +319,6 @@ 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);
@@ -557,7 +549,6 @@ 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 16925e4..f8b60a8 100644
--- a/core/jni/android/graphics/GraphicsJNI.h
+++ b/core/jni/android/graphics/GraphicsJNI.h
@@ -38,7 +38,6 @@ 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 b11edfc..fd5271e 100644
--- a/core/jni/android/graphics/NinePatch.cpp
+++ b/core/jni/android/graphics/NinePatch.cpp
@@ -1,5 +1,6 @@
 #include <utils/ResourceTypes.h>
 
+#include "SkCanvas.h"
 #include "SkRegion.h"
 #include "GraphicsJNI.h"
 
@@ -45,7 +46,8 @@ public:
     }
 
     static void draw(JNIEnv* env, SkCanvas* canvas, SkRect& bounds,
-                      const SkBitmap* bitmap, jbyteArray chunkObj, const SkPaint* paint)
+                      const SkBitmap* bitmap, jbyteArray chunkObj, const SkPaint* paint,
+                      jint destDensity, jint srcDensity)
     {
         size_t chunkSize = env->GetArrayLength(chunkObj);
         void* storage = alloca(chunkSize);
@@ -56,13 +58,32 @@ public:
             Res_png_9patch* chunk = static_cast<Res_png_9patch*>(storage);
             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);
+            Res_png_9patch::deserialize(chunk);
+            
+            if (destDensity == srcDensity || destDensity == 0
+                    || srcDensity == 0) {
+                NinePatch_Draw(canvas, bounds, *bitmap, *chunk, paint, NULL);
+            } else {
+                canvas->save();
+                
+                SkScalar scale = SkFloatToScalar(destDensity / (float)srcDensity);
+                canvas->translate(bounds.fLeft, bounds.fTop);
+                canvas->scale(scale, scale);
+    
+                bounds.fRight = SkScalarDiv(bounds.fRight-bounds.fLeft, scale);
+                bounds.fBottom = SkScalarDiv(bounds.fBottom-bounds.fTop, scale);
+                bounds.fLeft = bounds.fTop = 0;
+    
+                NinePatch_Draw(canvas, bounds, *bitmap, *chunk, paint, NULL);
+    
+                canvas->restore();
+            }
         }
     } 
 
     static void drawF(JNIEnv* env, jobject, SkCanvas* canvas, jobject boundsRectF,
-                      const SkBitmap* bitmap, jbyteArray chunkObj, const SkPaint* paint)
+                      const SkBitmap* bitmap, jbyteArray chunkObj, const SkPaint* paint,
+                      jint destDensity, jint srcDensity)
     {
         SkASSERT(canvas);
         SkASSERT(boundsRectF);
@@ -73,11 +94,12 @@ public:
         SkRect      bounds;
         GraphicsJNI::jrectf_to_rect(env, boundsRectF, &bounds);
 
-        draw(env, canvas, bounds, bitmap, chunkObj, paint);
+        draw(env, canvas, bounds, bitmap, chunkObj, paint, destDensity, srcDensity);
     }
  
     static void drawI(JNIEnv* env, jobject, SkCanvas* canvas, jobject boundsRect,
-                      const SkBitmap* bitmap, jbyteArray chunkObj, const SkPaint* paint)
+                      const SkBitmap* bitmap, jbyteArray chunkObj, const SkPaint* paint,
+                      jint destDensity, jint srcDensity)
     {
         SkASSERT(canvas);
         SkASSERT(boundsRect);
@@ -87,7 +109,7 @@ public:
 
         SkRect      bounds;
         GraphicsJNI::jrect_to_rect(env, boundsRect, &bounds);
-        draw(env, canvas, bounds, bitmap, chunkObj, paint);
+        draw(env, canvas, bounds, bitmap, chunkObj, paint, destDensity, srcDensity);
     }
     
     static jint getTransparentRegion(JNIEnv* env, jobject,
@@ -126,8 +148,8 @@ public:
 static JNINativeMethod gNinePatchMethods[] = {
     { "isNinePatchChunk", "([B)Z",                      (void*)SkNinePatchGlue::isNinePatchChunk   },
     { "validateNinePatchChunk", "(I[B)V",               (void*)SkNinePatchGlue::validateNinePatchChunk   },
-    { "nativeDraw", "(ILandroid/graphics/RectF;I[BI)V", (void*)SkNinePatchGlue::drawF   },
-    { "nativeDraw", "(ILandroid/graphics/Rect;I[BI)V",  (void*)SkNinePatchGlue::drawI   },
+    { "nativeDraw", "(ILandroid/graphics/RectF;I[BIII)V", (void*)SkNinePatchGlue::drawF   },
+    { "nativeDraw", "(ILandroid/graphics/Rect;I[BIII)V",  (void*)SkNinePatchGlue::drawI   },
     { "nativeGetTransparentRegion", "(I[BLandroid/graphics/Rect;)I", 
                                                         (void*)SkNinePatchGlue::getTransparentRegion   }
 };