Remove support for density compatibility in the hardware renderer.

Change-Id: I535e919986e5ccfb344ede8516ccd84c02642823

5 files changed, 60 insertions, 113 deletions

diff --git a/core/java/android/hardware/SensorEvent.java b/core/java/android/hardware/SensorEvent.java
index 70519ff26fd6..aaf389895d47 100644
--- a/core/java/android/hardware/SensorEvent.java
+++ b/core/java/android/hardware/SensorEvent.java
@@ -84,14 +84,14 @@ public class SensorEvent {
      * sensor itself (<b>Fs</b>) using the relation:
      * </p>
      * 
-     * <b><center>Ad = - ·Fs / mass</center></b>
+     * <b><center>Ad = - &#8721;Fs / mass</center></b>
      * 
      * <p>
      * In particular, the force of gravity is always influencing the measured
      * acceleration:
      * </p>
      * 
-     * <b><center>Ad = -g - ·F / mass</center></b>
+     * <b><center>Ad = -g - &#8721;F / mass</center></b>
      * 
      * <p>
      * For this reason, when the device is sitting on a table (and obviously not
diff --git a/core/java/android/view/GLES20Canvas.java b/core/java/android/view/GLES20Canvas.java
index 00dc12897da3..49ef8dc350d5 100644
--- a/core/java/android/view/GLES20Canvas.java
+++ b/core/java/android/view/GLES20Canvas.java
@@ -362,53 +362,48 @@ class GLES20Canvas extends Canvas {
     @Override
     public void drawPatch(Bitmap bitmap, byte[] chunks, RectF dst, Paint paint) {
         final int nativePaint = paint == null ? 0 : paint.mNativePaint;
-        nDrawPatch(mRenderer, bitmap.mNativeBitmap, chunks, dst.left, dst.top, dst.right,
-                dst.bottom, nativePaint, bitmap.getDensity(), mDensity, mScreenDensity);
+        nDrawPatch(mRenderer, bitmap.mNativeBitmap, chunks, dst.left, dst.top,
+                dst.right, dst.bottom, nativePaint);
     }
 
     private native void nDrawPatch(int renderer, int bitmap, byte[] chunks, float left, float top,
-            float right, float bottom, int paint, int bitmapDensity, int canvasDensity, int screenDensity);
+            float right, float bottom, int paint);
 
     @Override
     public void drawBitmap(Bitmap bitmap, float left, float top, Paint paint) {
         final int nativePaint = paint == null ? 0 : paint.mNativePaint;
-        nDrawBitmap(mRenderer, bitmap.mNativeBitmap, left, top, nativePaint,
-                bitmap.getDensity(), mDensity, mScreenDensity);
+        nDrawBitmap(mRenderer, bitmap.mNativeBitmap, left, top, nativePaint);
     }
 
+    private native void nDrawBitmap(int renderer, int bitmap, float left, float top, int paint);
+
     @Override
     public void drawBitmap(Bitmap bitmap, Matrix matrix, Paint paint) {
         final int nativePaint = paint == null ? 0 : paint.mNativePaint;
-        nDrawBitmap(mRenderer, bitmap.mNativeBitmap, matrix.native_instance, nativePaint,
-                bitmap.getDensity(), mDensity, mScreenDensity);
+        nDrawBitmap(mRenderer, bitmap.mNativeBitmap, matrix.native_instance, nativePaint);
     }
 
-    private native void nDrawBitmap(int renderer, int bitmap, int matrix, int paint,
-            int bitmapDensity, int canvasDensity, int screenDensity);
+    private native void nDrawBitmap(int renderer, int bitmap, int matrix, int paint);
 
     @Override
     public void drawBitmap(Bitmap bitmap, Rect src, Rect dst, Paint paint) {
         final int nativePaint = paint == null ? 0 : paint.mNativePaint;
         nDrawBitmap(mRenderer, bitmap.mNativeBitmap, src.left, src.top, src.right, src.bottom,
-                dst.left, dst.top, dst.right, dst.bottom, nativePaint,
-                bitmap.getDensity(), mDensity, mScreenDensity);
+                dst.left, dst.top, dst.right, dst.bottom, nativePaint
+        );
     }
 
     @Override
     public void drawBitmap(Bitmap bitmap, Rect src, RectF dst, Paint paint) {
         final int nativePaint = paint == null ? 0 : paint.mNativePaint;
         nDrawBitmap(mRenderer, bitmap.mNativeBitmap, src.left, src.top, src.right, src.bottom,
-                dst.left, dst.top, dst.right, dst.bottom, nativePaint,
-                bitmap.getDensity(), mDensity, mScreenDensity);
+                dst.left, dst.top, dst.right, dst.bottom, nativePaint
+        );
     }
 
-    private native void nDrawBitmap(int renderer, int bitmap, float left, float top, int paint,
-            int bitmapDensity, int canvasDensity, int screenDensity);
-
     private native void nDrawBitmap(int renderer, int bitmap,
             float srcLeft, float srcTop, float srcRight, float srcBottom,
-            float left, float top, float right, float bottom, int paint,
-            int bitmapDensity, int canvasDensity, int screenDensity);
+            float left, float top, float right, float bottom, int paint);
 
     @Override
     public void drawBitmap(int[] colors, int offset, int stride, float x, float y,
diff --git a/core/java/android/view/HardwareRenderer.java b/core/java/android/view/HardwareRenderer.java
index d30bce9bb89a..090a74372c1a 100644
--- a/core/java/android/view/HardwareRenderer.java
+++ b/core/java/android/view/HardwareRenderer.java
@@ -17,10 +17,8 @@
 
 package android.view;
 
-import android.content.res.CompatibilityInfo;
 import android.graphics.Canvas;
 import android.os.SystemClock;
-import android.util.DisplayMetrics;
 import android.util.Log;
 
 import javax.microedition.khronos.egl.EGL10;
@@ -74,14 +72,8 @@ abstract class HardwareRenderer {
      * 
      * @param view The view to draw.
      * @param attachInfo AttachInfo tied to the specified view.
-     * @param translator Translator used to draw applications in compatibility mode.
-     * @param yoff The vertical offset for the drawing.
-     * @param density The density of the application
-     * @param scalingRequired Whether drawing should be scaled.
      */
-    abstract void draw(View view, View.AttachInfo attachInfo,
-            CompatibilityInfo.Translator translator, int yoff, int density,
-            boolean scalingRequired);
+    abstract void draw(View view, View.AttachInfo attachInfo, int yOffset);
 
     /**
      * Initializes the hardware renderer for the specified surface and setup the
@@ -371,9 +363,7 @@ abstract class HardwareRenderer {
         }
 
         @Override
-        void draw(View view, View.AttachInfo attachInfo, CompatibilityInfo.Translator translator,
-                int yoff, int density, boolean scalingRequired) {
-
+        void draw(View view, View.AttachInfo attachInfo, int yOffset) {
             if (canDraw()) {
                 attachInfo.mDrawingTime = SystemClock.uptimeMillis();
                 attachInfo.mIgnoreDirtyState = true;
@@ -383,14 +373,9 @@ abstract class HardwareRenderer {
 
                 Canvas canvas = mCanvas;
                 int saveCount = canvas.save(Canvas.MATRIX_SAVE_FLAG);
+                canvas.translate(0, -yOffset);
+
                 try {
-                    canvas.translate(0, -yoff);
-                    if (translator != null) {
-                        translator.translateCanvas(canvas);
-                    }
-                    canvas.setDensity(density);
-                    canvas.setScreenDensity(scalingRequired ? DisplayMetrics.DENSITY_DEVICE : 0);
-    
                     view.draw(canvas);
                 } finally {
                     canvas.restoreToCount(saveCount);
diff --git a/core/java/android/view/ViewRoot.java b/core/java/android/view/ViewRoot.java
index 9cd9a64db9e7..63934bbeb211 100644
--- a/core/java/android/view/ViewRoot.java
+++ b/core/java/android/view/ViewRoot.java
@@ -1262,7 +1262,7 @@ public final class ViewRoot extends Handler implements ViewParent, View.AttachIn
         
         if (mHwRenderer != null && mHwRenderer.isEnabled()) {
             if (!dirty.isEmpty()) {
-                mHwRenderer.draw(mView, mAttachInfo, mTranslator, yoff, mDensity, scalingRequired);
+                mHwRenderer.draw(mView, mAttachInfo, yoff);
             }
 
             if (scrolling) {
diff --git a/core/jni/android_view_GLES20Canvas.cpp b/core/jni/android_view_GLES20Canvas.cpp
index 47f5bfc59380..1bbac71c171e 100644
--- a/core/jni/android_view_GLES20Canvas.cpp
+++ b/core/jni/android_view_GLES20Canvas.cpp
@@ -178,65 +178,32 @@ static void android_view_GLES20Canvas_concatMatrix(JNIEnv* env, jobject canvas,
 // ----------------------------------------------------------------------------
 
 static void android_view_GLES20Canvas_drawBitmap(JNIEnv* env, jobject canvas,
-        OpenGLRenderer* renderer, SkBitmap* bitmap, float left, float top,
-        SkPaint* paint, jint bitmapDensity, jint canvasDensity,jint screenDensity) {
-    if (canvasDensity == bitmapDensity || canvasDensity == 0 || bitmapDensity == 0) {
-        renderer->drawBitmap(bitmap, left, top, paint);
-    } else {
-        renderer->save(0);
-        const float scale = canvasDensity / float(bitmapDensity);
-        renderer->translate(left, top);
-        renderer->scale(scale, scale);
-        renderer->drawBitmap(bitmap, left, top, paint);
-        renderer->restore();
-    }
+        OpenGLRenderer* renderer, SkBitmap* bitmap, float left, float top, SkPaint* paint) {
+    renderer->drawBitmap(bitmap, left, top, paint);
 }
 
 static void android_view_GLES20Canvas_drawBitmapRect(JNIEnv* env, jobject canvas,
         OpenGLRenderer* renderer, SkBitmap* bitmap,
         float srcLeft, float srcTop, float srcRight, float srcBottom,
-        float dstLeft, float dstTop, float dstRight, float dstBottom,
-        SkPaint* paint, jint bitmapDensity, jint canvasDensity, jint screenDensity) {
-    if (canvasDensity == bitmapDensity || canvasDensity == 0 || bitmapDensity == 0) {
-        renderer->drawBitmap(bitmap, srcLeft, srcTop, srcRight, srcBottom,
-                dstLeft, dstTop, dstRight, dstBottom, paint);
-    } else {
-        // TODO: implement
-    }
+        float dstLeft, float dstTop, float dstRight, float dstBottom, SkPaint* paint) {
+    renderer->drawBitmap(bitmap, srcLeft, srcTop, srcRight, srcBottom,
+            dstLeft, dstTop, dstRight, dstBottom, paint);
 }
 
 static void android_view_GLES20Canvas_drawBitmapMatrix(JNIEnv* env, jobject canvas,
-        OpenGLRenderer* renderer, SkBitmap* bitmap, SkMatrix* matrix, SkPaint* paint,
-        jint bitmapDensity, jint canvasDensity,jint screenDensity) {
-    if (canvasDensity == bitmapDensity || canvasDensity == 0 || bitmapDensity == 0) {
-        renderer->drawBitmap(bitmap, matrix, paint);
-    } else {
-        // TODO: implement
-    }
+        OpenGLRenderer* renderer, SkBitmap* bitmap, SkMatrix* matrix, SkPaint* paint) {
+    renderer->drawBitmap(bitmap, matrix, paint);
 }
 
 static void android_view_GLES20Canvas_drawPatch(JNIEnv* env, jobject canvas,
         OpenGLRenderer* renderer, SkBitmap* bitmap, jbyteArray chunks,
-        float left, float top, float right, float bottom, SkPaint* paint,
-        jint bitmapDensity, jint canvasDensity,jint screenDensity) {
+        float left, float top, float right, float bottom, SkPaint* paint) {
 
     jbyte* storage = env->GetByteArrayElements(chunks, NULL);
     Res_png_9patch* patch = reinterpret_cast<Res_png_9patch*>(storage);
     Res_png_9patch::deserialize(patch);
 
-    if (canvasDensity == bitmapDensity || canvasDensity == 0 || bitmapDensity == 0) {
-        renderer->drawPatch(bitmap, patch, left, top, right, bottom, paint);
-    } else {
-        renderer->save(0);
-        const float scale = canvasDensity / float(bitmapDensity);
-        renderer->translate(left, top);
-        renderer->scale(scale, scale);
-        left = top = 0.0f;
-        right = (right - left) / scale;
-        bottom = (bottom - top) / scale;
-        renderer->drawPatch(bitmap, patch, left, top, right, bottom, paint);
-        renderer->restore();
-    }
+    renderer->drawPatch(bitmap, patch, left, top, right, bottom, paint);
 
     // TODO: make sure that 0 is correct for the flags
     env->ReleaseByteArrayElements(chunks, storage, 0);
@@ -260,37 +227,37 @@ static void android_view_GLES20Canvas_drawRect(JNIEnv* env, jobject canvas,
 const char* const kClassPathName = "android/view/GLES20Canvas";
 
 static JNINativeMethod gMethods[] = {
-    {   "nCreateRenderer",    "()I",                (void*) android_view_GLES20Canvas_createRenderer },
-    {   "nDestroyRenderer",   "(I)V",               (void*) android_view_GLES20Canvas_destroyRenderer },
-    {   "nSetViewport",       "(III)V",             (void*) android_view_GLES20Canvas_setViewport },
-    {   "nPrepare",           "(I)V",               (void*) android_view_GLES20Canvas_prepare },
-
-    {   "nSave",              "(II)I",              (void*) android_view_GLES20Canvas_save },
-    {   "nRestore",           "(I)V",               (void*) android_view_GLES20Canvas_restore },
-    {   "nRestoreToCount",    "(II)V",              (void*) android_view_GLES20Canvas_restoreToCount },
-    {   "nGetSaveCount",      "(I)I",               (void*) android_view_GLES20Canvas_getSaveCount },
-
-    {   "nSaveLayer",         "(IFFFFII)I",         (void*) android_view_GLES20Canvas_saveLayer },
-    {   "nSaveLayerAlpha",    "(IFFFFII)I",         (void*) android_view_GLES20Canvas_saveLayerAlpha },
-
-    {   "nQuickReject",       "(IFFFFI)Z",          (void*) android_view_GLES20Canvas_quickReject },
-    {   "nClipRect",          "(IFFFF)Z",           (void*) android_view_GLES20Canvas_clipRectF },
-    {   "nClipRect",          "(IIIII)Z",           (void*) android_view_GLES20Canvas_clipRect },
-
-    {   "nTranslate",         "(IFF)V",             (void*) android_view_GLES20Canvas_translate },
-    {   "nRotate",            "(IF)V",              (void*) android_view_GLES20Canvas_rotate },
-    {   "nScale",             "(IFF)V",             (void*) android_view_GLES20Canvas_scale },
-
-    {   "nSetMatrix",         "(II)V",              (void*) android_view_GLES20Canvas_setMatrix },
-    {   "nGetMatrix",         "(II)V",              (void*) android_view_GLES20Canvas_getMatrix },
-    {   "nConcatMatrix",      "(II)V",              (void*) android_view_GLES20Canvas_concatMatrix },
-
-    {   "nDrawBitmap",        "(IIFFIIII)V",        (void*) android_view_GLES20Canvas_drawBitmap },
-    {   "nDrawBitmap",        "(IIFFFFFFFFIIII)V",  (void*) android_view_GLES20Canvas_drawBitmapRect },
-    {   "nDrawBitmap",        "(IIIIIII)V",         (void*) android_view_GLES20Canvas_drawBitmapMatrix },
-    {   "nDrawPatch",         "(II[BFFFFIIII)V",    (void*) android_view_GLES20Canvas_drawPatch },
-    {   "nDrawColor",         "(III)V",             (void*) android_view_GLES20Canvas_drawColor },
-    {   "nDrawRect",          "(IFFFFI)V",          (void*) android_view_GLES20Canvas_drawRect },
+    {   "nCreateRenderer",    "()I",             (void*) android_view_GLES20Canvas_createRenderer },
+    {   "nDestroyRenderer",   "(I)V",            (void*) android_view_GLES20Canvas_destroyRenderer },
+    {   "nSetViewport",       "(III)V",          (void*) android_view_GLES20Canvas_setViewport },
+    {   "nPrepare",           "(I)V",            (void*) android_view_GLES20Canvas_prepare },
+
+    {   "nSave",              "(II)I",           (void*) android_view_GLES20Canvas_save },
+    {   "nRestore",           "(I)V",            (void*) android_view_GLES20Canvas_restore },
+    {   "nRestoreToCount",    "(II)V",           (void*) android_view_GLES20Canvas_restoreToCount },
+    {   "nGetSaveCount",      "(I)I",            (void*) android_view_GLES20Canvas_getSaveCount },
+
+    {   "nSaveLayer",         "(IFFFFII)I",      (void*) android_view_GLES20Canvas_saveLayer },
+    {   "nSaveLayerAlpha",    "(IFFFFII)I",      (void*) android_view_GLES20Canvas_saveLayerAlpha },
+
+    {   "nQuickReject",       "(IFFFFI)Z",       (void*) android_view_GLES20Canvas_quickReject },
+    {   "nClipRect",          "(IFFFF)Z",        (void*) android_view_GLES20Canvas_clipRectF },
+    {   "nClipRect",          "(IIIII)Z",        (void*) android_view_GLES20Canvas_clipRect },
+
+    {   "nTranslate",         "(IFF)V",          (void*) android_view_GLES20Canvas_translate },
+    {   "nRotate",            "(IF)V",           (void*) android_view_GLES20Canvas_rotate },
+    {   "nScale",             "(IFF)V",          (void*) android_view_GLES20Canvas_scale },
+
+    {   "nSetMatrix",         "(II)V",           (void*) android_view_GLES20Canvas_setMatrix },
+    {   "nGetMatrix",         "(II)V",           (void*) android_view_GLES20Canvas_getMatrix },
+    {   "nConcatMatrix",      "(II)V",           (void*) android_view_GLES20Canvas_concatMatrix },
+
+    {   "nDrawBitmap",        "(IIFFI)V",        (void*) android_view_GLES20Canvas_drawBitmap },
+    {   "nDrawBitmap",        "(IIFFFFFFFFI)V",  (void*) android_view_GLES20Canvas_drawBitmapRect },
+    {   "nDrawBitmap",        "(IIII)V",         (void*) android_view_GLES20Canvas_drawBitmapMatrix },
+    {   "nDrawPatch",         "(II[BFFFFI)V",    (void*) android_view_GLES20Canvas_drawPatch },
+    {   "nDrawColor",         "(III)V",          (void*) android_view_GLES20Canvas_drawColor },
+    {   "nDrawRect",          "(IFFFFI)V",       (void*) android_view_GLES20Canvas_drawRect },
 
     {   "nGetClipBounds",     "(ILandroid/graphics/Rect;)Z",
             (void*) android_view_GLES20Canvas_getClipBounds },