auto import from //depot/cupcake/@135843

30 files changed, 0 insertions, 6965 deletions

diff --git a/core/jni/android/graphics/Bitmap.cpp b/core/jni/android/graphics/Bitmap.cpp
deleted file mode 100644
index 65f44d5..0000000
--- a/core/jni/android/graphics/Bitmap.cpp
+++ /dev/null
@@ -1,566 +0,0 @@
-#include "SkBitmap.h"

-#include "SkImageEncoder.h"

-#include "SkColorPriv.h"

-#include "GraphicsJNI.h"

-#include "SkDither.h"

-#include "SkUnPreMultiply.h"

-

-#include "Parcel.h"

-#include "android_util_Binder.h"

-#include "android_nio_utils.h"

-#include "CreateJavaOutputStreamAdaptor.h"

-

-#include <jni.h>

-

-#if 0

-    #define TRACE_BITMAP(code)  code

-#else

-    #define TRACE_BITMAP(code)

-#endif

-

-///////////////////////////////////////////////////////////////////////////////

-// Conversions to/from SkColor, for get/setPixels, and the create method, which

-// is basically like setPixels

-

-typedef void (*FromColorProc)(void* dst, const SkColor src[], int width,

-                              int x, int y);

-

-static void FromColor_D32(void* dst, const SkColor src[], int width,

-                          int, int) {

-    SkPMColor* d = (SkPMColor*)dst;

-    

-    for (int i = 0; i < width; i++) {

-        *d++ = SkPreMultiplyColor(*src++);

-    }

-}

-

-static void FromColor_D565(void* dst, const SkColor src[], int width,

-                           int x, int y) {

-    uint16_t* d = (uint16_t*)dst;

-    

-    DITHER_565_SCAN(y);

-    for (int stop = x + width; x < stop; x++) {

-        SkColor c = *src++;

-        *d++ = SkDitherRGBTo565(SkColorGetR(c), SkColorGetG(c), SkColorGetB(c),

-                                DITHER_VALUE(x));

-    }

-}

-

-static void FromColor_D4444(void* dst, const SkColor src[], int width,

-                            int x, int y) {

-    SkPMColor16* d = (SkPMColor16*)dst;

-    

-    DITHER_4444_SCAN(y);

-    for (int stop = x + width; x < stop; x++) {

-        SkPMColor c = SkPreMultiplyColor(*src++);

-        *d++ = SkDitherARGB32To4444(c, DITHER_VALUE(x));

-//        *d++ = SkPixel32ToPixel4444(c);

-    }

-}

-

-// can return NULL

-static FromColorProc ChooseFromColorProc(SkBitmap::Config config) {

-    switch (config) {

-        case SkBitmap::kARGB_8888_Config:

-            return FromColor_D32;

-        case SkBitmap::kARGB_4444_Config:

-            return FromColor_D4444;

-        case SkBitmap::kRGB_565_Config:

-            return FromColor_D565;

-        default:

-            break;

-    }

-    return NULL;

-}

-

-bool GraphicsJNI::SetPixels(JNIEnv* env, jintArray srcColors,

-                            int srcOffset, int srcStride,

-                            int x, int y, int width, int height,

-                            const SkBitmap& dstBitmap) {

-    SkAutoLockPixels alp(dstBitmap);

-    void* dst = dstBitmap.getPixels();

-    FromColorProc proc = ChooseFromColorProc(dstBitmap.config());

-    

-    if (NULL == dst || NULL == proc) {

-        return false;

-    }

-    

-    const jint* array = env->GetIntArrayElements(srcColors, NULL);

-    const SkColor* src = (const SkColor*)array + srcOffset;

-    

-    // reset to to actual choice from caller

-    dst = dstBitmap.getAddr(x, y);

-    // now copy/convert each scanline

-    for (int y = 0; y < height; y++) {

-        proc(dst, src, width, x, y);

-        src += srcStride;

-        dst = (char*)dst + dstBitmap.rowBytes();

-    }

-    

-    env->ReleaseIntArrayElements(srcColors, const_cast<jint*>(array),

-                                 JNI_ABORT);

-    return true;

-}

-

-//////////////////// ToColor procs

-

-typedef void (*ToColorProc)(SkColor dst[], const void* src, int width,

-                            SkColorTable*);

-

-static void ToColor_S32_Alpha(SkColor dst[], const void* src, int width,

-                              SkColorTable*) {

-    SkASSERT(width > 0);

-    const SkPMColor* s = (const SkPMColor*)src;

-    do {

-        *dst++ = SkUnPreMultiply::PMColorToColor(*s++);

-    } while (--width != 0);

-}

-

-static void ToColor_S32_Opaque(SkColor dst[], const void* src, int width,

-                               SkColorTable*) {

-    SkASSERT(width > 0);

-    const SkPMColor* s = (const SkPMColor*)src;

-    do {

-        SkPMColor c = *s++;

-        *dst++ = SkColorSetRGB(SkGetPackedR32(c), SkGetPackedG32(c),

-                               SkGetPackedB32(c));

-    } while (--width != 0);

-}

-

-static void ToColor_S4444_Alpha(SkColor dst[], const void* src, int width,

-                                SkColorTable*) {

-    SkASSERT(width > 0);

-    const SkPMColor16* s = (const SkPMColor16*)src;

-    do {

-        *dst++ = SkUnPreMultiply::PMColorToColor(SkPixel4444ToPixel32(*s++));

-    } while (--width != 0);

-}

-

-static void ToColor_S4444_Opaque(SkColor dst[], const void* src, int width,

-                                 SkColorTable*) {

-    SkASSERT(width > 0);

-    const SkPMColor* s = (const SkPMColor*)src;

-    do {

-        SkPMColor c = SkPixel4444ToPixel32(*s++);

-        *dst++ = SkColorSetRGB(SkGetPackedR32(c), SkGetPackedG32(c),

-                               SkGetPackedB32(c));

-    } while (--width != 0);

-}

-

-static void ToColor_S565(SkColor dst[], const void* src, int width,

-                         SkColorTable*) {

-    SkASSERT(width > 0);

-    const uint16_t* s = (const uint16_t*)src;

-    do {

-        uint16_t c = *s++;

-        *dst++ =  SkColorSetRGB(SkPacked16ToR32(c), SkPacked16ToG32(c),

-                                SkPacked16ToB32(c));

-    } while (--width != 0);

-}

-

-static void ToColor_SI8_Alpha(SkColor dst[], const void* src, int width,

-                              SkColorTable* ctable) {

-    SkASSERT(width > 0);

-    const uint8_t* s = (const uint8_t*)src;

-    const SkPMColor* colors = ctable->lockColors();

-    do {

-        *dst++ = SkUnPreMultiply::PMColorToColor(colors[*s++]);

-    } while (--width != 0);

-    ctable->unlockColors(false);

-}

-

-static void ToColor_SI8_Opaque(SkColor dst[], const void* src, int width,

-                               SkColorTable* ctable) {

-    SkASSERT(width > 0);

-    const uint8_t* s = (const uint8_t*)src;

-    const SkPMColor* colors = ctable->lockColors();

-    do {

-        SkPMColor c = colors[*s++];

-        *dst++ = SkColorSetRGB(SkGetPackedR32(c), SkGetPackedG32(c),

-                               SkGetPackedB32(c));

-    } while (--width != 0);

-    ctable->unlockColors(false);

-}

-

-// can return NULL

-static ToColorProc ChooseToColorProc(const SkBitmap& src) {

-    switch (src.config()) {

-        case SkBitmap::kARGB_8888_Config:

-            return src.isOpaque() ? ToColor_S32_Opaque : ToColor_S32_Alpha;

-        case SkBitmap::kARGB_4444_Config:

-            return src.isOpaque() ? ToColor_S4444_Opaque : ToColor_S4444_Alpha;

-        case SkBitmap::kRGB_565_Config:

-            return ToColor_S565;

-        case SkBitmap::kIndex8_Config:

-            if (src.getColorTable() == NULL) {

-                return NULL;

-            }

-            return src.isOpaque() ? ToColor_SI8_Opaque : ToColor_SI8_Alpha;

-        default:

-            break;

-    }

-    return NULL;

-}

-

-///////////////////////////////////////////////////////////////////////////////

-///////////////////////////////////////////////////////////////////////////////

-

-static jobject Bitmap_creator(JNIEnv* env, jobject, jintArray jColors,

-                              int offset, int stride, int width, int height,

-                              SkBitmap::Config config, jboolean isMutable) {

-    if (width <= 0 || height <= 0) {

-        doThrowIAE(env, "width and height must be > 0");

-        return NULL;

-    }

-    

-    if (NULL != jColors) {

-        size_t n = env->GetArrayLength(jColors);

-        if (n < SkAbs32(stride) * (size_t)height) {

-            doThrowAIOOBE(env);

-            return NULL;

-        }

-    }

-

-    SkBitmap bitmap;

-    

-    bitmap.setConfig(config, width, height);

-    if (!GraphicsJNI::setJavaPixelRef(env, &bitmap, NULL)) {

-        return NULL;

-    }

-

-    if (jColors != NULL) {

-        GraphicsJNI::SetPixels(env, jColors, offset, stride,

-                               0, 0, width, height, bitmap);

-    }

-    

-    return GraphicsJNI::createBitmap(env, new SkBitmap(bitmap), isMutable,

-                                     NULL);

-}

-

-static jobject Bitmap_copy(JNIEnv* env, jobject, const SkBitmap* src,

-                           SkBitmap::Config dstConfig, jboolean isMutable) {

-    SkBitmap            result;

-    JavaPixelAllocator  allocator(env);

-

-    if (!src->copyTo(&result, dstConfig, &allocator)) {

-        return NULL;

-    }

-    

-    return GraphicsJNI::createBitmap(env, new SkBitmap(result), isMutable,

-                                     NULL);

-}

-

-static void Bitmap_destructor(JNIEnv* env, jobject, SkBitmap* bitmap) {

-    delete bitmap;

-}

-

-static void Bitmap_recycle(JNIEnv* env, jobject, SkBitmap* bitmap) {

-    bitmap->setPixels(NULL, NULL);

-}

-

-// These must match the int values in Bitmap.java

-enum JavaEncodeFormat {

-    kJPEG_JavaEncodeFormat = 0,

-    kPNG_JavaEncodeFormat = 1

-};

-

-static bool Bitmap_compress(JNIEnv* env, jobject clazz, SkBitmap* bitmap,

-                            int format, int quality,

-                            jobject jstream, jbyteArray jstorage) {

-    SkImageEncoder::Type fm;

-

-    switch (format) {

-    case kJPEG_JavaEncodeFormat:

-        fm = SkImageEncoder::kJPEG_Type;

-        break;

-    case kPNG_JavaEncodeFormat:

-        fm = SkImageEncoder::kPNG_Type;

-        break;

-    default:

-        return false;

-    }

-

-    bool success = false;

-    SkWStream* strm = CreateJavaOutputStreamAdaptor(env, jstream, jstorage);

-    if (NULL != strm) {

-        SkImageEncoder* encoder = SkImageEncoder::Create(fm);

-        if (NULL != encoder) {

-            success = encoder->encodeStream(strm, *bitmap, quality);

-            delete encoder;

-        }

-        delete strm;

-    }

-    return success;

-}

-

-static void Bitmap_erase(JNIEnv* env, jobject, SkBitmap* bitmap, jint color) {

-    bitmap->eraseColor(color);

-}

-

-static int Bitmap_width(JNIEnv* env, jobject, SkBitmap* bitmap) {

-    return bitmap->width();

-}

-

-static int Bitmap_height(JNIEnv* env, jobject, SkBitmap* bitmap) {

-    return bitmap->height();

-}

-

-static int Bitmap_rowBytes(JNIEnv* env, jobject, SkBitmap* bitmap) {

-    return bitmap->rowBytes();

-}

-

-static int Bitmap_config(JNIEnv* env, jobject, SkBitmap* bitmap) {

-    return bitmap->config();

-}

-

-static jboolean Bitmap_hasAlpha(JNIEnv* env, jobject, SkBitmap* bitmap) {

-    return !bitmap->isOpaque();

-}

-

-///////////////////////////////////////////////////////////////////////////////

-

-static jobject Bitmap_createFromParcel(JNIEnv* env, jobject, jobject parcel) {

-    if (parcel == NULL) {

-        SkDebugf("-------- unparcel parcel is NULL\n");

-        return NULL;

-    }

-    

-    android::Parcel* p = android::parcelForJavaObject(env, parcel);

-    

-    const bool              isMutable = p->readInt32() != 0;

-    const SkBitmap::Config  config = (SkBitmap::Config)p->readInt32();

-    const int               width = p->readInt32();

-    const int               height = p->readInt32();

-    const int               rowBytes = p->readInt32();

-    

-    if (SkBitmap::kARGB_8888_Config != config &&

-            SkBitmap::kRGB_565_Config != config &&

-            SkBitmap::kARGB_4444_Config != config &&

-            SkBitmap::kIndex8_Config != config &&

-            SkBitmap::kA8_Config != config) {

-        SkDebugf("Bitmap_createFromParcel unknown config: %d\n", config);

-        return NULL;

-    }

-

-    SkBitmap* bitmap = new SkBitmap;

-

-    bitmap->setConfig(config, width, height, rowBytes);

-

-    SkColorTable* ctable = NULL;

-    if (config == SkBitmap::kIndex8_Config) {

-        int count = p->readInt32();

-        if (count > 0) {

-            size_t size = count * sizeof(SkPMColor);

-            const SkPMColor* src = (const SkPMColor*)p->readInplace(size);

-            ctable = new SkColorTable(src, count);

-        }

-    }

-    

-    if (!GraphicsJNI::setJavaPixelRef(env, bitmap, ctable)) {

-        ctable->safeUnref();

-        delete bitmap;

-        return NULL;

-    }

-

-    ctable->safeUnref();

-

-    size_t size = bitmap->getSize();

-    bitmap->lockPixels();

-    memcpy(bitmap->getPixels(), p->readInplace(size), size);

-    bitmap->unlockPixels();

-    

-    return GraphicsJNI::createBitmap(env, bitmap, isMutable, NULL);

-}

-

-static jboolean Bitmap_writeToParcel(JNIEnv* env, jobject,

-                                     const SkBitmap* bitmap,

-                                     jboolean isMutable, jobject parcel) {

-    if (parcel == NULL) {

-        SkDebugf("------- writeToParcel null parcel\n");

-        return false;

-    }

-

-    android::Parcel* p = android::parcelForJavaObject(env, parcel);

-    

-    p->writeInt32(isMutable);

-    p->writeInt32(bitmap->config());

-    p->writeInt32(bitmap->width());

-    p->writeInt32(bitmap->height());

-    p->writeInt32(bitmap->rowBytes());

-

-    if (bitmap->getConfig() == SkBitmap::kIndex8_Config) {

-        SkColorTable* ctable = bitmap->getColorTable();

-        if (ctable != NULL) {

-            int count = ctable->count();

-            p->writeInt32(count);

-            memcpy(p->writeInplace(count * sizeof(SkPMColor)),

-                   ctable->lockColors(), count * sizeof(SkPMColor));

-            ctable->unlockColors(false);

-        } else {

-            p->writeInt32(0);   // indicate no ctable

-        }

-    }

-

-    size_t size = bitmap->getSize();

-    bitmap->lockPixels();

-    memcpy(p->writeInplace(size), bitmap->getPixels(), size);

-    bitmap->unlockPixels();

-    return true;

-}

-

-static jobject Bitmap_extractAlpha(JNIEnv* env, jobject clazz,

-                                   const SkBitmap* src, const SkPaint* paint,

-                                   jintArray offsetXY) {

-    SkIPoint  offset;

-    SkBitmap* dst = new SkBitmap;

-    

-    src->extractAlpha(dst, paint, &offset);

-    if (offsetXY != 0 && env->GetArrayLength(offsetXY) >= 2) {

-        int* array = env->GetIntArrayElements(offsetXY, NULL);

-        array[0] = offset.fX;

-        array[1] = offset.fY;

-        env->ReleaseIntArrayElements(offsetXY, array, 0);

-    }

-    

-    return GraphicsJNI::createBitmap(env, dst, true, NULL);

-}

-

-///////////////////////////////////////////////////////////////////////////////

-

-static int Bitmap_getPixel(JNIEnv* env, jobject, const SkBitmap* bitmap,

-                           int x, int y) {

-    SkAutoLockPixels alp(*bitmap);

-

-    ToColorProc proc = ChooseToColorProc(*bitmap);

-    if (NULL == proc) {

-        return 0;

-    }

-    const void* src = bitmap->getAddr(x, y);

-    if (NULL == src) {

-        return 0;

-    }

-    

-    SkColor dst[1];

-    proc(dst, src, 1, bitmap->getColorTable());

-    return dst[0];

-}

-

-static void Bitmap_getPixels(JNIEnv* env, jobject, const SkBitmap* bitmap,

-                             jintArray pixelArray, int offset, int stride,

-                             int x, int y, int width, int height) {

-    SkAutoLockPixels alp(*bitmap);

-    

-    ToColorProc proc = ChooseToColorProc(*bitmap);

-    if (NULL == proc) {

-        return;

-    }

-    const void* src = bitmap->getAddr(x, y);

-    if (NULL == src) {

-        return;

-    }

-

-    SkColorTable* ctable = bitmap->getColorTable();

-    jint* dst = env->GetIntArrayElements(pixelArray, NULL);

-    SkColor* d = (SkColor*)dst + offset;

-    while (--height >= 0) {

-        proc(d, src, width, ctable);

-        d += stride;

-        src = (void*)((const char*)src + bitmap->rowBytes());

-    }

-    env->ReleaseIntArrayElements(pixelArray, dst, 0);

-}

-

-///////////////////////////////////////////////////////////////////////////////

-

-static void Bitmap_setPixel(JNIEnv* env, jobject, const SkBitmap* bitmap,

-                            int x, int y, SkColor color) {

-    SkAutoLockPixels alp(*bitmap);

-    if (NULL == bitmap->getPixels()) {

-        return;

-    }

-

-    FromColorProc proc = ChooseFromColorProc(bitmap->config());

-    if (NULL == proc) {

-        return;

-    }

-

-    proc(bitmap->getAddr(x, y), &color, 1, x, y);

-}

-

-static void Bitmap_setPixels(JNIEnv* env, jobject, const SkBitmap* bitmap,

-                             jintArray pixelArray, int offset, int stride,

-                             int x, int y, int width, int height) {

-    GraphicsJNI::SetPixels(env, pixelArray, offset, stride,

-                           x, y, width, height, *bitmap);

-}

-

-static void Bitmap_copyPixelsToBuffer(JNIEnv* env, jobject,

-                                      const SkBitmap* bitmap, jobject jbuffer) {

-    SkAutoLockPixels alp(*bitmap);

-    const void* src = bitmap->getPixels();

-    

-    if (NULL != src) {

-        android::AutoBufferPointer abp(env, jbuffer, JNI_TRUE);

-

-        // the java side has already checked that buffer is large enough

-        memcpy(abp.pointer(), src, bitmap->getSize());

-    }

-}

-

-static void Bitmap_copyPixelsFromBuffer(JNIEnv* env, jobject,

-                                    const SkBitmap* bitmap, jobject jbuffer) {

-    SkAutoLockPixels alp(*bitmap);

-    void* dst = bitmap->getPixels();

-    

-    if (NULL != dst) {

-        android::AutoBufferPointer abp(env, jbuffer, JNI_FALSE);

-        // the java side has already checked that buffer is large enough

-        memcpy(dst, abp.pointer(), bitmap->getSize());

-    }

-}

-

-///////////////////////////////////////////////////////////////////////////////

-

-#include <android_runtime/AndroidRuntime.h>

-

-static JNINativeMethod gBitmapMethods[] = {

-    {   "nativeCreate",             "([IIIIIIZ)Landroid/graphics/Bitmap;",

-        (void*)Bitmap_creator },

-    {   "nativeCopy",               "(IIZ)Landroid/graphics/Bitmap;",

-        (void*)Bitmap_copy },

-    {   "nativeDestructor",         "(I)V", (void*)Bitmap_destructor },

-    {   "nativeRecycle",            "(I)V", (void*)Bitmap_recycle },

-    {   "nativeCompress",           "(IIILjava/io/OutputStream;[B)Z",

-        (void*)Bitmap_compress },

-    {   "nativeErase",              "(II)V", (void*)Bitmap_erase },

-    {   "nativeWidth",              "(I)I", (void*)Bitmap_width },

-    {   "nativeHeight",             "(I)I", (void*)Bitmap_height },

-    {   "nativeRowBytes",           "(I)I", (void*)Bitmap_rowBytes },

-    {   "nativeConfig",             "(I)I", (void*)Bitmap_config },

-    {   "nativeHasAlpha",           "(I)Z", (void*)Bitmap_hasAlpha },

-    {   "nativeCreateFromParcel",

-        "(Landroid/os/Parcel;)Landroid/graphics/Bitmap;",

-        (void*)Bitmap_createFromParcel },

-    {   "nativeWriteToParcel",      "(IZLandroid/os/Parcel;)Z",

-        (void*)Bitmap_writeToParcel },

-    {   "nativeExtractAlpha",       "(II[I)Landroid/graphics/Bitmap;",

-        (void*)Bitmap_extractAlpha },

-    {   "nativeGetPixel",           "(III)I", (void*)Bitmap_getPixel },

-    {   "nativeGetPixels",          "(I[IIIIIII)V", (void*)Bitmap_getPixels },

-    {   "nativeSetPixel",           "(IIII)V", (void*)Bitmap_setPixel },

-    {   "nativeSetPixels",          "(I[IIIIIII)V", (void*)Bitmap_setPixels },

-    {   "nativeCopyPixelsToBuffer", "(ILjava/nio/Buffer;)V",

-                                            (void*)Bitmap_copyPixelsToBuffer },

-    {   "nativeCopyPixelsFromBuffer", "(ILjava/nio/Buffer;)V",

-                                            (void*)Bitmap_copyPixelsFromBuffer }

-};

-

-#define kClassPathName  "android/graphics/Bitmap"

-

-int register_android_graphics_Bitmap(JNIEnv* env);

-int register_android_graphics_Bitmap(JNIEnv* env)

-{

-    return android::AndroidRuntime::registerNativeMethods(env, kClassPathName,

-                                gBitmapMethods, SK_ARRAY_COUNT(gBitmapMethods));

-}

-

diff --git a/core/jni/android/graphics/BitmapFactory.cpp b/core/jni/android/graphics/BitmapFactory.cpp
deleted file mode 100644
index 332b01c..0000000
--- a/core/jni/android/graphics/BitmapFactory.cpp
+++ /dev/null
@@ -1,604 +0,0 @@
-#define LOG_TAG "BitmapFactory"
-
-#include "SkImageDecoder.h"
-#include "SkPixelRef.h"
-#include "SkStream.h"
-#include "GraphicsJNI.h"
-#include "SkTemplates.h"
-#include "SkUtils.h"
-#include "CreateJavaOutputStreamAdaptor.h"
-
-#include <android_runtime/AndroidRuntime.h>
-#include <utils/Asset.h>
-#include <utils/ResourceTypes.h>
-#include <netinet/in.h>
-#include <sys/mman.h>
-
-static jclass gOptions_class;
-static jfieldID gOptions_justBoundsFieldID;
-static jfieldID gOptions_sampleSizeFieldID;
-static jfieldID gOptions_configFieldID;
-static jfieldID gOptions_ditherFieldID;
-static jfieldID gOptions_widthFieldID;
-static jfieldID gOptions_heightFieldID;
-static jfieldID gOptions_mimeFieldID;
-
-static jclass gFileDescriptor_class;
-static jfieldID gFileDescriptor_descriptor;
-
-#if 0
-    #define TRACE_BITMAP(code)  code
-#else
-    #define TRACE_BITMAP(code)
-#endif
-
-//#define MIN_SIZE_TO_USE_MMAP    (4*1024)
-
-///////////////////////////////////////////////////////////////////////////////
-
-class AutoDecoderCancel {
-public:
-    AutoDecoderCancel(jobject options, SkImageDecoder* decoder);
-    ~AutoDecoderCancel();
-
-    static bool RequestCancel(jobject options);
-    
-private:
-    AutoDecoderCancel*  fNext;
-    AutoDecoderCancel*  fPrev;
-    jobject             fJOptions;  // java options object
-    SkImageDecoder*     fDecoder;
-    
-#ifdef SK_DEBUG
-    static void Validate();
-#else
-    static void Validate() {}
-#endif
-};
-
-static SkMutex  gAutoDecoderCancelMutex;
-static AutoDecoderCancel* gAutoDecoderCancel;
-#ifdef SK_DEBUG
-    static int gAutoDecoderCancelCount;
-#endif
-
-AutoDecoderCancel::AutoDecoderCancel(jobject joptions,
-                                       SkImageDecoder* decoder) {
-    fJOptions = joptions;
-    fDecoder = decoder;
-
-    if (NULL != joptions) {
-        SkAutoMutexAcquire ac(gAutoDecoderCancelMutex);
-
-        // Add us as the head of the list
-        fPrev = NULL;
-        fNext = gAutoDecoderCancel;
-        if (gAutoDecoderCancel) {
-            gAutoDecoderCancel->fPrev = this;
-        }
-        gAutoDecoderCancel = this;
-        
-        SkDEBUGCODE(gAutoDecoderCancelCount += 1;)
-        Validate();
-    }
-}
-
-AutoDecoderCancel::~AutoDecoderCancel() {
-    if (NULL != fJOptions) {
-        SkAutoMutexAcquire ac(gAutoDecoderCancelMutex);
-        
-        // take us out of the dllist
-        AutoDecoderCancel* prev = fPrev;
-        AutoDecoderCancel* next = fNext;
-        
-        if (prev) {
-            SkASSERT(prev->fNext == this);
-            prev->fNext = next;
-        } else {
-            SkASSERT(gAutoDecoderCancel == this);
-            gAutoDecoderCancel = next;
-        }
-        if (next) {
-            SkASSERT(next->fPrev == this);
-            next->fPrev = prev;
-        }
-
-        SkDEBUGCODE(gAutoDecoderCancelCount -= 1;)
-        Validate();
-    }
-}
-
-bool AutoDecoderCancel::RequestCancel(jobject joptions) {
-    SkAutoMutexAcquire ac(gAutoDecoderCancelMutex);
-
-    Validate();
-
-    AutoDecoderCancel* pair = gAutoDecoderCancel;
-    while (pair != NULL) {
-        if (pair->fJOptions == joptions) {
-            pair->fDecoder->cancelDecode();
-            return true;
-        }
-        pair = pair->fNext;
-    }
-    return false;
-}
-
-#ifdef SK_DEBUG
-// can only call this inside a lock on gAutoDecoderCancelMutex 
-void AutoDecoderCancel::Validate() {
-    const int gCount = gAutoDecoderCancelCount;
-
-    if (gCount == 0) {
-        SkASSERT(gAutoDecoderCancel == NULL);
-    } else {
-        SkASSERT(gCount > 0);
-        
-        AutoDecoderCancel* curr = gAutoDecoderCancel;
-        SkASSERT(curr);
-        SkASSERT(curr->fPrev == NULL);
-
-        int count = 0;
-        while (curr) {
-            count += 1;
-            SkASSERT(count <= gCount);
-            if (curr->fPrev) {
-                SkASSERT(curr->fPrev->fNext == curr);
-            }
-            if (curr->fNext) {
-                SkASSERT(curr->fNext->fPrev == curr);
-            }
-            curr = curr->fNext;
-        }
-        SkASSERT(count == gCount);
-    }
-}
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-
-using namespace android;
-
-class NinePatchPeeker : public SkImageDecoder::Peeker {
-public:
-    NinePatchPeeker() {
-        fPatchIsValid = false;
-    }
-
-    ~NinePatchPeeker() {
-        if (fPatchIsValid) {
-            free(fPatch);
-        }
-    }
-
-    bool    fPatchIsValid;
-    Res_png_9patch*  fPatch;
-
-    virtual bool peek(const char tag[], const void* data, size_t length) {
-        if (strcmp("npTc", tag) == 0 && length >= sizeof(Res_png_9patch)) {
-            Res_png_9patch* patch = (Res_png_9patch*) data;
-            size_t patchSize = patch->serializedSize();
-            assert(length == patchSize);
-            // You have to copy the data because it is owned by the png reader
-            Res_png_9patch* patchNew = (Res_png_9patch*) malloc(patchSize);
-            memcpy(patchNew, patch, patchSize);
-            // this relies on deserialization being done in place
-            Res_png_9patch::deserialize(patchNew);
-            patchNew->fileToDevice();
-            if (fPatchIsValid) {
-                free(fPatch);
-            }
-            fPatch = patchNew;
-            //printf("9patch: (%d,%d)-(%d,%d)\n",
-            //       fPatch.sizeLeft, fPatch.sizeTop,
-            //       fPatch.sizeRight, fPatch.sizeBottom);
-            fPatchIsValid = true;
-        } else {
-            fPatch = NULL;
-        }
-        return true;    // keep on decoding
-    }
-};
-
-class AssetStreamAdaptor : public SkStream {
-public:
-    AssetStreamAdaptor(Asset* a) : fAsset(a) {}
-    
-	virtual bool rewind() {
-        off_t pos = fAsset->seek(0, SEEK_SET);
-        return pos != (off_t)-1;
-    }
-    
-	virtual size_t read(void* buffer, size_t size) {
-        ssize_t amount;
-        
-        if (NULL == buffer) {
-            if (0 == size) {  // caller is asking us for our total length
-                return fAsset->getLength();
-            }
-            // asset->seek returns new total offset
-            // we want to return amount that was skipped
-
-            off_t oldOffset = fAsset->seek(0, SEEK_CUR);
-            if (-1 == oldOffset) {
-                return 0;
-            }
-            off_t newOffset = fAsset->seek(size, SEEK_CUR);
-            if (-1 == newOffset) {
-                return 0;
-            }
-            amount = newOffset - oldOffset;
-        } else {
-            amount = fAsset->read(buffer, size);
-        }
-        
-        if (amount < 0) {
-            amount = 0;
-        }
-        return amount;
-    }
-    
-private:
-    Asset*  fAsset;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-static inline int32_t validOrNeg1(bool isValid, int32_t value) {
-//    return isValid ? value : -1;
-    SkASSERT((int)isValid == 0 || (int)isValid == 1);
-    return ((int32_t)isValid - 1) | value;
-}
-
-static jstring getMimeTypeString(JNIEnv* env, SkImageDecoder::Format format) {
-    static const struct {
-        SkImageDecoder::Format fFormat;
-        const char*            fMimeType;
-    } gMimeTypes[] = {
-        { SkImageDecoder::kBMP_Format,  "image/bmp" },
-        { SkImageDecoder::kGIF_Format,  "image/gif" },
-        { SkImageDecoder::kICO_Format,  "image/x-ico" },
-        { SkImageDecoder::kJPEG_Format, "image/jpeg" },
-        { SkImageDecoder::kPNG_Format,  "image/png" },
-        { SkImageDecoder::kWBMP_Format, "image/vnd.wap.wbmp" }
-    };
-    
-    const char* cstr = NULL;
-    for (size_t i = 0; i < SK_ARRAY_COUNT(gMimeTypes); i++) {
-        if (gMimeTypes[i].fFormat == format) {
-            cstr = gMimeTypes[i].fMimeType;
-            break;
-        }
-    }
-
-    jstring jstr = 0;
-    if (NULL != cstr) {
-        jstr = env->NewStringUTF(cstr);
-    }
-    return jstr;
-}
-
-static jobject doDecode(JNIEnv* env, SkStream* stream, jobject padding,
-                        jobject options) {
-
-    int sampleSize = 1;
-    SkImageDecoder::Mode mode = SkImageDecoder::kDecodePixels_Mode;
-    SkBitmap::Config prefConfig = SkBitmap::kNo_Config;
-    bool doDither = true;
-    
-    if (NULL != options) {
-        sampleSize = env->GetIntField(options, gOptions_sampleSizeFieldID);
-        if (env->GetBooleanField(options, gOptions_justBoundsFieldID)) {
-            mode = SkImageDecoder::kDecodeBounds_Mode;
-        }
-        // initialize these, in case we fail later on
-        env->SetIntField(options, gOptions_widthFieldID, -1);
-        env->SetIntField(options, gOptions_heightFieldID, -1);
-        env->SetObjectField(options, gOptions_mimeFieldID, 0);
-        
-        jobject jconfig = env->GetObjectField(options, gOptions_configFieldID);
-        prefConfig = GraphicsJNI::getNativeBitmapConfig(env, jconfig);
-        doDither = env->GetBooleanField(options, gOptions_ditherFieldID);
-    }
-
-    SkImageDecoder* decoder = SkImageDecoder::Factory(stream);
-    if (NULL == decoder) {
-        return NULL;
-    }
-    
-    decoder->setSampleSize(sampleSize);
-    decoder->setDitherImage(doDither);
-
-    NinePatchPeeker     peeker;
-    JavaPixelAllocator  allocator(env);
-    SkBitmap*           bitmap = new SkBitmap;
-    Res_png_9patch      dummy9Patch;
-
-    SkAutoTDelete<SkImageDecoder>   add(decoder);
-    SkAutoTDelete<SkBitmap>         adb(bitmap);
-
-    decoder->setPeeker(&peeker);
-    decoder->setAllocator(&allocator);
-    
-    AutoDecoderCancel   adc(options, decoder);
-
-    if (!decoder->decode(stream, bitmap, prefConfig, mode)) {
-        return NULL;
-    }
-    
-    // update options (if any)
-    if (NULL != options) {
-        env->SetIntField(options, gOptions_widthFieldID, bitmap->width());
-        env->SetIntField(options, gOptions_heightFieldID, bitmap->height());
-        // TODO: set the mimeType field with the data from the codec.
-        // but how to reuse a set of strings, rather than allocating new one
-        // each time?
-        env->SetObjectField(options, gOptions_mimeFieldID,
-                            getMimeTypeString(env, decoder->getFormat()));
-    }
-    
-    // if we're in justBounds mode, return now (skip the java bitmap)
-    if (SkImageDecoder::kDecodeBounds_Mode == mode) {
-        return NULL;
-    }
-
-    jbyteArray ninePatchChunk = NULL;
-    if (peeker.fPatchIsValid) {
-        size_t ninePatchArraySize = peeker.fPatch->serializedSize();
-        ninePatchChunk = env->NewByteArray(ninePatchArraySize);
-        if (NULL == ninePatchChunk) {
-            return NULL;
-        }
-        jbyte* array = (jbyte*)env->GetPrimitiveArrayCritical(ninePatchChunk,
-                                                              NULL);
-        if (NULL == array) {
-            return NULL;
-        }
-        peeker.fPatch->serialize(array);
-        env->ReleasePrimitiveArrayCritical(ninePatchChunk, array, 0);
-    }
-
-    // detach bitmap from its autotdeleter, since we want to own it now
-    adb.detach();
-
-    if (padding) {
-        if (peeker.fPatchIsValid) {
-            GraphicsJNI::set_jrect(env, padding,
-                                   peeker.fPatch->paddingLeft,
-                                   peeker.fPatch->paddingTop,
-                                   peeker.fPatch->paddingRight,
-                                   peeker.fPatch->paddingBottom);
-        } else {
-            GraphicsJNI::set_jrect(env, padding, -1, -1, -1, -1);
-        }
-    }
-    
-    // promise we will never change our pixels (great for sharing and pictures)
-    SkPixelRef* ref = bitmap->pixelRef();
-    SkASSERT(ref);
-    ref->setImmutable();
-
-    return GraphicsJNI::createBitmap(env, bitmap, false, ninePatchChunk);
-}
-
-static jobject nativeDecodeStream(JNIEnv* env, jobject clazz,
-                                  jobject is,       // InputStream
-                                  jbyteArray storage,   // byte[]
-                                  jobject padding,
-                                  jobject options) {  // BitmapFactory$Options
-    jobject bitmap = NULL;
-    SkStream* stream = CreateJavaInputStreamAdaptor(env, is, storage);
-
-    if (stream) {
-        bitmap = doDecode(env, stream, padding, options);
-        stream->unref();
-    }
-    return bitmap;
-}
-
-static ssize_t getFDSize(int fd) {
-    off_t curr = ::lseek(fd, 0, SEEK_CUR);
-    if (curr < 0) {
-        return 0;
-    }
-    size_t size = ::lseek(fd, 0, SEEK_END);
-    ::lseek(fd, curr, SEEK_SET);
-    return size;
-}
-
-/** Restore the file descriptor's offset in our destructor
- */
-class AutoFDSeek {
-public:
-    AutoFDSeek(int fd) : fFD(fd) {
-        fCurr = ::lseek(fd, 0, SEEK_CUR);
-    }
-    ~AutoFDSeek() {
-        if (fCurr >= 0) {
-            ::lseek(fFD, fCurr, SEEK_SET);
-        }
-    }
-private:
-    int     fFD;
-    off_t   fCurr;
-};
-
-static jobject nativeDecodeFileDescriptor(JNIEnv* env, jobject clazz,
-                                          jobject fileDescriptor,
-                                          jobject padding,
-                                          jobject bitmapFactoryOptions) {
-    NPE_CHECK_RETURN_ZERO(env, fileDescriptor);
-
-    jint descriptor = env->GetIntField(fileDescriptor,
-                                       gFileDescriptor_descriptor);
-    
-#ifdef MIN_SIZE_TO_USE_MMAP
-    // First try to use mmap
-    size_t size = getFDSize(descriptor);
-    if (size >= MIN_SIZE_TO_USE_MMAP) {
-        void* addr = mmap(NULL, size, PROT_READ, MAP_PRIVATE, descriptor, 0);
-//        SkDebugf("-------- mmap returned %p %d\n", addr, size);
-        if (MAP_FAILED != addr) {
-            SkMemoryStream strm(addr, size);
-            jobject obj = doDecode(env, &strm, padding, bitmapFactoryOptions);
-            munmap(addr, size);
-            return obj;
-        }
-    }
-#endif
-
-    // we pass false for closeWhenDone, since the caller owns the descriptor    
-    SkFDStream file(descriptor, false);
-    if (!file.isValid()) {
-        return NULL;
-    }
-    
-    /* Restore our offset when we leave, so the caller doesn't have to.
-       This is a real feature, so we can be called more than once with the
-       same descriptor.
-    */
-    AutoFDSeek as(descriptor);
-
-    return doDecode(env, &file, padding, bitmapFactoryOptions);
-}
-
-static jobject nativeDecodeAsset(JNIEnv* env, jobject clazz,
-                                 jint native_asset,    // Asset
-                                 jobject padding,       // Rect
-                                 jobject options) { // BitmapFactory$Options
-    AssetStreamAdaptor  mystream((Asset*)native_asset);
-
-    return doDecode(env, &mystream, padding, options);
-}
-
-static jobject nativeDecodeByteArray(JNIEnv* env, jobject, jbyteArray byteArray,
-                                     int offset, int length, jobject options) {
-    AutoJavaByteArray   ar(env, byteArray);
-    SkMemoryStream  stream(ar.ptr() + offset, length);
-
-    return doDecode(env, &stream, NULL, options);
-}
-
-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[] = {
-    {   "nativeDecodeStream",
-        "(Ljava/io/InputStream;[BLandroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;",
-        (void*)nativeDecodeStream
-    },
-
-    {   "nativeDecodeFileDescriptor",
-        "(Ljava/io/FileDescriptor;Landroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;",
-        (void*)nativeDecodeFileDescriptor
-    },
-
-    {   "nativeDecodeAsset",
-        "(ILandroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;",
-        (void*)nativeDecodeAsset
-    },
-
-    {   "nativeDecodeByteArray",
-        "([BIILandroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;",
-        (void*)nativeDecodeByteArray
-    },
-
-    {   "nativeScaleNinePatch",
-        "([BFLandroid/graphics/Rect;)[B",
-        (void*)nativeScaleNinePatch
-    }
-
-};
-
-static JNINativeMethod gOptionsMethods[] = {
-    {   "requestCancel", "()V", (void*)nativeRequestCancel }
-};
-
-static jclass make_globalref(JNIEnv* env, const char classname[]) {
-    jclass c = env->FindClass(classname);
-    SkASSERT(c);
-    return (jclass)env->NewGlobalRef(c);
-}
-
-static jfieldID getFieldIDCheck(JNIEnv* env, jclass clazz,
-                                const char fieldname[], const char type[]) {
-    jfieldID id = env->GetFieldID(clazz, fieldname, type);
-    SkASSERT(id);
-    return id;
-}
-
-#define kClassPathName  "android/graphics/BitmapFactory"
-
-#define RETURN_ERR_IF_NULL(value) \
-    do { if (!(value)) { assert(0); return -1; } } while (false)
-
-int register_android_graphics_BitmapFactory(JNIEnv* env);
-int register_android_graphics_BitmapFactory(JNIEnv* env) {
-    gOptions_class = make_globalref(env, "android/graphics/BitmapFactory$Options");
-    gOptions_justBoundsFieldID = getFieldIDCheck(env, gOptions_class, "inJustDecodeBounds", "Z");
-    gOptions_sampleSizeFieldID = getFieldIDCheck(env, gOptions_class, "inSampleSize", "I");
-    gOptions_configFieldID = getFieldIDCheck(env, gOptions_class, "inPreferredConfig",
-            "Landroid/graphics/Bitmap$Config;");
-    gOptions_ditherFieldID = getFieldIDCheck(env, gOptions_class, "inDither", "Z");
-    gOptions_widthFieldID = getFieldIDCheck(env, gOptions_class, "outWidth", "I");
-    gOptions_heightFieldID = getFieldIDCheck(env, gOptions_class, "outHeight", "I");
-    gOptions_mimeFieldID = getFieldIDCheck(env, gOptions_class, "outMimeType", "Ljava/lang/String;");
-
-    gFileDescriptor_class = make_globalref(env, "java/io/FileDescriptor");
-    gFileDescriptor_descriptor = getFieldIDCheck(env, gFileDescriptor_class, "descriptor", "I");
-
-    int ret = AndroidRuntime::registerNativeMethods(env,
-                                    "android/graphics/BitmapFactory$Options",
-                                    gOptionsMethods,
-                                    SK_ARRAY_COUNT(gOptionsMethods));
-    if (ret) {
-        return ret;
-    }
-    return android::AndroidRuntime::registerNativeMethods(env, kClassPathName,
-                                         gMethods, SK_ARRAY_COUNT(gMethods));
-}
diff --git a/core/jni/android/graphics/Camera.cpp b/core/jni/android/graphics/Camera.cpp
deleted file mode 100644
index 980003e..0000000
--- a/core/jni/android/graphics/Camera.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-#include "jni.h"
-#include <android_runtime/AndroidRuntime.h>
-
-#include "SkCamera.h"
-
-static jfieldID gNativeInstanceFieldID;
-
-static void Camera_constructor(JNIEnv* env, jobject obj) {
-    Sk3DView* view = new Sk3DView;
-    env->SetIntField(obj, gNativeInstanceFieldID, (int)view);
-}
-
-static void Camera_destructor(JNIEnv* env, jobject obj) {
-    delete (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
-}
-
-static void Camera_save(JNIEnv* env, jobject obj) {
-    Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
-    v->save();
-}
-
-static void Camera_restore(JNIEnv* env, jobject obj) {
-    Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
-    v->restore();
-}
-
-static void Camera_translate(JNIEnv* env, jobject obj,
-                             float dx, float dy, float dz) {
-    Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
-    v->translate(SkFloatToScalar(dx), SkFloatToScalar(dy), SkFloatToScalar(dz));
-}
-
-static void Camera_rotateX(JNIEnv* env, jobject obj, float degrees) {
-    Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
-    v->rotateX(SkFloatToScalar(degrees));
-}
-
-static void Camera_rotateY(JNIEnv* env, jobject obj, float degrees) {
-    Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
-    v->rotateY(SkFloatToScalar(degrees));
-}
-
-static void Camera_rotateZ(JNIEnv* env, jobject obj, float degrees) {
-    Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
-    v->rotateZ(SkFloatToScalar(degrees));
-}
-
-static void Camera_getMatrix(JNIEnv* env, jobject obj, int native_matrix) {
-    Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
-    v->getMatrix((SkMatrix*)native_matrix);
-}
-
-static void Camera_applyToCanvas(JNIEnv* env, jobject obj, int native_canvas) {
-    Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
-    v->applyToCanvas((SkCanvas*)native_canvas);
-}
-
-static float Camera_dotWithNormal(JNIEnv* env, jobject obj,
-                                  float x, float y, float z) {
-    Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID);
-    SkScalar dot = v->dotWithNormal(SkFloatToScalar(x), SkFloatToScalar(y),
-                                    SkFloatToScalar(z));
-    return SkScalarToFloat(dot);
-}
-
-// ----------------------------------------------------------------------------
-
-/*
- * JNI registration.
- */
-static JNINativeMethod gCameraMethods[] = {
-    /* name, signature, funcPtr */
-
-    { "nativeConstructor",   "()V",    (void*)Camera_constructor   },
-    { "nativeDestructor",    "()V",    (void*)Camera_destructor    },
-    { "save",                "()V",    (void*)Camera_save          },
-    { "restore",             "()V",    (void*)Camera_restore       },
-    { "translate",           "(FFF)V", (void*)Camera_translate     },
-    { "rotateX",             "(F)V",   (void*)Camera_rotateX       },
-    { "rotateY",             "(F)V",   (void*)Camera_rotateY       },
-    { "rotateZ",             "(F)V",   (void*)Camera_rotateZ       },
-    { "nativeGetMatrix",     "(I)V",   (void*)Camera_getMatrix     },
-    { "nativeApplyToCanvas", "(I)V",   (void*)Camera_applyToCanvas },
-    { "dotWithNormal",       "(FFF)F", (void*)Camera_dotWithNormal }
-};
-
-int register_android_graphics_Camera(JNIEnv* env);
-int register_android_graphics_Camera(JNIEnv* env) {
-    jclass clazz = env->FindClass("android/graphics/Camera");
-    if (clazz == 0) {
-        return -1;
-    }
-    gNativeInstanceFieldID = env->GetFieldID(clazz, "native_instance", "I");
-    if (gNativeInstanceFieldID == 0) {
-        return -1;
-    }
-    return android::AndroidRuntime::registerNativeMethods(env,
-                                               "android/graphics/Camera",
-                                               gCameraMethods,
-                                               SK_ARRAY_COUNT(gCameraMethods));
-}
-
diff --git a/core/jni/android/graphics/Canvas.cpp b/core/jni/android/graphics/Canvas.cpp
deleted file mode 100644
index 605e4b8..0000000
--- a/core/jni/android/graphics/Canvas.cpp
+++ /dev/null
@@ -1,954 +0,0 @@
-/*
- * Copyright (C) 2006-2007 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "jni.h"
-#include "GraphicsJNI.h"
-#include <android_runtime/AndroidRuntime.h>
-
-#include "SkCanvas.h"
-#include "SkDevice.h"
-#include "SkGLCanvas.h"
-#include "SkShader.h"
-#include "SkTemplates.h"
-
-#define TIME_DRAWx
-
-static uint32_t get_thread_msec() {
-#if defined(HAVE_POSIX_CLOCKS)
-    struct timespec tm;
-    
-    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tm);
-    
-    return tm.tv_sec * 1000LL + tm.tv_nsec / 1000000;
-#else
-    struct timeval tv;
-    
-    gettimeofday(&tv, NULL);
-    return tv.tv_sec * 1000LL + tv.tv_usec / 1000;
-#endif
-}
-
-namespace android {
-
-class SkCanvasGlue {
-public:
-
-    static void finalizer(JNIEnv* env, jobject clazz, SkCanvas* canvas) {
-        canvas->unref();
-    }
-
-    static SkCanvas* initRaster(JNIEnv* env, jobject, SkBitmap* bitmap) {
-        return bitmap ? new SkCanvas(*bitmap) : new SkCanvas;
-    }
-    
-    static SkCanvas* initGL(JNIEnv* env, jobject) {
-        return new SkGLCanvas;
-    }
-    
-    static void freeGlCaches(JNIEnv* env, jobject) {
-        SkGLCanvas::DeleteAllTextures();
-    }
-    
-    static jboolean isOpaque(JNIEnv* env, jobject jcanvas) {
-        NPE_CHECK_RETURN_ZERO(env, jcanvas);
-        SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
-
-        /*
-            Currently we cannot support transparency in GL-based canvas' at
-            the view level. Therefore we cannot base our answer on the device's
-            bitmap, but need to hard-code the answer. If we relax this
-            limitation in views, we can simplify the following code as well.
-         
-            Use the getViewport() call to find out if we're gl-based...
-        */
-        if (canvas->getViewport(NULL)) {
-            return true;
-        }
-        
-        // normal technique, rely on the device's bitmap for the answer
-        return canvas->getDevice()->accessBitmap(false).isOpaque();
-    }
-    
-    static int getWidth(JNIEnv* env, jobject jcanvas) {
-        NPE_CHECK_RETURN_ZERO(env, jcanvas);
-        SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
-        return canvas->getDevice()->accessBitmap(false).width();
-    }
-    
-    static int getHeight(JNIEnv* env, jobject jcanvas) {
-        NPE_CHECK_RETURN_ZERO(env, jcanvas);
-        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);
-    }
-    
-    static void setBitmap(JNIEnv* env, jobject, SkCanvas* canvas,
-                          SkBitmap* bitmap) {
-        canvas->setBitmapDevice(*bitmap);
-    }
- 
-    static int saveAll(JNIEnv* env, jobject jcanvas) {
-        NPE_CHECK_RETURN_ZERO(env, jcanvas);
-        return GraphicsJNI::getNativeCanvas(env, jcanvas)->save();
-    }
-    
-    static int save(JNIEnv* env, jobject jcanvas, SkCanvas::SaveFlags flags) {
-        NPE_CHECK_RETURN_ZERO(env, jcanvas);
-        return GraphicsJNI::getNativeCanvas(env, jcanvas)->save(flags);
-    }
-    
-    static int saveLayer(JNIEnv* env, jobject, SkCanvas* canvas, jobject bounds,
-                         SkPaint* paint, int flags) {
-        SkRect* bounds_ = NULL;
-        SkRect  storage;
-        if (bounds != NULL) {
-            GraphicsJNI::jrectf_to_rect(env, bounds, &storage);
-            bounds_ = &storage;
-        }
-        return canvas->saveLayer(bounds_, paint, (SkCanvas::SaveFlags)flags);
-    }
- 
-    static int saveLayer4F(JNIEnv* env, jobject, SkCanvas* canvas,
-                           jfloat l, jfloat t, jfloat r, jfloat b,
-                           SkPaint* paint, int flags) {
-        SkRect bounds;
-        bounds.set(SkFloatToScalar(l), SkFloatToScalar(t), SkFloatToScalar(r),
-                   SkFloatToScalar(b));
-        return canvas->saveLayer(&bounds, paint, (SkCanvas::SaveFlags)flags);
-    }
- 
-    static int saveLayerAlpha(JNIEnv* env, jobject, SkCanvas* canvas,
-                              jobject bounds, int alpha, int flags) {
-        SkRect* bounds_ = NULL;
-        SkRect  storage;
-        if (bounds != NULL) {
-            GraphicsJNI::jrectf_to_rect(env, bounds, &storage);
-            bounds_ = &storage;
-        }
-        return canvas->saveLayerAlpha(bounds_, alpha,
-                                      (SkCanvas::SaveFlags)flags);
-    }
- 
-    static int saveLayerAlpha4F(JNIEnv* env, jobject, SkCanvas* canvas,
-                                jfloat l, jfloat t, jfloat r, jfloat b,
-                                int alpha, int flags) {
-        SkRect  bounds;
-        bounds.set(SkFloatToScalar(l), SkFloatToScalar(t), SkFloatToScalar(r),
-                   SkFloatToScalar(b));
-        return canvas->saveLayerAlpha(&bounds, alpha,
-                                      (SkCanvas::SaveFlags)flags);
-    }
- 
-    static void restore(JNIEnv* env, jobject jcanvas) {
-        NPE_CHECK_RETURN_VOID(env, jcanvas);
-        SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
-        if (canvas->getSaveCount() <= 1) {  // cannot restore anymore
-            doThrowISE(env, "Underflow in restore");
-            return;
-        }
-        canvas->restore();
-    }
- 
-    static int getSaveCount(JNIEnv* env, jobject jcanvas) {
-        NPE_CHECK_RETURN_ZERO(env, jcanvas);
-        return GraphicsJNI::getNativeCanvas(env, jcanvas)->getSaveCount();
-    }
- 
-    static void restoreToCount(JNIEnv* env, jobject jcanvas, int restoreCount) {
-        NPE_CHECK_RETURN_VOID(env, jcanvas);
-        SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
-        if (restoreCount < 1) {
-            doThrowIAE(env, "Underflow in restoreToCount");
-            return;
-        }
-        canvas->restoreToCount(restoreCount);
-    }
- 
-    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_);
-    }
- 
-    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_);
-    }
- 
-    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_);
-    }
- 
-    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_);
-    }
- 
-    static void concat(JNIEnv* env, jobject, SkCanvas* canvas,
-                       const SkMatrix* matrix) {
-        canvas->concat(*matrix);
-    }
-    
-    static void setMatrix(JNIEnv* env, jobject, SkCanvas* canvas,
-                          const SkMatrix* matrix) {
-        if (NULL == matrix) {
-            canvas->resetMatrix();
-        } else {
-            canvas->setMatrix(*matrix);
-        }
-    }
-    
-    static jboolean clipRect_FFFF(JNIEnv* env, jobject jcanvas, jfloat left,
-                                  jfloat top, jfloat right, jfloat bottom) {
-        NPE_CHECK_RETURN_ZERO(env, jcanvas);
-        SkRect  r;
-        r.set(SkFloatToScalar(left), SkFloatToScalar(top),
-              SkFloatToScalar(right), SkFloatToScalar(bottom));
-        SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas);
-        return c->clipRect(r);
-    }
-    
-    static jboolean clipRect_IIII(JNIEnv* env, jobject jcanvas, jint left,
-                                  jint top, jint right, jint bottom) {
-        NPE_CHECK_RETURN_ZERO(env, jcanvas);
-        SkRect  r;
-        r.set(SkIntToScalar(left), SkIntToScalar(top),
-              SkIntToScalar(right), SkIntToScalar(bottom));
-        return GraphicsJNI::getNativeCanvas(env, jcanvas)->clipRect(r);
-    }
-    
-    static jboolean clipRect_RectF(JNIEnv* env, jobject jcanvas, jobject rectf) {
-        NPE_CHECK_RETURN_ZERO(env, jcanvas);
-        NPE_CHECK_RETURN_ZERO(env, rectf);
-        SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas);
-        SkRect tmp;
-        return c->clipRect(*GraphicsJNI::jrectf_to_rect(env, rectf, &tmp));
-    }
-    
-    static jboolean clipRect_Rect(JNIEnv* env, jobject jcanvas, jobject rect) {
-        NPE_CHECK_RETURN_ZERO(env, jcanvas);
-        NPE_CHECK_RETURN_ZERO(env, rect);
-        SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas);
-        SkRect tmp;
-        return c->clipRect(*GraphicsJNI::jrect_to_rect(env, rect, &tmp));
-    }
-    
-    static jboolean clipRect(JNIEnv* env, jobject, SkCanvas* canvas,
-                             float left, float top, float right, float bottom,
-                             int op) {
-        SkRect rect;
-        rect.set(SkFloatToScalar(left), SkFloatToScalar(top),
-                 SkFloatToScalar(right), SkFloatToScalar(bottom));
-        return canvas->clipRect(rect, (SkRegion::Op)op);
-    }
- 
-    static jboolean clipPath(JNIEnv* env, jobject, SkCanvas* canvas,
-                             SkPath* path, int op) {
-        return canvas->clipPath(*path, (SkRegion::Op)op);
-    }
- 
-    static jboolean clipRegion(JNIEnv* env, jobject, SkCanvas* canvas,
-                               SkRegion* deviceRgn, int op) {
-        return canvas->clipRegion(*deviceRgn, (SkRegion::Op)op);
-    }
-    
-    static void setDrawFilter(JNIEnv* env, jobject, SkCanvas* canvas,
-                              SkDrawFilter* filter) {
-        canvas->setDrawFilter(filter);
-    }
-    
-    static jboolean quickReject__RectFI(JNIEnv* env, jobject, SkCanvas* canvas,
-                                        jobject rect, int edgetype) {
-        SkRect rect_;
-        GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
-        return canvas->quickReject(rect_, (SkCanvas::EdgeType)edgetype);
-    }
- 
-    static jboolean quickReject__PathI(JNIEnv* env, jobject, SkCanvas* canvas,
-                                       SkPath* path, int edgetype) {
-        return canvas->quickReject(*path, (SkCanvas::EdgeType)edgetype);
-    }
- 
-    static jboolean quickReject__FFFFI(JNIEnv* env, jobject, SkCanvas* canvas,
-                                       jfloat left, jfloat top, jfloat right,
-                                       jfloat bottom, int edgetype) {
-        SkRect r;
-        r.set(SkFloatToScalar(left), SkFloatToScalar(top),
-              SkFloatToScalar(right), SkFloatToScalar(bottom));
-        return canvas->quickReject(r, (SkCanvas::EdgeType)edgetype);
-    }
- 
-    static void drawRGB(JNIEnv* env, jobject, SkCanvas* canvas,
-                        jint r, jint g, jint b) {
-        canvas->drawARGB(0xFF, r, g, b);
-    }
- 
-    static void drawARGB(JNIEnv* env, jobject, SkCanvas* canvas,
-                         jint a, jint r, jint g, jint b) {
-        canvas->drawARGB(a, r, g, b);
-    }
- 
-    static void drawColor__I(JNIEnv* env, jobject, SkCanvas* canvas,
-                             jint color) {
-        canvas->drawColor(color);
-    }
- 
-    static void drawColor__II(JNIEnv* env, jobject, SkCanvas* canvas,
-                              jint color, SkPorterDuff::Mode mode) {
-        canvas->drawColor(color, mode);
-    }
- 
-    static void drawPaint(JNIEnv* env, jobject, SkCanvas* canvas,
-                          SkPaint* paint) {
-        canvas->drawPaint(*paint);
-    }
-    
-    static void doPoints(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray,
-                         jint offset, jint count, jobject jpaint,
-                         SkCanvas::PointMode mode) {
-        NPE_CHECK_RETURN_VOID(env, jcanvas);
-        NPE_CHECK_RETURN_VOID(env, jptsArray);
-        NPE_CHECK_RETURN_VOID(env, jpaint);
-        SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
-        const SkPaint& paint = *GraphicsJNI::getNativePaint(env, jpaint);
-        
-        AutoJavaFloatArray autoPts(env, jptsArray);
-        float* floats = autoPts.ptr();
-        const int length = autoPts.length();
-        
-        if ((offset | count) < 0 || offset + count > length) {
-            doThrowAIOOBE(env);
-            return;
-        }
-        
-        // now convert the floats into SkPoints
-        count >>= 1;    // now it is the number of points
-        SkAutoSTMalloc<32, SkPoint> storage(count);
-        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]));
-            src += 2;
-        }        
-        canvas->drawPoints(mode, count, pts, paint);
-    }
-    
-    static void drawPoints(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray,
-                           jint offset, jint count, jobject jpaint) {
-        doPoints(env, jcanvas, jptsArray, offset, count, jpaint,
-                 SkCanvas::kPoints_PointMode);
-    }
-    
-    static void drawLines(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray,
-                           jint offset, jint count, jobject jpaint) {
-        doPoints(env, jcanvas, jptsArray, offset, count, jpaint,
-                 SkCanvas::kLines_PointMode);
-    }
-    
-    static void drawPoint(JNIEnv* env, jobject jcanvas, float x, float y,
-                          jobject jpaint) {
-        NPE_CHECK_RETURN_VOID(env, jcanvas);
-        NPE_CHECK_RETURN_VOID(env, jpaint);
-        SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas);
-        const SkPaint& paint = *GraphicsJNI::getNativePaint(env, jpaint);
-        
-        canvas->drawPoint(SkFloatToScalar(x), SkFloatToScalar(y), paint);
-    }
- 
-    static void drawLine__FFFFPaint(JNIEnv* env, jobject, SkCanvas* canvas,
-                                    jfloat startX, jfloat startY, jfloat stopX,
-                                    jfloat stopY, SkPaint* paint) {
-        canvas->drawLine(SkFloatToScalar(startX), SkFloatToScalar(startY),
-                         SkFloatToScalar(stopX), SkFloatToScalar(stopY),
-                         *paint);
-    }
- 
-    static void drawRect__RectFPaint(JNIEnv* env, jobject, SkCanvas* canvas,
-                                     jobject rect, SkPaint* paint) {
-        SkRect rect_;
-        GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
-        canvas->drawRect(rect_, *paint);
-    }
- 
-    static void drawRect__FFFFPaint(JNIEnv* env, jobject, SkCanvas* canvas,
-                                    jfloat left, jfloat top, jfloat right,
-                                    jfloat bottom, SkPaint* paint) {
-        SkScalar left_ = SkFloatToScalar(left);
-        SkScalar top_ = SkFloatToScalar(top);
-        SkScalar right_ = SkFloatToScalar(right);
-        SkScalar bottom_ = SkFloatToScalar(bottom);
-        canvas->drawRectCoords(left_, top_, right_, bottom_, *paint);
-    }
- 
-    static void drawOval(JNIEnv* env, jobject, SkCanvas* canvas, jobject joval,
-                         SkPaint* paint) {
-        SkRect oval;
-        GraphicsJNI::jrectf_to_rect(env, joval, &oval);
-        canvas->drawOval(oval, *paint);
-    }
- 
-    static void drawCircle(JNIEnv* env, jobject, SkCanvas* canvas, jfloat cx,
-                           jfloat cy, jfloat radius, SkPaint* paint) {
-        canvas->drawCircle(SkFloatToScalar(cx), SkFloatToScalar(cy),
-                           SkFloatToScalar(radius), *paint);
-    }
- 
-    static void drawArc(JNIEnv* env, jobject, SkCanvas* canvas, jobject joval,
-                        jfloat startAngle, jfloat sweepAngle,
-                        jboolean useCenter, SkPaint* paint) {
-        SkRect oval;
-        GraphicsJNI::jrectf_to_rect(env, joval, &oval);
-        canvas->drawArc(oval, SkFloatToScalar(startAngle),
-                        SkFloatToScalar(sweepAngle), useCenter, *paint);
-    }
- 
-    static void drawRoundRect(JNIEnv* env, jobject, SkCanvas* canvas,
-                              jobject jrect, jfloat rx, jfloat ry,
-                              SkPaint* paint) {
-        SkRect rect;
-        GraphicsJNI::jrectf_to_rect(env, jrect, &rect);
-        canvas->drawRoundRect(rect, SkFloatToScalar(rx), SkFloatToScalar(ry),
-                              *paint);
-    }
- 
-    static void drawPath(JNIEnv* env, jobject, SkCanvas* canvas, SkPath* path,
-                         SkPaint* paint) {
-        canvas->drawPath(*path, *paint);
-    }
- 
-    static void drawPicture(JNIEnv* env, jobject, SkCanvas* canvas,
-                            SkPicture* picture) {
-        SkASSERT(canvas);
-        SkASSERT(picture);
-        
-#ifdef TIME_DRAW
-        SkMSec now = get_thread_msec(); //SkTime::GetMSecs();
-#endif
-        canvas->drawPicture(*picture);
-#ifdef TIME_DRAW
-        LOGD("---- picture playback %d ms\n", get_thread_msec() - now);
-#endif
-    }
-
-    static void drawBitmap__BitmapFFPaint(JNIEnv* env, jobject jcanvas,
-                                          SkCanvas* canvas, SkBitmap* bitmap,
-                                          jfloat left, jfloat top,
-                                          SkPaint* paint,
-                                          jboolean autoScale, jfloat densityScale) {
-        SkScalar left_ = SkFloatToScalar(left);
-        SkScalar top_ = SkFloatToScalar(top);
-
-        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,
-                        jobject srcIRect, const SkRect& dst, SkPaint* paint) {
-        SkIRect    src, *srcPtr = NULL;
-
-        if (NULL != srcIRect) {
-            GraphicsJNI::jrect_to_irect(env, srcIRect, &src);
-            srcPtr = &src;
-        }
-        canvas->drawBitmapRect(*bitmap, srcPtr, dst, paint);
-    }
-
-    static void drawBitmapRF(JNIEnv* env, jobject, SkCanvas* canvas,
-                             SkBitmap* bitmap, jobject srcIRect,
-                             jobject dstRectF, SkPaint* paint) {
-        SkRect      dst;
-        GraphicsJNI::jrectf_to_rect(env, dstRectF, &dst);
-        doDrawBitmap(env, canvas, bitmap, srcIRect, dst, paint);
-    }
-    
-    static void drawBitmapRR(JNIEnv* env, jobject, SkCanvas* canvas,
-                             SkBitmap* bitmap, jobject srcIRect,
-                             jobject dstRect, SkPaint* paint) {
-        SkRect      dst;
-        GraphicsJNI::jrect_to_rect(env, dstRect, &dst);
-        doDrawBitmap(env, canvas, bitmap, srcIRect, dst, paint);
-    }
-    
-    static void drawBitmapArray(JNIEnv* env, jobject, SkCanvas* canvas,
-                                jintArray jcolors, int offset, int stride,
-                                jfloat x, jfloat y, int width, int height,
-                                jboolean hasAlpha, SkPaint* paint)
-    {
-        SkBitmap    bitmap;
-        
-        bitmap.setConfig(hasAlpha ? SkBitmap::kARGB_8888_Config :
-                         SkBitmap::kRGB_565_Config, width, height);
-        if (!bitmap.allocPixels()) {
-            return;
-        }
-        
-        if (!GraphicsJNI::SetPixels(env, jcolors, offset, stride,
-                                    0, 0, width, height, bitmap)) {
-            return;
-        }
-        
-        canvas->drawBitmap(bitmap, SkFloatToScalar(x), SkFloatToScalar(y),
-                           paint);
-    }
-    
-    static void drawBitmapMatrix(JNIEnv* env, jobject, SkCanvas* canvas,
-                                 const SkBitmap* bitmap, const SkMatrix* matrix,
-                                 const SkPaint* paint) {
-        canvas->drawBitmapMatrix(*bitmap, *matrix, paint);
-    }
-    
-    static void drawBitmapMesh(JNIEnv* env, jobject, SkCanvas* canvas,
-                          const SkBitmap* bitmap, int meshWidth, int meshHeight,
-                          jfloatArray jverts, int vertIndex, jintArray jcolors,
-                          int colorIndex, const SkPaint* paint) {
-
-        const int ptCount = (meshWidth + 1) * (meshHeight + 1);
-        const int indexCount = meshWidth * meshHeight * 6;
-
-        AutoJavaFloatArray  vertA(env, jverts, vertIndex + (ptCount << 1));
-        AutoJavaIntArray    colorA(env, jcolors, colorIndex + ptCount);
-        
-        /*  Our temp storage holds 2 or 3 arrays.
-            texture points [ptCount * sizeof(SkPoint)]
-            optionally vertex points [ptCount * sizeof(SkPoint)] if we need a
-                copy to convert from float to fixed
-            indices [ptCount * sizeof(uint16_t)]
-        */
-        ssize_t storageSize = ptCount * sizeof(SkPoint); // texs[]
-#ifdef SK_SCALAR_IS_FIXED
-        storageSize += ptCount * sizeof(SkPoint);  // storage for verts
-#endif
-        storageSize += indexCount * sizeof(uint16_t);  // indices[]
-
-        SkAutoMalloc storage(storageSize);
-        SkPoint* texs = (SkPoint*)storage.get();
-        SkPoint* verts;
-        uint16_t* indices;
-#ifdef SK_SCALAR_IS_FLOAT
-        verts = (SkPoint*)(vertA.ptr() + vertIndex);
-        indices = (uint16_t*)(texs + ptCount);
-#else
-        verts = texs + ptCount;
-        indices = (uint16_t*)(verts + ptCount);
-        // convert floats to fixed
-        {
-            const float* src = vertA.ptr() + vertIndex;
-            for (int i = 0; i < ptCount; i++) {
-                verts[i].set(SkFloatToFixed(src[0]), SkFloatToFixed(src[1]));
-                src += 2;
-            }
-        }
-#endif
-
-        // cons up texture coordinates and indices
-        {
-            const SkScalar w = SkIntToScalar(bitmap->width());
-            const SkScalar h = SkIntToScalar(bitmap->height());
-            const SkScalar dx = w / meshWidth;
-            const SkScalar dy = h / meshHeight;
-            
-            SkPoint* texsPtr = texs;
-            SkScalar y = 0;
-            for (int i = 0; i <= meshHeight; i++) {
-                if (i == meshHeight) {
-                    y = h;  // to ensure numerically we hit h exactly
-                }
-                SkScalar x = 0;
-                for (int j = 0; j < meshWidth; j++) {
-                    texsPtr->set(x, y);
-                    texsPtr += 1;
-                    x += dx;
-                }
-                texsPtr->set(w, y);
-                texsPtr += 1;
-                y += dy;
-            }
-            SkASSERT(texsPtr - texs == ptCount);
-        }
-        
-        // cons up indices
-        {
-            uint16_t* indexPtr = indices;
-            int index = 0;
-            for (int i = 0; i < meshHeight; i++) {
-                for (int j = 0; j < meshWidth; j++) {
-                    // lower-left triangle
-                    *indexPtr++ = index;
-                    *indexPtr++ = index + meshWidth + 1;
-                    *indexPtr++ = index + meshWidth + 2;
-                    // upper-right triangle
-                    *indexPtr++ = index;
-                    *indexPtr++ = index + meshWidth + 2;
-                    *indexPtr++ = index + 1;
-                    // bump to the next cell
-                    index += 1;
-                }
-                // bump to the next row
-                index += 1;
-            }
-            SkASSERT(indexPtr - indices == indexCount);
-            SkASSERT((char*)indexPtr - (char*)storage.get() == storageSize);
-        }
-
-        // double-check that we have legal indices
-#ifdef SK_DEBUG
-        {
-            for (int i = 0; i < indexCount; i++) {
-                SkASSERT((unsigned)indices[i] < (unsigned)ptCount);
-            }
-        }
-#endif
-
-        // cons-up a shader for the bitmap
-        SkPaint tmpPaint;
-        if (paint) {
-            tmpPaint = *paint;
-        }
-        SkShader* shader = SkShader::CreateBitmapShader(*bitmap,
-                        SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
-        tmpPaint.setShader(shader)->safeUnref();
-
-        canvas->drawVertices(SkCanvas::kTriangles_VertexMode, ptCount, verts,
-                             texs, (const SkColor*)colorA.ptr(), NULL, indices,
-                             indexCount, tmpPaint);
-    }
-
-    static void drawVertices(JNIEnv* env, jobject, SkCanvas* canvas,
-                             SkCanvas::VertexMode mode, int vertexCount,
-                             jfloatArray jverts, int vertIndex,
-                             jfloatArray jtexs, int texIndex,
-                             jintArray jcolors, int colorIndex,
-                             jshortArray jindices, int indexIndex,
-                             int indexCount, const SkPaint* paint) {
-
-        AutoJavaFloatArray  vertA(env, jverts, vertIndex + vertexCount);
-        AutoJavaFloatArray  texA(env, jtexs, texIndex + vertexCount);
-        AutoJavaIntArray    colorA(env, jcolors, colorIndex + vertexCount);
-        AutoJavaShortArray  indexA(env, jindices, indexIndex + indexCount);
-
-        const int ptCount = vertexCount >> 1;
-
-        SkPoint* verts;
-        SkPoint* texs = NULL;
-#ifdef SK_SCALAR_IS_FLOAT
-        verts = (SkPoint*)(vertA.ptr() + vertIndex);
-        if (jtexs != NULL) {
-            texs = (SkPoint*)(texA.ptr() + texIndex);
-        }
-#else
-        int count = ptCount;    // for verts
-        if (jtexs != NULL) {
-            count += ptCount;   // += for texs
-        }
-        SkAutoMalloc storage(count * sizeof(SkPoint));
-        verts = (SkPoint*)storage.get();        
-        const float* src = vertA.ptr() + vertIndex;
-        for (int i = 0; i < ptCount; i++) {
-            verts[i].set(SkFloatToFixed(src[0]), SkFloatToFixed(src[1]));
-            src += 2;
-        }
-        if (jtexs != NULL) {
-            texs = verts + ptCount;
-            src = texA.ptr() + texIndex;
-            for (int i = 0; i < ptCount; i++) {
-                texs[i].set(SkFloatToFixed(src[0]), SkFloatToFixed(src[1]));
-                src += 2;
-            }
-        }
-#endif
-
-        const SkColor* colors = NULL;
-        const uint16_t* indices = NULL;
-        if (jcolors != NULL) {
-            colors = (const SkColor*)(colorA.ptr() + colorIndex);
-        }
-        if (jindices != NULL) {
-            indices = (const uint16_t*)(indexA.ptr() + indexIndex);
-        }
-
-        canvas->drawVertices(mode, ptCount, verts, texs, colors, NULL,
-                             indices, indexCount, *paint);
-    }
-    
-    static void drawText___CIIFFPaint(JNIEnv* env, jobject, SkCanvas* canvas,
-                                      jcharArray text, int index, int count,
-                                      jfloat x, jfloat y, SkPaint* paint) {
-        jchar* textArray = env->GetCharArrayElements(text, NULL);
-        jsize textCount = env->GetArrayLength(text);
-        SkScalar x_ = SkFloatToScalar(x);
-        SkScalar y_ = SkFloatToScalar(y);
-        textArray += index;
-        canvas->drawText(textArray, count << 1, x_, y_, *paint);
-        env->ReleaseCharArrayElements(text, textArray, 0);
-    }
- 
-    static void drawText__StringIIFFPaint(JNIEnv* env, jobject,
-                            SkCanvas* canvas, jstring text, int start, int end,
-                                          jfloat x, jfloat y, SkPaint* paint) {
-        const void* text_ = env->GetStringChars(text, NULL);
-        SkScalar x_ = SkFloatToScalar(x);
-        SkScalar y_ = SkFloatToScalar(y);
-        canvas->drawText((const uint16_t*)text_ + start, (end - start) << 1,
-                         x_, y_, *paint);
-        env->ReleaseStringChars(text, (const jchar*) text_);
-    }
-    
-    static void drawString(JNIEnv* env, jobject canvas, jstring text,
-                           jfloat x, jfloat y, jobject paint) {
-        NPE_CHECK_RETURN_VOID(env, canvas);
-        NPE_CHECK_RETURN_VOID(env, paint);
-        NPE_CHECK_RETURN_VOID(env, text);
-        size_t count = env->GetStringLength(text);
-        if (0 == count) {
-            return;
-        }
-        const jchar* text_ = env->GetStringChars(text, NULL);
-        SkCanvas* c = GraphicsJNI::getNativeCanvas(env, canvas);
-        c->drawText(text_, count << 1, SkFloatToScalar(x), SkFloatToScalar(y),
-                    *GraphicsJNI::getNativePaint(env, paint));
-        env->ReleaseStringChars(text, text_);
-    }
-    
-    static void drawPosText___CII_FPaint(JNIEnv* env, jobject, SkCanvas* canvas,
-                                         jcharArray text, int index, int count,
-                                         jfloatArray pos, SkPaint* paint) {
-        jchar* textArray = text ? env->GetCharArrayElements(text, NULL) : NULL;
-        jsize textCount = text ? env->GetArrayLength(text) : NULL;
-        float* posArray = pos ? env->GetFloatArrayElements(pos, NULL) : NULL;
-        int posCount = pos ? env->GetArrayLength(pos) >> 1: 0;
-        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]);
-        }
-        textArray += index;
-        canvas->drawPosText(textArray, count << 1, posPtr, *paint);
-        if (text) {
-            env->ReleaseCharArrayElements(text, textArray, 0);
-        }
-        if (pos) {
-            env->ReleaseFloatArrayElements(pos, posArray, 0);
-        }
-        delete[] posPtr;
-    }
- 
-    static void drawPosText__String_FPaint(JNIEnv* env, jobject,
-                                           SkCanvas* canvas, jstring text,
-                                           jfloatArray pos, SkPaint* paint) {
-        const void* text_ = text ? env->GetStringChars(text, NULL) : NULL;
-        int byteLength = text ? env->GetStringLength(text) : 0;
-        float* posArray = pos ? env->GetFloatArrayElements(pos, NULL) : NULL;
-        int posCount = pos ? env->GetArrayLength(pos) >> 1: 0;
-        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]);
-        }
-        canvas->drawPosText(text_, byteLength << 1, posPtr, *paint);
-        if (text) {
-            env->ReleaseStringChars(text, (const jchar*) text_);
-        }
-        if (pos) {
-            env->ReleaseFloatArrayElements(pos, posArray, 0);
-        }
-        delete[] posPtr;
-    }
- 
-    static void drawTextOnPath___CIIPathFFPaint(JNIEnv* env, jobject,
-                        SkCanvas* canvas, jcharArray text, int index, int count,
-                SkPath* path, jfloat hOffset, jfloat vOffset, SkPaint* paint) {
-
-        jchar* textArray = env->GetCharArrayElements(text, NULL);
-        canvas->drawTextOnPathHV(textArray + index, count << 1, *path,
-                    SkFloatToScalar(hOffset), SkFloatToScalar(vOffset), *paint);
-        env->ReleaseCharArrayElements(text, textArray, 0);
-    }
- 
-    static void drawTextOnPath__StringPathFFPaint(JNIEnv* env, jobject,
-                            SkCanvas* canvas, jstring text, SkPath* path,
-                            jfloat hOffset, jfloat vOffset, SkPaint* paint) {
-        const jchar* text_ = env->GetStringChars(text, NULL);
-        int byteLength = env->GetStringLength(text) << 1;
-        canvas->drawTextOnPathHV(text_, byteLength, *path,
-                    SkFloatToScalar(hOffset), SkFloatToScalar(vOffset), *paint);
-        env->ReleaseStringChars(text, text_);
-    }
- 
-    static bool getClipBounds(JNIEnv* env, jobject, SkCanvas* canvas,
-                              jobject bounds) {
-        SkRect   r;
-        SkIRect ir;
-        bool     result = canvas->getClipBounds(&r, SkCanvas::kBW_EdgeType);
-
-        r.round(&ir);
-        (void)GraphicsJNI::irect_to_jrect(ir, env, bounds);
-        return result;
-    }
-
-    static void getCTM(JNIEnv* env, jobject, SkCanvas* canvas,
-                       SkMatrix* matrix) {
-        *matrix = canvas->getTotalMatrix();
-    }
-};
-    
-///////////////////////////////////////////////////////////////////////////////
-
-static JNINativeMethod gCanvasMethods[] = {
-    {"finalizer", "(I)V", (void*) SkCanvasGlue::finalizer},
-    {"initRaster","(I)I", (void*) SkCanvasGlue::initRaster},
-    {"initGL","()I", (void*) SkCanvasGlue::initGL},
-    {"isOpaque","()Z", (void*) SkCanvasGlue::isOpaque},
-    {"getWidth","()I", (void*) SkCanvasGlue::getWidth},
-    {"getHeight","()I", (void*) SkCanvasGlue::getHeight},
-    {"native_setBitmap","(II)V", (void*) SkCanvasGlue::setBitmap},
-    {"nativeSetViewport", "(III)V", (void*) SkCanvasGlue::setViewport},
-    {"save","()I", (void*) SkCanvasGlue::saveAll},
-    {"save","(I)I", (void*) SkCanvasGlue::save},
-    {"native_saveLayer","(ILandroid/graphics/RectF;II)I",
-        (void*) SkCanvasGlue::saveLayer},
-    {"native_saveLayer","(IFFFFII)I", (void*) SkCanvasGlue::saveLayer4F},
-    {"native_saveLayerAlpha","(ILandroid/graphics/RectF;II)I",
-        (void*) SkCanvasGlue::saveLayerAlpha},
-    {"native_saveLayerAlpha","(IFFFFII)I",
-        (void*) SkCanvasGlue::saveLayerAlpha4F},
-    {"restore","()V", (void*) SkCanvasGlue::restore},
-    {"getSaveCount","()I", (void*) SkCanvasGlue::getSaveCount},
-    {"restoreToCount","(I)V", (void*) SkCanvasGlue::restoreToCount},
-    {"translate","(FF)V", (void*) SkCanvasGlue::translate},
-    {"scale","(FF)V", (void*) SkCanvasGlue::scale__FF},
-    {"rotate","(F)V", (void*) SkCanvasGlue::rotate__F},
-    {"skew","(FF)V", (void*) SkCanvasGlue::skew__FF},
-    {"native_concat","(II)V", (void*) SkCanvasGlue::concat},
-    {"native_setMatrix","(II)V", (void*) SkCanvasGlue::setMatrix},
-    {"clipRect","(FFFF)Z", (void*) SkCanvasGlue::clipRect_FFFF},
-    {"clipRect","(IIII)Z", (void*) SkCanvasGlue::clipRect_IIII},
-    {"clipRect","(Landroid/graphics/RectF;)Z",
-        (void*) SkCanvasGlue::clipRect_RectF},
-    {"clipRect","(Landroid/graphics/Rect;)Z",
-        (void*) SkCanvasGlue::clipRect_Rect},
-    {"native_clipRect","(IFFFFI)Z", (void*) SkCanvasGlue::clipRect},
-    {"native_clipPath","(III)Z", (void*) SkCanvasGlue::clipPath},
-    {"native_clipRegion","(III)Z", (void*) SkCanvasGlue::clipRegion},
-    {"nativeSetDrawFilter", "(II)V", (void*) SkCanvasGlue::setDrawFilter},
-    {"native_getClipBounds","(ILandroid/graphics/Rect;)Z",
-        (void*) SkCanvasGlue::getClipBounds},
-    {"native_getCTM", "(II)V", (void*)SkCanvasGlue::getCTM},
-    {"native_quickReject","(ILandroid/graphics/RectF;I)Z",
-        (void*) SkCanvasGlue::quickReject__RectFI},
-    {"native_quickReject","(III)Z", (void*) SkCanvasGlue::quickReject__PathI},
-    {"native_quickReject","(IFFFFI)Z", (void*)SkCanvasGlue::quickReject__FFFFI},
-    {"native_drawRGB","(IIII)V", (void*) SkCanvasGlue::drawRGB},
-    {"native_drawARGB","(IIIII)V", (void*) SkCanvasGlue::drawARGB},
-    {"native_drawColor","(II)V", (void*) SkCanvasGlue::drawColor__I},
-    {"native_drawColor","(III)V", (void*) SkCanvasGlue::drawColor__II},
-    {"native_drawPaint","(II)V", (void*) SkCanvasGlue::drawPaint},
-    {"drawPoint", "(FFLandroid/graphics/Paint;)V",
-    (void*) SkCanvasGlue::drawPoint},
-    {"drawPoints", "([FIILandroid/graphics/Paint;)V",
-        (void*) SkCanvasGlue::drawPoints},
-    {"drawLines", "([FIILandroid/graphics/Paint;)V",
-        (void*) SkCanvasGlue::drawLines},
-    {"native_drawLine","(IFFFFI)V", (void*) SkCanvasGlue::drawLine__FFFFPaint},
-    {"native_drawRect","(ILandroid/graphics/RectF;I)V",
-        (void*) SkCanvasGlue::drawRect__RectFPaint},
-    {"native_drawRect","(IFFFFI)V", (void*) SkCanvasGlue::drawRect__FFFFPaint},
-    {"native_drawOval","(ILandroid/graphics/RectF;I)V",
-        (void*) SkCanvasGlue::drawOval},
-    {"native_drawCircle","(IFFFI)V", (void*) SkCanvasGlue::drawCircle},
-    {"native_drawArc","(ILandroid/graphics/RectF;FFZI)V",
-        (void*) SkCanvasGlue::drawArc},
-    {"native_drawRoundRect","(ILandroid/graphics/RectF;FFI)V",
-        (void*) SkCanvasGlue::drawRoundRect},
-    {"native_drawPath","(III)V", (void*) SkCanvasGlue::drawPath},
-    {"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[IIIFFIIZI)V",
-    (void*)SkCanvasGlue::drawBitmapArray},
-    
-    {"nativeDrawBitmapMatrix", "(IIII)V",
-        (void*)SkCanvasGlue::drawBitmapMatrix},
-    {"nativeDrawBitmapMesh", "(IIII[FI[III)V",
-        (void*)SkCanvasGlue::drawBitmapMesh},
-    {"nativeDrawVertices", "(III[FI[FI[II[SIII)V",
-        (void*)SkCanvasGlue::drawVertices},
-    {"native_drawText","(I[CIIFFI)V",
-        (void*) SkCanvasGlue::drawText___CIIFFPaint},
-    {"native_drawText","(ILjava/lang/String;IIFFI)V",
-        (void*) SkCanvasGlue::drawText__StringIIFFPaint},
-    {"drawText","(Ljava/lang/String;FFLandroid/graphics/Paint;)V",
-        (void*) SkCanvasGlue::drawString},
-    {"native_drawPosText","(I[CII[FI)V",
-        (void*) SkCanvasGlue::drawPosText___CII_FPaint},
-    {"native_drawPosText","(ILjava/lang/String;[FI)V",
-        (void*) SkCanvasGlue::drawPosText__String_FPaint},
-    {"native_drawTextOnPath","(I[CIIIFFI)V",
-        (void*) SkCanvasGlue::drawTextOnPath___CIIPathFFPaint},
-    {"native_drawTextOnPath","(ILjava/lang/String;IFFI)V",
-        (void*) SkCanvasGlue::drawTextOnPath__StringPathFFPaint},
-    {"native_drawPicture", "(II)V", (void*) SkCanvasGlue::drawPicture},
-
-    {"freeGlCaches", "()V", (void*) SkCanvasGlue::freeGlCaches}
-};
-
-#include <android_runtime/AndroidRuntime.h>
-
-#define REG(env, name, array) \
-    result = android::AndroidRuntime::registerNativeMethods(env, name, array, \
-                                                    SK_ARRAY_COUNT(array));  \
-    if (result < 0) return result
-
-int register_android_graphics_Canvas(JNIEnv* env) {
-    int result;
-
-    REG(env, "android/graphics/Canvas", gCanvasMethods);
-    
-    return result;
-}
-
-}
diff --git a/core/jni/android/graphics/ColorFilter.cpp b/core/jni/android/graphics/ColorFilter.cpp
deleted file mode 100644
index b6ec4a2..0000000
--- a/core/jni/android/graphics/ColorFilter.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-/* libs/android_runtime/android/graphics/ColorFilter.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
-**
-**     http://www.apache.org/licenses/LICENSE-2.0 
-**
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
-** limitations under the License.
-*/
-
-#include "jni.h"
-#include "GraphicsJNI.h"
-#include <android_runtime/AndroidRuntime.h>
-
-#include "SkColorFilter.h"
-#include "SkColorMatrixFilter.h"
-
-namespace android {
-
-class SkColorFilterGlue {
-public:
-
-    static void finalizer(JNIEnv* env, jobject clazz, SkColorFilter* obj) {
-        obj->safeUnref();
-    }
-
-    static SkColorFilter* CreatePorterDuffFilter(JNIEnv* env, jobject,
-                            jint srcColor, SkPorterDuff::Mode porterDuffMode) {
-        return SkColorFilter::CreatePorterDuffFilter(srcColor, porterDuffMode);
-    }
- 
-    static SkColorFilter* CreateLightingFilter(JNIEnv* env, jobject,
-                                               jint mul, jint add) {
-        return SkColorFilter::CreateLightingFilter(mul, add);
-    }
-    
-    static SkColorFilter* CreateColorMatrixFilter(JNIEnv* env, jobject,
-                                                  jfloatArray jarray) {
-        AutoJavaFloatArray autoArray(env, jarray, 20);
-        const float* src = autoArray.ptr();
-
-#ifdef SK_SCALAR_IS_FIXED
-        SkFixed array[20];
-        for (int i = 0; i < 20; i++) {
-            array[i] = SkFloatToScalar(src[i]);
-        }
-        return new SkColorMatrixFilter(array);
-#else
-        return new SkColorMatrixFilter(src);
-#endif
-    }
- 
-};
-
-static JNINativeMethod colorfilter_methods[] = {
-    {"finalizer", "(I)V", (void*) SkColorFilterGlue::finalizer}
-};
-
-static JNINativeMethod porterduff_methods[] = {
-    {"native_CreatePorterDuffFilter","(II)I",
-        (void*) SkColorFilterGlue::CreatePorterDuffFilter}
-};
-
-static JNINativeMethod lighting_methods[] = {
-    {"native_CreateLightingFilter","(II)I",
-        (void*) SkColorFilterGlue::CreateLightingFilter}
-};
-
-static JNINativeMethod colormatrix_methods[] = {
-    {"nativeColorMatrixFilter","([F)I",
-        (void*) SkColorFilterGlue::CreateColorMatrixFilter}
-};
-
-#define REG(env, name, array) \
-    result = android::AndroidRuntime::registerNativeMethods(env, name, array, \
-                                                    SK_ARRAY_COUNT(array));  \
-    if (result < 0) return result
-
-
-int register_android_graphics_ColorFilter(JNIEnv* env) {
-    int result;
-    
-    REG(env, "android/graphics/ColorFilter", colorfilter_methods);
-    REG(env, "android/graphics/PorterDuffColorFilter", porterduff_methods);
-    REG(env, "android/graphics/LightingColorFilter", lighting_methods);
-    REG(env, "android/graphics/ColorMatrixColorFilter", colormatrix_methods);
-    
-    return 0;
-}
-
-}
diff --git a/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.cpp b/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.cpp
deleted file mode 100644
index a285def..0000000
--- a/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.cpp
+++ /dev/null
@@ -1,251 +0,0 @@
-#include "CreateJavaOutputStreamAdaptor.h"
-
-#define RETURN_NULL_IF_NULL(value) \
-    do { if (!(value)) { SkASSERT(0); return NULL; } } while (false)
-
-static jclass       gInputStream_Clazz;
-static jmethodID    gInputStream_resetMethodID;
-static jmethodID    gInputStream_availableMethodID;
-static jmethodID    gInputStream_readMethodID;
-static jmethodID    gInputStream_skipMethodID;
-
-class JavaInputStreamAdaptor : public SkStream {
-public:
-    JavaInputStreamAdaptor(JNIEnv* env, jobject js, jbyteArray ar)
-        : fEnv(env), fJavaInputStream(js), fJavaByteArray(ar) {
-        SkASSERT(ar);
-        fCapacity   = env->GetArrayLength(ar);
-        SkASSERT(fCapacity > 0);
-        fBytesRead  = 0;
-    }
-    
-	virtual bool rewind() {
-        JNIEnv* env = fEnv;
-        
-        fBytesRead = 0;
-
-        env->CallVoidMethod(fJavaInputStream, gInputStream_resetMethodID);
-        if (env->ExceptionCheck()) {
-            env->ExceptionDescribe();
-            env->ExceptionClear();
-            SkDebugf("------- reset threw an exception\n");
-            return false;
-        }
-        return true;
-    }
-    
-    size_t doRead(void* buffer, size_t size) {
-        JNIEnv* env = fEnv;
-        size_t bytesRead = 0;
-        // read the bytes
-        do {
-            size_t requested = size;
-            if (requested > fCapacity)
-                requested = fCapacity;
-            
-            jint n = env->CallIntMethod(fJavaInputStream,
-                                        gInputStream_readMethodID, fJavaByteArray, 0, requested);
-            if (env->ExceptionCheck()) {
-                env->ExceptionDescribe();
-                env->ExceptionClear();
-                SkDebugf("---- read threw an exception\n");
-                return 0;
-            }
-            
-            if (n <= 0) {
-                break;  // eof
-            }
-            
-            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;
-            size -= n;
-            fBytesRead += n;
-        } while (size != 0);
-        
-        return bytesRead;
-    }
-    
-    size_t doSkip(size_t size) {
-        JNIEnv* env = fEnv;
-        jlong skipped = env->CallLongMethod(fJavaInputStream,
-                                            gInputStream_skipMethodID, (jlong)size);
-        if (env->ExceptionCheck()) {
-            env->ExceptionDescribe();
-            env->ExceptionClear();
-            SkDebugf("------- available threw an exception\n");
-            return 0;
-        }
-        if (skipped < 0) {
-            skipped = 0;
-        }
-        return (size_t)skipped;
-    }
-    
-    size_t doSize() {
-        JNIEnv* env = fEnv;
-        jint avail = env->CallIntMethod(fJavaInputStream,
-                                        gInputStream_availableMethodID);
-        if (env->ExceptionCheck()) {
-            env->ExceptionDescribe();
-            env->ExceptionClear();
-            SkDebugf("------- available threw an exception\n");
-            avail = 0;
-        }
-        return avail;
-    }
-    
-	virtual size_t read(void* buffer, size_t size) {
-        JNIEnv* env = fEnv;
-        if (NULL == buffer) {
-            if (0 == size) {
-                return this->doSize();
-            } else {
-                /*  InputStream.skip(n) can return <=0 but still not be at EOF
-                    If we see that value, we need to call read(), which will
-                    block if waiting for more data, or return -1 at EOF
-                 */
-                size_t amountSkipped = 0;
-                do {
-                    size_t amount = this->doSkip(size);
-                    if (0 == amount) {
-                        char tmp;
-                        amount = this->doRead(&tmp, 1);
-                        if (0 == amount) {
-                            // if read returned 0, we're at EOF
-                            break;
-                        }
-                    }
-                    amountSkipped += amount;
-                } while (amountSkipped < size);
-                return amountSkipped;
-            }
-        }
-        return this->doRead(buffer, size);
-    }
-    
-private:
-    JNIEnv*     fEnv;
-    jobject     fJavaInputStream;   // the caller owns this object
-    jbyteArray  fJavaByteArray;     // the caller owns this object
-    size_t      fCapacity;
-    size_t      fBytesRead;
-};
-
-SkStream* CreateJavaInputStreamAdaptor(JNIEnv* env, jobject stream,
-                                       jbyteArray storage) {
-    static bool gInited;
-
-    if (!gInited) {
-        gInputStream_Clazz = env->FindClass("java/io/InputStream");
-        RETURN_NULL_IF_NULL(gInputStream_Clazz);
-        gInputStream_Clazz = (jclass)env->NewGlobalRef(gInputStream_Clazz);
-
-        gInputStream_resetMethodID      = env->GetMethodID(gInputStream_Clazz,
-                                                           "reset", "()V");
-        gInputStream_availableMethodID  = env->GetMethodID(gInputStream_Clazz,
-                                                           "available", "()I");
-        gInputStream_readMethodID       = env->GetMethodID(gInputStream_Clazz,
-                                                           "read", "([BII)I");
-        gInputStream_skipMethodID       = env->GetMethodID(gInputStream_Clazz,
-                                                           "skip", "(J)J");
-
-        RETURN_NULL_IF_NULL(gInputStream_resetMethodID);
-        RETURN_NULL_IF_NULL(gInputStream_availableMethodID);
-        RETURN_NULL_IF_NULL(gInputStream_availableMethodID);
-        RETURN_NULL_IF_NULL(gInputStream_skipMethodID);
-
-        gInited = true;
-    }
-
-    return new JavaInputStreamAdaptor(env, stream, storage);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-static jclass       gOutputStream_Clazz;
-static jmethodID    gOutputStream_writeMethodID;
-static jmethodID    gOutputStream_flushMethodID;
-
-class SkJavaOutputStream : public SkWStream {
-public:
-    SkJavaOutputStream(JNIEnv* env, jobject stream, jbyteArray storage)
-        : fEnv(env), fJavaOutputStream(stream), fJavaByteArray(storage) {
-        fCapacity = env->GetArrayLength(storage);
-    }
-    
-	virtual bool write(const void* buffer, size_t size) {
-        JNIEnv* env = fEnv;
-        jbyteArray storage = fJavaByteArray;
-        
-        while (size > 0) {
-            size_t requested = size;
-            if (requested > fCapacity) {
-                requested = fCapacity;
-            }
-
-            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()) {
-                env->ExceptionDescribe();
-                env->ExceptionClear();
-                SkDebugf("------- write threw an exception\n");
-                return false;
-            }
-            
-            buffer = (void*)((char*)buffer + requested);
-            size -= requested;
-        }
-        return true;
-    }
-    
-    virtual void flush() {
-        fEnv->CallVoidMethod(fJavaOutputStream, gOutputStream_flushMethodID);
-    }
-    
-private:
-    JNIEnv*     fEnv;
-    jobject     fJavaOutputStream;  // the caller owns this object
-    jbyteArray  fJavaByteArray;     // the caller owns this object
-    size_t      fCapacity;
-};
-
-SkWStream* CreateJavaOutputStreamAdaptor(JNIEnv* env, jobject stream,
-                                         jbyteArray storage) {
-    static bool gInited;
-
-    if (!gInited) {
-        gOutputStream_Clazz = env->FindClass("java/io/OutputStream");
-        RETURN_NULL_IF_NULL(gOutputStream_Clazz);
-        gOutputStream_Clazz = (jclass)env->NewGlobalRef(gOutputStream_Clazz);
-
-        gOutputStream_writeMethodID = env->GetMethodID(gOutputStream_Clazz,
-                                                       "write", "([BII)V");
-        RETURN_NULL_IF_NULL(gOutputStream_writeMethodID);
-        gOutputStream_flushMethodID = env->GetMethodID(gOutputStream_Clazz,
-                                                       "flush", "()V");
-        RETURN_NULL_IF_NULL(gOutputStream_flushMethodID);
-
-        gInited = true;
-    }
-
-    return new SkJavaOutputStream(env, stream, storage);
-}
-
diff --git a/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.h b/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.h
deleted file mode 100644
index cf21dde..0000000
--- a/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef CreateJavaOutputStream_DEFINED
-#define CreateJavaOutputStream_DEFINED
-
-//#include <android_runtime/AndroidRuntime.h>
-#include "jni.h"
-#include "SkStream.h"
-
-SkStream* CreateJavaInputStreamAdaptor(JNIEnv* env, jobject stream,
-                                       jbyteArray storage);
-SkWStream* CreateJavaOutputStreamAdaptor(JNIEnv* env, jobject stream,
-                                         jbyteArray storage);
-
-#endif
diff --git a/core/jni/android/graphics/DrawFilter.cpp b/core/jni/android/graphics/DrawFilter.cpp
deleted file mode 100644
index 496e712..0000000
--- a/core/jni/android/graphics/DrawFilter.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-/* libs/android_runtime/android/graphics/ColorFilter.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
-**
-**     http://www.apache.org/licenses/LICENSE-2.0 
-**
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
-** limitations under the License.
-*/
-
-// This file was generated from the C++ include file: SkColorFilter.h
-// Any changes made to this file will be discarded by the build.
-// To change this file, either edit the include, or device/tools/gluemaker/main.cpp, 
-// or one of the auxilary file specifications in device/tools/gluemaker.
-
-#include "jni.h"
-#include "GraphicsJNI.h"
-#include <android_runtime/AndroidRuntime.h>
-
-#include "SkDrawFilter.h"
-#include "SkPaintFlagsDrawFilter.h"
-#include "SkPaint.h"
-
-namespace android {
-
-class SkDrawFilterGlue {
-public:
-
-    static void finalizer(JNIEnv* env, jobject clazz, SkDrawFilter* obj) {
-        obj->safeUnref();
-    }
-
-    static SkDrawFilter* CreatePaintFlagsDF(JNIEnv* env, jobject clazz,
-                                           int clearFlags, int setFlags) {
-        // trim off any out-of-range bits
-        clearFlags &= SkPaint::kAllFlags;
-        setFlags &= SkPaint::kAllFlags;
-
-        if (clearFlags | setFlags) {
-            return new SkPaintFlagsDrawFilter(clearFlags, setFlags);
-        } else {
-            return NULL;
-        }
-    }
-};
-
-static JNINativeMethod drawfilter_methods[] = {
-    {"nativeDestructor", "(I)V", (void*) SkDrawFilterGlue::finalizer}
-};
-
-static JNINativeMethod paintflags_methods[] = {
-    {"nativeConstructor","(II)I", (void*) SkDrawFilterGlue::CreatePaintFlagsDF}
-};
-
-#define REG(env, name, array)                                                                       \
-    result = android::AndroidRuntime::registerNativeMethods(env, name, array, SK_ARRAY_COUNT(array));  \
-    if (result < 0) return result
-
-
-int register_android_graphics_DrawFilter(JNIEnv* env) {
-    int result;
-    
-    REG(env, "android/graphics/DrawFilter", drawfilter_methods);
-    REG(env, "android/graphics/PaintFlagsDrawFilter", paintflags_methods);
-    
-    return 0;
-}
-
-}
diff --git a/core/jni/android/graphics/Graphics.cpp b/core/jni/android/graphics/Graphics.cpp
deleted file mode 100644
index 6eebbdc..0000000
--- a/core/jni/android/graphics/Graphics.cpp
+++ /dev/null
@@ -1,587 +0,0 @@
-#include "jni.h"
-#include "GraphicsJNI.h"
-#include "NIOBuffer.h"
-#include "SkPicture.h"
-#include "SkRegion.h"
-#include <android_runtime/AndroidRuntime.h>
-
-//#define TRACK_LOCK_COUNT
-
-void doThrow(JNIEnv* env, const char* exc, const char* msg) {
-    // don't throw a new exception if we already have one pending
-    if (env->ExceptionCheck() == JNI_FALSE) {
-        jclass npeClazz;
-        
-        npeClazz = env->FindClass(exc);
-        LOG_FATAL_IF(npeClazz == NULL, "Unable to find class %s", exc);
-        
-        env->ThrowNew(npeClazz, msg);
-    }
-}
-
-void doThrowNPE(JNIEnv* env) {
-    doThrow(env, "java/lang/NullPointerException");
-}
-
-void doThrowAIOOBE(JNIEnv* env) {
-    doThrow(env, "java/lang/ArrayIndexOutOfBoundsException");
-}
-
-void doThrowRE(JNIEnv* env, const char* msg) {
-    doThrow(env, "java/lang/RuntimeException", msg);
-}
-
-void doThrowIAE(JNIEnv* env, const char* msg) {
-    doThrow(env, "java/lang/IllegalArgumentException", msg);
-}
-
-void doThrowISE(JNIEnv* env, const char* msg) {
-    doThrow(env, "java/lang/IllegalStateException", msg);
-}
-
-void doThrowOOME(JNIEnv* env, const char* msg) {
-    doThrow(env, "java/lang/OutOfMemoryError", msg);
-}
-
-bool GraphicsJNI::hasException(JNIEnv *env) {
-    if (env->ExceptionCheck() != 0) {
-        LOGE("*** Uncaught exception returned from Java call!\n");
-        env->ExceptionDescribe();
-        return true;
-    }
-    return false;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-AutoJavaFloatArray::AutoJavaFloatArray(JNIEnv* env, jfloatArray array,
-                                       int minLength)
-: fEnv(env), fArray(array), fPtr(NULL), fLen(0) {
-    SkASSERT(env);
-    if (array) {
-        fLen = env->GetArrayLength(array);
-        if (fLen < minLength) {
-            sk_throw();
-        }
-        fPtr = env->GetFloatArrayElements(array, NULL);
-    }
-}
-
-AutoJavaFloatArray::~AutoJavaFloatArray() {
-    if (fPtr) {
-        fEnv->ReleaseFloatArrayElements(fArray, fPtr, 0);
-    }
-}
-
-AutoJavaIntArray::AutoJavaIntArray(JNIEnv* env, jintArray array,
-                                       int minLength)
-: fEnv(env), fArray(array), fPtr(NULL), fLen(0) {
-    SkASSERT(env);
-    if (array) {
-        fLen = env->GetArrayLength(array);
-        if (fLen < minLength) {
-            sk_throw();
-        }
-        fPtr = env->GetIntArrayElements(array, NULL);
-    }
-}
-
-AutoJavaIntArray::~AutoJavaIntArray() {
-    if (fPtr) {
-        fEnv->ReleaseIntArrayElements(fArray, fPtr, 0);
-    }
-}
-
-AutoJavaShortArray::AutoJavaShortArray(JNIEnv* env, jshortArray array,
-                                       int minLength)
-: fEnv(env), fArray(array), fPtr(NULL), fLen(0) {
-    SkASSERT(env);
-    if (array) {
-        fLen = env->GetArrayLength(array);
-        if (fLen < minLength) {
-            sk_throw();
-        }
-        fPtr = env->GetShortArrayElements(array, NULL);
-    }
-}
-
-AutoJavaShortArray::~AutoJavaShortArray() {
-    if (fPtr) {
-        fEnv->ReleaseShortArrayElements(fArray, fPtr, 0);
-    }
-}
-
-AutoJavaByteArray::AutoJavaByteArray(JNIEnv* env, jbyteArray array,
-                                       int minLength)
-: fEnv(env), fArray(array), fPtr(NULL), fLen(0) {
-    SkASSERT(env);
-    if (array) {
-        fLen = env->GetArrayLength(array);
-        if (fLen < minLength) {
-            sk_throw();
-        }
-        fPtr = env->GetByteArrayElements(array, NULL);
-    }
-}
-
-AutoJavaByteArray::~AutoJavaByteArray() {
-    if (fPtr) {
-        fEnv->ReleaseByteArrayElements(fArray, fPtr, 0);
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-static jclass   gRect_class;
-static jfieldID gRect_leftFieldID;
-static jfieldID gRect_topFieldID;
-static jfieldID gRect_rightFieldID;
-static jfieldID gRect_bottomFieldID;
-
-static jclass   gRectF_class;
-static jfieldID gRectF_leftFieldID;
-static jfieldID gRectF_topFieldID;
-static jfieldID gRectF_rightFieldID;
-static jfieldID gRectF_bottomFieldID;
-
-static jclass   gPoint_class;
-static jfieldID gPoint_xFieldID;
-static jfieldID gPoint_yFieldID;
-
-static jclass   gPointF_class;
-static jfieldID gPointF_xFieldID;
-static jfieldID gPointF_yFieldID;
-
-static jclass   gBitmap_class;
-static jfieldID gBitmap_nativeInstanceID;
-static jmethodID gBitmap_constructorMethodID;
-static jmethodID gBitmap_allocBufferMethodID;
-
-static jclass   gBitmapConfig_class;
-static jfieldID gBitmapConfig_nativeInstanceID;
-
-static jclass   gCanvas_class;
-static jfieldID gCanvas_nativeInstanceID;
-static jfieldID gCanvas_densityScaleID;
-
-static jclass   gPaint_class;
-static jfieldID gPaint_nativeInstanceID;
-
-static jclass   gPicture_class;
-static jfieldID gPicture_nativeInstanceID;
-
-static jclass   gRegion_class;
-static jfieldID gRegion_nativeInstanceID;
-static jmethodID gRegion_constructorMethodID;
-
-static jobject   gVMRuntime_singleton;
-static jmethodID gVMRuntime_trackExternalAllocationMethodID;
-static jmethodID gVMRuntime_trackExternalFreeMethodID;
-
-///////////////////////////////////////////////////////////////////////////////
-
-void GraphicsJNI::get_jrect(JNIEnv* env, jobject obj, int* L, int* T, int* R, int* B)
-{
-    SkASSERT(env->IsInstanceOf(obj, gRect_class));
-
-    *L = env->GetIntField(obj, gRect_leftFieldID);
-    *T = env->GetIntField(obj, gRect_topFieldID);
-    *R = env->GetIntField(obj, gRect_rightFieldID);
-    *B = env->GetIntField(obj, gRect_bottomFieldID);
-}
-
-void GraphicsJNI::set_jrect(JNIEnv* env, jobject obj, int L, int T, int R, int B)
-{
-    SkASSERT(env->IsInstanceOf(obj, gRect_class));
-
-    env->SetIntField(obj, gRect_leftFieldID, L);
-    env->SetIntField(obj, gRect_topFieldID, T);
-    env->SetIntField(obj, gRect_rightFieldID, R);
-    env->SetIntField(obj, gRect_bottomFieldID, B);
-}
-
-SkIRect* GraphicsJNI::jrect_to_irect(JNIEnv* env, jobject obj, SkIRect* ir)
-{
-    SkASSERT(env->IsInstanceOf(obj, gRect_class));
-
-    ir->set(env->GetIntField(obj, gRect_leftFieldID),
-            env->GetIntField(obj, gRect_topFieldID),
-            env->GetIntField(obj, gRect_rightFieldID),
-            env->GetIntField(obj, gRect_bottomFieldID));
-    return ir;
-}
-
-void GraphicsJNI::irect_to_jrect(const SkIRect& ir, JNIEnv* env, jobject obj)
-{
-    SkASSERT(env->IsInstanceOf(obj, gRect_class));
-
-    env->SetIntField(obj, gRect_leftFieldID, ir.fLeft);
-    env->SetIntField(obj, gRect_topFieldID, ir.fTop);
-    env->SetIntField(obj, gRect_rightFieldID, ir.fRight);
-    env->SetIntField(obj, gRect_bottomFieldID, ir.fBottom);
-}
-
-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)));
-    return r;
-}
-
-SkRect* GraphicsJNI::jrect_to_rect(JNIEnv* env, jobject obj, SkRect* r)
-{
-    SkASSERT(env->IsInstanceOf(obj, gRect_class));
-    
-    r->set(SkIntToScalar(env->GetIntField(obj, gRect_leftFieldID)),
-           SkIntToScalar(env->GetIntField(obj, gRect_topFieldID)),
-           SkIntToScalar(env->GetIntField(obj, gRect_rightFieldID)),
-           SkIntToScalar(env->GetIntField(obj, gRect_bottomFieldID)));
-    return r;
-}
-
-void GraphicsJNI::rect_to_jrectf(const SkRect& r, JNIEnv* env, jobject obj)
-{
-    SkASSERT(env->IsInstanceOf(obj, gRectF_class));
-
-    env->SetFloatField(obj, gRectF_leftFieldID, SkScalarToFloat(r.fLeft));
-    env->SetFloatField(obj, gRectF_topFieldID, SkScalarToFloat(r.fTop));
-    env->SetFloatField(obj, gRectF_rightFieldID, SkScalarToFloat(r.fRight));
-    env->SetFloatField(obj, gRectF_bottomFieldID, SkScalarToFloat(r.fBottom));
-}
-
-SkIPoint* GraphicsJNI::jpoint_to_ipoint(JNIEnv* env, jobject obj, SkIPoint* point)
-{
-    SkASSERT(env->IsInstanceOf(obj, gPoint_class));
-    
-    point->set(env->GetIntField(obj, gPoint_xFieldID),
-               env->GetIntField(obj, gPoint_yFieldID));
-    return point;
-}
-
-void GraphicsJNI::ipoint_to_jpoint(const SkIPoint& ir, JNIEnv* env, jobject obj)
-{
-    SkASSERT(env->IsInstanceOf(obj, gPoint_class));
-
-    env->SetIntField(obj, gPoint_xFieldID, ir.fX);
-    env->SetIntField(obj, gPoint_yFieldID, ir.fY);
-}
-
-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)));
-    return point;
-}
-
-void GraphicsJNI::point_to_jpointf(const SkPoint& r, JNIEnv* env, jobject obj)
-{
-    SkASSERT(env->IsInstanceOf(obj, gPointF_class));
-
-    env->SetFloatField(obj, gPointF_xFieldID, SkScalarToFloat(r.fX));
-    env->SetFloatField(obj, gPointF_yFieldID, SkScalarToFloat(r.fY));
-}
-
-SkBitmap* GraphicsJNI::getNativeBitmap(JNIEnv* env, jobject bitmap) {
-    SkASSERT(env);
-    SkASSERT(bitmap);
-    SkASSERT(env->IsInstanceOf(bitmap, gBitmap_class));
-    SkBitmap* b = (SkBitmap*)env->GetIntField(bitmap, gBitmap_nativeInstanceID);
-    SkASSERT(b);
-    return b;
-}
-
-SkBitmap::Config GraphicsJNI::getNativeBitmapConfig(JNIEnv* env,
-                                                    jobject jconfig) {
-    SkASSERT(env);
-    if (NULL == jconfig) {
-        return SkBitmap::kNo_Config;
-    }
-    SkASSERT(env->IsInstanceOf(jconfig, gBitmapConfig_class));
-    int c = env->GetIntField(jconfig, gBitmapConfig_nativeInstanceID);
-    if (c < 0 || c >= SkBitmap::kConfigCount) {
-        c = SkBitmap::kNo_Config;
-    }
-    return static_cast<SkBitmap::Config>(c);
-}
-
-SkCanvas* GraphicsJNI::getNativeCanvas(JNIEnv* env, jobject canvas) {
-    SkASSERT(env);
-    SkASSERT(canvas);
-    SkASSERT(env->IsInstanceOf(canvas, gCanvas_class));
-    SkCanvas* c = (SkCanvas*)env->GetIntField(canvas, gCanvas_nativeInstanceID);
-    SkASSERT(c);
-    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);
-    SkASSERT(env->IsInstanceOf(paint, gPaint_class));
-    SkPaint* p = (SkPaint*)env->GetIntField(paint, gPaint_nativeInstanceID);
-    SkASSERT(p);
-    return p;
-}
-
-SkPicture* GraphicsJNI::getNativePicture(JNIEnv* env, jobject picture)
-{
-    SkASSERT(env);
-    SkASSERT(picture);
-    SkASSERT(env->IsInstanceOf(picture, gPicture_class));
-    SkPicture* p = (SkPicture*)env->GetIntField(picture, gPicture_nativeInstanceID);
-    SkASSERT(p);
-    return p;
-}
-
-SkRegion* GraphicsJNI::getNativeRegion(JNIEnv* env, jobject region)
-{
-    SkASSERT(env);
-    SkASSERT(region);
-    SkASSERT(env->IsInstanceOf(region, gRegion_class));
-    SkRegion* r = (SkRegion*)env->GetIntField(region, gRegion_nativeInstanceID);
-    SkASSERT(r);
-    return r;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////
-
-jobject GraphicsJNI::createBitmap(JNIEnv* env, SkBitmap* bitmap, bool isMutable,
-                                  jbyteArray ninepatch)
-{
-    SkASSERT(bitmap != NULL);
-    SkASSERT(NULL != bitmap->pixelRef());
-    
-    jobject obj = env->AllocObject(gBitmap_class);
-    if (obj) {
-        env->CallVoidMethod(obj, gBitmap_constructorMethodID,
-                            (jint)bitmap, isMutable, ninepatch);
-        if (hasException(env)) {
-            obj = NULL;
-        }
-    }
-    return obj;
-}
-
-jobject GraphicsJNI::createRegion(JNIEnv* env, SkRegion* region)
-{
-    SkASSERT(region != NULL);
-    jobject obj = env->AllocObject(gRegion_class);
-    if (obj) {
-        env->CallVoidMethod(obj, gRegion_constructorMethodID, (jint)region, 0);
-        if (hasException(env)) {
-            obj = NULL;
-        }
-    }
-    return obj;
-}
-
-#include "SkPixelRef.h"
-
-static JNIEnv* vm2env(JavaVM* vm)
-{
-    JNIEnv* env = NULL;
-    if (vm->GetEnv((void**)&env, JNI_VERSION_1_4) != JNI_OK || NULL == env)
-    {
-        SkDebugf("------- [%p] vm->GetEnv() failed\n", vm);
-        sk_throw();
-    }
-    return env;
-}
-
-#ifdef TRACK_LOCK_COUNT
-    static int gLockCount;
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-
-#include "SkMallocPixelRef.h"
-
-/*  Extend SkMallocPixelRef to inform the VM when we free up the storage
-*/
-class AndroidPixelRef : public SkMallocPixelRef {
-public:
-    /** Allocate the specified buffer for pixels. The memory is freed when the
-        last owner of this pixelref is gone. Our caller has already informed
-        the VM of our allocation.
-    */
-    AndroidPixelRef(JNIEnv* env, void* storage, size_t size,
-            SkColorTable* ctable) : SkMallocPixelRef(storage, size, ctable) {
-        SkASSERT(storage);
-        SkASSERT(env);
-
-        if (env->GetJavaVM(&fVM) != JNI_OK) {
-            SkDebugf("------ [%p] env->GetJavaVM failed\n", env);
-            sk_throw();
-        }        
-    }
-
-    virtual ~AndroidPixelRef() {
-        JNIEnv* env = vm2env(fVM);
-//        SkDebugf("-------------- inform VM we're releasing %d bytes\n", this->getSize());
-        jlong jsize = this->getSize();  // the VM wants longs for the size
-        env->CallVoidMethod(gVMRuntime_singleton,
-                            gVMRuntime_trackExternalFreeMethodID,
-                            jsize);
-        if (GraphicsJNI::hasException(env)) {
-            env->ExceptionClear();
-        }
-    }
-
-private:
-    JavaVM* fVM;
-};
-
-bool GraphicsJNI::setJavaPixelRef(JNIEnv* env, SkBitmap* bitmap,
-                                  SkColorTable* ctable) {
-    Sk64 size64 = bitmap->getSize64();
-    if (size64.isNeg() || !size64.is32()) {
-        doThrow(env, "java/lang/IllegalArgumentException",
-                     "bitmap size exceeds 32bits");
-        return false;
-    }
-    
-    size_t size = size64.get32();
-    //    SkDebugf("-------------- inform VM we've allocated %d bytes\n", size);
-    jlong jsize = size;  // the VM wants longs for the size
-    bool r = env->CallBooleanMethod(gVMRuntime_singleton,
-                                     gVMRuntime_trackExternalAllocationMethodID,
-                                     jsize);
-    if (GraphicsJNI::hasException(env)) {
-        return false;
-    }
-    if (!r) {
-        LOGE("VM won't let us allocate %zd bytes\n", size);
-        doThrowOOME(env, "bitmap size exceeds VM budget");
-        return false;
-    }
-    
-    // call the version of malloc that returns null on failure
-    void* addr = sk_malloc_flags(size, 0);
-    if (NULL == addr) {
-        //        SkDebugf("-------------- inform VM we're releasing %d bytes which we couldn't allocate\n", size);
-        // we didn't actually allocate it, so inform the VM
-        env->CallVoidMethod(gVMRuntime_singleton,
-                             gVMRuntime_trackExternalFreeMethodID,
-                             jsize);
-        if (!GraphicsJNI::hasException(env)) {
-            doThrowOOME(env, "bitmap size too large for malloc");
-        }
-        return false;
-    }
-    
-    bitmap->setPixelRef(new AndroidPixelRef(env, addr, size, ctable))->unref();
-    // since we're already allocated, we lockPixels right away
-    // HeapAllocator behaves this way too
-    bitmap->lockPixels();
-    return true;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-JavaPixelAllocator::JavaPixelAllocator(JNIEnv* env) : fEnv(env)
-{
-}
-    
-bool JavaPixelAllocator::allocPixelRef(SkBitmap* bitmap, SkColorTable* ctable) {
-    return GraphicsJNI::setJavaPixelRef(fEnv, bitmap, ctable);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-static jclass make_globalref(JNIEnv* env, const char classname[])
-{
-    jclass c = env->FindClass(classname);
-    SkASSERT(c);
-    return (jclass)env->NewGlobalRef(c);
-}
-
-static jfieldID getFieldIDCheck(JNIEnv* env, jclass clazz,
-                                const char fieldname[], const char type[])
-{
-    jfieldID id = env->GetFieldID(clazz, fieldname, type);
-    SkASSERT(id);
-    return id;
-}
-
-int register_android_graphics_Graphics(JNIEnv* env)
-{
-    jmethodID m;
-    jclass c;
-
-    gRect_class = make_globalref(env, "android/graphics/Rect");
-    gRect_leftFieldID = getFieldIDCheck(env, gRect_class, "left", "I");
-    gRect_topFieldID = getFieldIDCheck(env, gRect_class, "top", "I");
-    gRect_rightFieldID = getFieldIDCheck(env, gRect_class, "right", "I");
-    gRect_bottomFieldID = getFieldIDCheck(env, gRect_class, "bottom", "I");
-
-    gRectF_class = make_globalref(env, "android/graphics/RectF");
-    gRectF_leftFieldID = getFieldIDCheck(env, gRectF_class, "left", "F");
-    gRectF_topFieldID = getFieldIDCheck(env, gRectF_class, "top", "F");
-    gRectF_rightFieldID = getFieldIDCheck(env, gRectF_class, "right", "F");
-    gRectF_bottomFieldID = getFieldIDCheck(env, gRectF_class, "bottom", "F");
-
-    gPoint_class = make_globalref(env, "android/graphics/Point");
-    gPoint_xFieldID = getFieldIDCheck(env, gPoint_class, "x", "I");
-    gPoint_yFieldID = getFieldIDCheck(env, gPoint_class, "y", "I");
-
-    gPointF_class = make_globalref(env, "android/graphics/PointF");
-    gPointF_xFieldID = getFieldIDCheck(env, gPointF_class, "x", "F");
-    gPointF_yFieldID = getFieldIDCheck(env, gPointF_class, "y", "F");
-
-    gBitmap_class = make_globalref(env, "android/graphics/Bitmap");
-    gBitmap_nativeInstanceID = getFieldIDCheck(env, gBitmap_class, "mNativeBitmap", "I");    
-    gBitmap_constructorMethodID = env->GetMethodID(gBitmap_class, "<init>",
-                                            "(IZ[B)V");
-
-    gBitmapConfig_class = make_globalref(env, "android/graphics/Bitmap$Config");
-    gBitmapConfig_nativeInstanceID = getFieldIDCheck(env, gBitmapConfig_class,
-                                                     "nativeInt", "I");    
-
-    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");
-    
-    gPicture_class = make_globalref(env, "android/graphics/Picture");
-    gPicture_nativeInstanceID = getFieldIDCheck(env, gPicture_class, "mNativePicture", "I");
-
-    gRegion_class = make_globalref(env, "android/graphics/Region");
-    gRegion_nativeInstanceID = getFieldIDCheck(env, gRegion_class, "mNativeRegion", "I");
-    gRegion_constructorMethodID = env->GetMethodID(gRegion_class, "<init>",
-        "(II)V");
-    
-    // Get the VMRuntime class.
-    c = env->FindClass("dalvik/system/VMRuntime");
-    SkASSERT(c);
-    // Look up VMRuntime.getRuntime().
-    m = env->GetStaticMethodID(c, "getRuntime", "()Ldalvik/system/VMRuntime;");
-    SkASSERT(m);
-    // Call VMRuntime.getRuntime() and hold onto its result.
-    gVMRuntime_singleton = env->CallStaticObjectMethod(c, m);
-    SkASSERT(gVMRuntime_singleton);
-    gVMRuntime_singleton = (jobject)env->NewGlobalRef(gVMRuntime_singleton);
-    // Look up the VMRuntime methods we'll be using.
-    gVMRuntime_trackExternalAllocationMethodID =
-                        env->GetMethodID(c, "trackExternalAllocation", "(J)Z");
-    gVMRuntime_trackExternalFreeMethodID =
-                            env->GetMethodID(c, "trackExternalFree", "(J)V");
-
-    NIOBuffer::RegisterJNI(env);
-
-    return 0;
-}
-
diff --git a/core/jni/android/graphics/GraphicsJNI.h b/core/jni/android/graphics/GraphicsJNI.h
deleted file mode 100644
index e2dc9ac..0000000
--- a/core/jni/android/graphics/GraphicsJNI.h
+++ /dev/null
@@ -1,157 +0,0 @@
-#ifndef GraphicsJNI_DEFINED
-#define GraphicsJNI_DEFINED
-
-#include "SkPoint.h"
-#include "SkRect.h"
-#include "SkBitmap.h"
-#include <jni.h>
-
-class SkCanvas;
-class SkPaint;
-class SkPicture;
-
-class GraphicsJNI {
-public:
-    // returns true if an exception is set (and dumps it out to the Log)
-    static bool hasException(JNIEnv*);
-
-    static void get_jrect(JNIEnv*, jobject jrect, int* L, int* T, int* R, int* B);
-    static void set_jrect(JNIEnv*, jobject jrect, int L, int T, int R, int B);
-
-    static SkIRect* jrect_to_irect(JNIEnv*, jobject jrect, SkIRect*);
-    static void irect_to_jrect(const SkIRect&, JNIEnv*, jobject jrect);
-
-    static SkRect* jrectf_to_rect(JNIEnv*, jobject jrectf, SkRect*);
-    static SkRect* jrect_to_rect(JNIEnv*, jobject jrect, SkRect*);
-    static void rect_to_jrectf(const SkRect&, JNIEnv*, jobject jrectf);
-    
-    static void set_jpoint(JNIEnv*, jobject jrect, int x, int y);
-    
-    static SkIPoint* jpoint_to_ipoint(JNIEnv*, jobject jpoint, SkIPoint* point);
-    static void ipoint_to_jpoint(const SkIPoint& point, JNIEnv*, jobject jpoint);
-    
-    static SkPoint* jpointf_to_point(JNIEnv*, jobject jpointf, SkPoint* point);
-    static void point_to_jpointf(const SkPoint& point, JNIEnv*, jobject jpointf);
-  
-    static SkCanvas* getNativeCanvas(JNIEnv*, jobject canvas);
-    static SkPaint*  getNativePaint(JNIEnv*, jobject paint);
-    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.
-    */
-    static SkBitmap::Config getNativeBitmapConfig(JNIEnv*, jobject jconfig);
-    
-    /** Create a java Bitmap object given the native bitmap (required) and optional
-        storage array (may be null). If storage is specified, then it must already be
-        locked, and its native address set as the bitmap's pixels. If storage is null,
-        then the bitmap must be an owner of its natively allocated pixels (via allocPixels).
-        */
-    static jobject createBitmap(JNIEnv* env, SkBitmap* bitmap, bool isMutable,
-                                jbyteArray ninePatch);
-    
-    static jobject createRegion(JNIEnv* env, SkRegion* region);
-
-    /** Set a pixelref for the bitmap (needs setConfig to already be called)
-        Returns true on success. If it returns false, then it failed, and the
-        appropriate exception will have been raised.
-    */
-    static bool setJavaPixelRef(JNIEnv*, SkBitmap*, SkColorTable* ctable);
-
-    /** Copy the colors in colors[] to the bitmap, convert to the correct
-        format along the way.
-    */
-    static bool SetPixels(JNIEnv* env, jintArray colors, int srcOffset,
-                          int srcStride, int x, int y, int width, int height,
-                          const SkBitmap& dstBitmap);
-};
-
-class JavaPixelAllocator : public SkBitmap::Allocator {
-public:
-    JavaPixelAllocator(JNIEnv* env);
-    // overrides
-    virtual bool allocPixelRef(SkBitmap* bitmap, SkColorTable* ctable);
-    
-private:
-    JNIEnv* fEnv;
-};
-
-class AutoJavaFloatArray {
-public:
-    AutoJavaFloatArray(JNIEnv* env, jfloatArray array, int minLength = 0);
-    ~AutoJavaFloatArray();
-    
-    float* ptr() const { return fPtr; }
-    int    length() const { return fLen; }
-    
-private:
-    JNIEnv*     fEnv;
-    jfloatArray fArray;
-    float*      fPtr;
-    int         fLen;
-};
-
-class AutoJavaIntArray {
-public:
-    AutoJavaIntArray(JNIEnv* env, jintArray array, int minLength = 0);
-    ~AutoJavaIntArray();
-    
-    jint* ptr() const { return fPtr; }
-    int    length() const { return fLen; }
-    
-private:
-    JNIEnv*     fEnv;
-    jintArray fArray;
-    jint*      fPtr;
-    int         fLen;
-};
-
-class AutoJavaShortArray {
-public:
-    AutoJavaShortArray(JNIEnv* env, jshortArray array, int minLength = 0);
-    ~AutoJavaShortArray();
-    
-    jshort* ptr() const { return fPtr; }
-    int    length() const { return fLen; }
-    
-private:
-    JNIEnv*     fEnv;
-    jshortArray fArray;
-    jshort*      fPtr;
-    int         fLen;
-};
-
-class AutoJavaByteArray {
-public:
-    AutoJavaByteArray(JNIEnv* env, jbyteArray array, int minLength = 0);
-    ~AutoJavaByteArray();
-    
-    jbyte* ptr() const { return fPtr; }
-    int    length() const { return fLen; }
-    
-private:
-    JNIEnv*     fEnv;
-    jbyteArray fArray;
-    jbyte*      fPtr;
-    int         fLen;
-};
-
-void doThrow(JNIEnv* env, const char* exc, const char* msg = NULL);
-void doThrowNPE(JNIEnv* env);
-void doThrowAIOOBE(JNIEnv* env); // Array Index Out Of Bounds Exception
-void doThrowIAE(JNIEnv* env, const char* msg = NULL);   // Illegal Argument
-void doThrowRE(JNIEnv* env, const char* msg = NULL);   // Runtime
-void doThrowISE(JNIEnv* env, const char* msg = NULL);   // Illegal State
-void doThrowOOME(JNIEnv* env, const char* msg = NULL);   // Out of memory
-
-#define NPE_CHECK_RETURN_ZERO(env, object)    \
-    do { if (NULL == (object)) { doThrowNPE(env); return 0; } } while (0)
-
-#define NPE_CHECK_RETURN_VOID(env, object)    \
-    do { if (NULL == (object)) { doThrowNPE(env); return; } } while (0)
-
-#endif
-
diff --git a/core/jni/android/graphics/Interpolator.cpp b/core/jni/android/graphics/Interpolator.cpp
deleted file mode 100644
index beec351..0000000
--- a/core/jni/android/graphics/Interpolator.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-#include "jni.h"
-#include <android_runtime/AndroidRuntime.h>
-
-#include "GraphicsJNI.h"
-#include "SkInterpolator.h"
-#include "SkTemplates.h"
-
-static SkInterpolator* Interpolator_constructor(JNIEnv* env, jobject clazz, int valueCount, int frameCount)
-{
-    return new SkInterpolator(valueCount, frameCount);
-}
-
-static void Interpolator_destructor(JNIEnv* env, jobject clazz, SkInterpolator* interp)
-{
-    delete interp;
-}
-
-static void Interpolator_reset(JNIEnv* env, jobject clazz, SkInterpolator* interp, int valueCount, int frameCount)
-{
-    interp->reset(valueCount, frameCount);
-}
-
-static void Interpolator_setKeyFrame(JNIEnv* env, jobject clazz, SkInterpolator* interp, int index, int msec, jfloatArray valueArray, jfloatArray blendArray)
-{
-    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;
-    }
-
-    interp->setKeyFrame(index, msec, scalars, blend);
-}
-
-static void Interpolator_setRepeatMirror(JNIEnv* env, jobject clazz, SkInterpolator* interp, float repeatCount, jboolean mirror)
-{
-    if (repeatCount > 32000)
-        repeatCount = 32000;
-
-    interp->setRepeatCount(SkFloatToScalar(repeatCount));
-    interp->setMirror(mirror != 0);
-}
-
-static int Interpolator_timeToValues(JNIEnv* env, jobject clazz, SkInterpolator* interp, int msec, jfloatArray valueArray)
-{
-    SkInterpolatorBase::Result result;
-
-    float* values = valueArray ? env->GetFloatArrayElements(valueArray, NULL) : NULL;
-    result = interp->timeToValues(msec, (SkScalar*)values);
-    
-    if (valueArray) {
-        int n = env->GetArrayLength(valueArray);
-        for (int i = 0; i < n; i++) {
-            values[i] = SkScalarToFloat(*(SkScalar*)&values[i]);
-        }
-        env->ReleaseFloatArrayElements(valueArray, values, 0);
-    }
-    
-    return result;
-}
-
-// ----------------------------------------------------------------------------
-
-/*
- * JNI registration.
- */
-static JNINativeMethod gInterpolatorMethods[] = {
-    { "nativeConstructor",      "(II)I",        (void*)Interpolator_constructor     },
-    { "nativeDestructor",       "(I)V",         (void*)Interpolator_destructor      },
-    { "nativeReset",            "(III)V",       (void*)Interpolator_reset           },
-    { "nativeSetKeyFrame",      "(III[F[F)V",   (void*)Interpolator_setKeyFrame     },
-    { "nativeSetRepeatMirror",  "(IFZ)V",       (void*)Interpolator_setRepeatMirror },
-    { "nativeTimeToValues",     "(II[F)I",      (void*)Interpolator_timeToValues    }
-};
-
-int register_android_graphics_Interpolator(JNIEnv* env);
-int register_android_graphics_Interpolator(JNIEnv* env)
-{
-    return android::AndroidRuntime::registerNativeMethods(env,
-                                                       "android/graphics/Interpolator",
-                                                       gInterpolatorMethods,
-                                                       SK_ARRAY_COUNT(gInterpolatorMethods));
-}
diff --git a/core/jni/android/graphics/LayerRasterizer.cpp b/core/jni/android/graphics/LayerRasterizer.cpp
deleted file mode 100644
index 7c45889..0000000
--- a/core/jni/android/graphics/LayerRasterizer.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "SkLayerRasterizer.h"
-#include <jni.h>
-
-class SkLayerRasterizerGlue {
-public:
-    static SkRasterizer* create(JNIEnv* env, jobject) {
-        return new SkLayerRasterizer();
-    }
-
-    static void addLayer(JNIEnv* env, jobject, SkLayerRasterizer* layer, const SkPaint* paint, float dx, float dy) {
-        SkASSERT(layer);
-        SkASSERT(paint);
-        layer->addLayer(*paint, SkFloatToScalar(dx), SkFloatToScalar(dy));
-    } 
-};
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-#include <android_runtime/AndroidRuntime.h>
-
-static JNINativeMethod gLayerRasterizerMethods[] = {
-    { "nativeConstructor",  "()I",      (void*)SkLayerRasterizerGlue::create    },
-    { "nativeAddLayer",     "(IIFF)V",  (void*)SkLayerRasterizerGlue::addLayer  }
-};
-
-int register_android_graphics_LayerRasterizer(JNIEnv* env);
-int register_android_graphics_LayerRasterizer(JNIEnv* env)
-{
-    return android::AndroidRuntime::registerNativeMethods(env,
-                                                       "android/graphics/LayerRasterizer",
-                                                       gLayerRasterizerMethods,
-                                                       SK_ARRAY_COUNT(gLayerRasterizerMethods));
-}
-
diff --git a/core/jni/android/graphics/MaskFilter.cpp b/core/jni/android/graphics/MaskFilter.cpp
deleted file mode 100644
index e6048cd..0000000
--- a/core/jni/android/graphics/MaskFilter.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-#include "GraphicsJNI.h"
-#include "SkMaskFilter.h"
-#include "SkBlurMaskFilter.h"
-
-#include <jni.h>
-
-class SkMaskFilterGlue {
-public:
-    static void destructor(JNIEnv* env, jobject, SkMaskFilter* filter) {
-        SkASSERT(filter);
-        filter->unref();
-    }
-
-    static SkMaskFilter* createBlur(JNIEnv* env, jobject, float radius, int blurStyle) {
-        return SkBlurMaskFilter::Create(SkFloatToScalar(radius), (SkBlurMaskFilter::BlurStyle)blurStyle);
-    }
- 
-    static SkMaskFilter* createEmboss(JNIEnv* env, jobject, jfloatArray dirArray, float ambient, float specular, float radius) {
-        SkScalar direction[3];
-
-        AutoJavaFloatArray autoDir(env, dirArray, 3);
-        float* values = autoDir.ptr();
-        for (int i = 0; i < 3; i++) {
-            direction[i] = SkFloatToScalar(values[i]);
-        }
-
-        return SkBlurMaskFilter::CreateEmboss(direction, SkFloatToScalar(ambient),
-                                              SkFloatToScalar(specular), SkFloatToScalar(radius));
-    }
-};
-
-static JNINativeMethod gMaskFilterMethods[] = {
-    { "nativeDestructor",   "(I)V",     (void*)SkMaskFilterGlue::destructor      }
-};
-
-static JNINativeMethod gBlurMaskFilterMethods[] = {
-    { "nativeConstructor",  "(FI)I",    (void*)SkMaskFilterGlue::createBlur      }
-};
-
-static JNINativeMethod gEmbossMaskFilterMethods[] = {
-    { "nativeConstructor",  "([FFFF)I", (void*)SkMaskFilterGlue::createEmboss    }
-};
-
-#include <android_runtime/AndroidRuntime.h>
-
-#define REG(env, name, array)                                                                       \
-    result = android::AndroidRuntime::registerNativeMethods(env, name, array, SK_ARRAY_COUNT(array));  \
-    if (result < 0) return result
-
-int register_android_graphics_MaskFilter(JNIEnv* env);
-int register_android_graphics_MaskFilter(JNIEnv* env)
-{
-    int result;
-    
-    REG(env, "android/graphics/MaskFilter", gMaskFilterMethods);
-    REG(env, "android/graphics/BlurMaskFilter", gBlurMaskFilterMethods);
-    REG(env, "android/graphics/EmbossMaskFilter", gEmbossMaskFilterMethods);
-    
-    return 0;
-}
-
diff --git a/core/jni/android/graphics/Matrix.cpp b/core/jni/android/graphics/Matrix.cpp
deleted file mode 100644
index b782766..0000000
--- a/core/jni/android/graphics/Matrix.cpp
+++ /dev/null
@@ -1,412 +0,0 @@
-/* libs/android_runtime/android/graphics/Matrix.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
-**
-**     http://www.apache.org/licenses/LICENSE-2.0 
-**
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
-** limitations under the License.
-*/
-
-// This file was generated from the C++ include file: SkMatrix.h
-// Any changes made to this file will be discarded by the build.
-// To change this file, either edit the include, or device/tools/gluemaker/main.cpp, 
-// or one of the auxilary file specifications in device/tools/gluemaker.
-
-#include "jni.h"
-#include "GraphicsJNI.h"
-#include <android_runtime/AndroidRuntime.h>
-
-#include "SkMatrix.h"
-#include "SkTemplates.h"
-
-namespace android {
-
-class SkMatrixGlue {
-public:
-
-    static void finalizer(JNIEnv* env, jobject clazz, SkMatrix* obj) {
-        delete obj;
-    }
-
-    static SkMatrix* create(JNIEnv* env, jobject clazz, const SkMatrix* src) {
-        SkMatrix* obj = new SkMatrix();
-        if (src)
-            *obj = *src;
-        else
-            obj->reset();
-        return obj;
-    }
- 
-    static jboolean isIdentity(JNIEnv* env, jobject clazz, SkMatrix* obj) {
-        return obj->isIdentity();
-    }
- 
-    static jboolean rectStaysRect(JNIEnv* env, jobject clazz, SkMatrix* obj) {
-        return obj->rectStaysRect();
-    }
- 
-    static void reset(JNIEnv* env, jobject clazz, SkMatrix* obj) {
-        obj->reset();
-    }
- 
-    static void set(JNIEnv* env, jobject clazz, SkMatrix* obj, SkMatrix* other) {
-        *obj = *other;
-    }
- 
-    static void setTranslate(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat dx, jfloat dy) {
-        SkScalar dx_ = SkFloatToScalar(dx);
-        SkScalar dy_ = SkFloatToScalar(dy);
-        obj->setTranslate(dx_, dy_);
-    }
- 
-    static void setScale__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy, jfloat px, jfloat py) {
-        SkScalar sx_ = SkFloatToScalar(sx);
-        SkScalar sy_ = SkFloatToScalar(sy);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        obj->setScale(sx_, sy_, px_, py_);
-    }
- 
-    static void setScale__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy) {
-        SkScalar sx_ = SkFloatToScalar(sx);
-        SkScalar sy_ = SkFloatToScalar(sy);
-        obj->setScale(sx_, sy_);
-    }
- 
-    static void setRotate__FFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees, jfloat px, jfloat py) {
-        SkScalar degrees_ = SkFloatToScalar(degrees);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        obj->setRotate(degrees_, px_, py_);
-    }
- 
-    static void setRotate__F(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees) {
-        SkScalar degrees_ = SkFloatToScalar(degrees);
-        obj->setRotate(degrees_);
-    }
- 
-    static void setSinCos__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sinValue, jfloat cosValue, jfloat px, jfloat py) {
-        SkScalar sinValue_ = SkFloatToScalar(sinValue);
-        SkScalar cosValue_ = SkFloatToScalar(cosValue);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        obj->setSinCos(sinValue_, cosValue_, px_, py_);
-    }
- 
-    static void setSinCos__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sinValue, jfloat cosValue) {
-        SkScalar sinValue_ = SkFloatToScalar(sinValue);
-        SkScalar cosValue_ = SkFloatToScalar(cosValue);
-        obj->setSinCos(sinValue_, cosValue_);
-    }
- 
-    static void setSkew__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky, jfloat px, jfloat py) {
-        SkScalar kx_ = SkFloatToScalar(kx);
-        SkScalar ky_ = SkFloatToScalar(ky);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        obj->setSkew(kx_, ky_, px_, py_);
-    }
- 
-    static void setSkew__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky) {
-        SkScalar kx_ = SkFloatToScalar(kx);
-        SkScalar ky_ = SkFloatToScalar(ky);
-        obj->setSkew(kx_, ky_);
-    }
- 
-    static jboolean setConcat(JNIEnv* env, jobject clazz, SkMatrix* obj, SkMatrix* a, SkMatrix* b) {
-        return obj->setConcat(*a, *b);
-    }
- 
-    static jboolean preTranslate(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat dx, jfloat dy) {
-        SkScalar dx_ = SkFloatToScalar(dx);
-        SkScalar dy_ = SkFloatToScalar(dy);
-        return obj->preTranslate(dx_, dy_);
-    }
- 
-    static jboolean preScale__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy, jfloat px, jfloat py) {
-        SkScalar sx_ = SkFloatToScalar(sx);
-        SkScalar sy_ = SkFloatToScalar(sy);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        return obj->preScale(sx_, sy_, px_, py_);
-    }
- 
-    static jboolean preScale__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy) {
-        SkScalar sx_ = SkFloatToScalar(sx);
-        SkScalar sy_ = SkFloatToScalar(sy);
-        return obj->preScale(sx_, sy_);
-    }
- 
-    static jboolean preRotate__FFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees, jfloat px, jfloat py) {
-        SkScalar degrees_ = SkFloatToScalar(degrees);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        return obj->preRotate(degrees_, px_, py_);
-    }
- 
-    static jboolean preRotate__F(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees) {
-        SkScalar degrees_ = SkFloatToScalar(degrees);
-        return obj->preRotate(degrees_);
-    }
- 
-    static jboolean preSkew__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky, jfloat px, jfloat py) {
-        SkScalar kx_ = SkFloatToScalar(kx);
-        SkScalar ky_ = SkFloatToScalar(ky);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        return obj->preSkew(kx_, ky_, px_, py_);
-    }
- 
-    static jboolean preSkew__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky) {
-        SkScalar kx_ = SkFloatToScalar(kx);
-        SkScalar ky_ = SkFloatToScalar(ky);
-        return obj->preSkew(kx_, ky_);
-    }
- 
-    static jboolean preConcat(JNIEnv* env, jobject clazz, SkMatrix* obj, SkMatrix* other) {
-        return obj->preConcat(*other);
-    }
- 
-    static jboolean postTranslate(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat dx, jfloat dy) {
-        SkScalar dx_ = SkFloatToScalar(dx);
-        SkScalar dy_ = SkFloatToScalar(dy);
-        return obj->postTranslate(dx_, dy_);
-    }
- 
-    static jboolean postScale__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy, jfloat px, jfloat py) {
-        SkScalar sx_ = SkFloatToScalar(sx);
-        SkScalar sy_ = SkFloatToScalar(sy);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        return obj->postScale(sx_, sy_, px_, py_);
-    }
- 
-    static jboolean postScale__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy) {
-        SkScalar sx_ = SkFloatToScalar(sx);
-        SkScalar sy_ = SkFloatToScalar(sy);
-        return obj->postScale(sx_, sy_);
-    }
- 
-    static jboolean postRotate__FFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees, jfloat px, jfloat py) {
-        SkScalar degrees_ = SkFloatToScalar(degrees);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        return obj->postRotate(degrees_, px_, py_);
-    }
- 
-    static jboolean postRotate__F(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees) {
-        SkScalar degrees_ = SkFloatToScalar(degrees);
-        return obj->postRotate(degrees_);
-    }
- 
-    static jboolean postSkew__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky, jfloat px, jfloat py) {
-        SkScalar kx_ = SkFloatToScalar(kx);
-        SkScalar ky_ = SkFloatToScalar(ky);
-        SkScalar px_ = SkFloatToScalar(px);
-        SkScalar py_ = SkFloatToScalar(py);
-        return obj->postSkew(kx_, ky_, px_, py_);
-    }
- 
-    static jboolean postSkew__FF(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloat kx, jfloat ky) {
-        SkScalar kx_ = SkFloatToScalar(kx);
-        SkScalar ky_ = SkFloatToScalar(ky);
-        return matrix->postSkew(kx_, ky_);
-    }
- 
-    static jboolean postConcat(JNIEnv* env, jobject clazz, SkMatrix* matrix, SkMatrix* other) {
-        return matrix->postConcat(*other);
-    }
- 
-    static jboolean setRectToRect(JNIEnv* env, jobject clazz, SkMatrix* matrix, jobject src, jobject dst, SkMatrix::ScaleToFit stf) {
-        SkRect src_;
-        GraphicsJNI::jrectf_to_rect(env, src, &src_);
-        SkRect dst_;
-        GraphicsJNI::jrectf_to_rect(env, dst, &dst_);
-        return matrix->setRectToRect(src_, dst_, stf);
-    }
- 
-    static jboolean setPolyToPoly(JNIEnv* env, jobject clazz, SkMatrix* matrix,
-                                  jfloatArray jsrc, int srcIndex,
-                                  jfloatArray jdst, int dstIndex, int ptCount) {
-        SkASSERT(srcIndex >= 0);
-        SkASSERT(dstIndex >= 0);
-        SkASSERT((unsigned)ptCount <= 4);
-
-        AutoJavaFloatArray autoSrc(env, jsrc, srcIndex + (ptCount << 1));
-        AutoJavaFloatArray autoDst(env, jdst, dstIndex + (ptCount << 1));
-        float* src = autoSrc.ptr() + srcIndex;
-        float* dst = autoDst.ptr() + dstIndex;
-
-#ifdef SK_SCALAR_IS_FIXED        
-        SkPoint srcPt[4], dstPt[4];
-        for (int i = 0; i < ptCount; i++) {
-            int x = i << 1;
-            int y = x + 1;
-            srcPt[i].set(SkFloatToScalar(src[x]), SkFloatToScalar(src[y]));
-            dstPt[i].set(SkFloatToScalar(dst[x]), SkFloatToScalar(dst[y]));
-        }
-        return matrix->setPolyToPoly(srcPt, dstPt, ptCount);
-#else
-        return matrix->setPolyToPoly((const SkPoint*)src, (const SkPoint*)dst,
-                                     ptCount);
-#endif
-    }
- 
-    static jboolean invert(JNIEnv* env, jobject clazz, SkMatrix* matrix, SkMatrix* inverse) {
-        return matrix->invert(inverse);
-    }
- 
-    static void mapPoints(JNIEnv* env, jobject clazz, SkMatrix* matrix,
-                              jfloatArray dst, int dstIndex,
-                              jfloatArray src, int srcIndex,
-                              int ptCount, bool isPts) {
-        SkASSERT(ptCount >= 0);
-        AutoJavaFloatArray autoSrc(env, src, srcIndex + (ptCount << 1));
-        AutoJavaFloatArray autoDst(env, dst, dstIndex + (ptCount << 1));
-        float* srcArray = autoSrc.ptr() + srcIndex;
-        float* dstArray = autoDst.ptr() + dstIndex;
-        
-#ifdef SK_SCALAR_IS_FIXED        
-        // we allocate twice the count, 1 set for src, 1 for dst
-        SkAutoSTMalloc<32, SkPoint> storage(ptCount * 2);
-        SkPoint* pts = storage.get();
-        SkPoint* srcPt = pts;
-        SkPoint* dstPt = pts + ptCount;
-        
-        int i;
-        for (i = 0; i < ptCount; i++) {
-            srcPt[i].set(SkFloatToScalar(srcArray[i << 1]),
-                         SkFloatToScalar(srcArray[(i << 1) + 1]));
-        }
-        
-        if (isPts)
-            matrix->mapPoints(dstPt, srcPt, ptCount);
-        else
-            matrix->mapVectors(dstPt, srcPt, ptCount);
-        
-        for (i = 0; i < ptCount; i++) {
-            dstArray[i << 1]  = SkScalarToFloat(dstPt[i].fX);
-            dstArray[(i << 1) + 1]  = SkScalarToFloat(dstPt[i].fY);
-        }
-#else
-        if (isPts)
-            matrix->mapPoints((SkPoint*)dstArray, (const SkPoint*)srcArray,
-                              ptCount);
-        else
-            matrix->mapVectors((SkVector*)dstArray, (const SkVector*)srcArray,
-                               ptCount);
-#endif
-    }
- 
-    static jboolean mapRect__RectFRectF(JNIEnv* env, jobject clazz, SkMatrix* matrix, jobjectArray dst, jobject src) {
-        SkRect dst_, src_;
-        GraphicsJNI::jrectf_to_rect(env, src, &src_);
-        jboolean rectStaysRect = matrix->mapRect(&dst_, src_);
-        GraphicsJNI::rect_to_jrectf(dst_, env, dst);
-        return rectStaysRect;
-    }
- 
-    static jfloat mapRadius(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloat radius) {
-        return SkScalarToFloat(matrix->mapRadius(SkFloatToScalar(radius)));
-    }
- 
-    static void getValues(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloatArray values) {
-        AutoJavaFloatArray autoValues(env, values, 9);
-        float* dst = autoValues.ptr();
-
-#ifdef SK_SCALAR_IS_FIXED
-        for (int i = 0; i < 6; i++) {
-            dst[i] = SkFixedToFloat(matrix->get(i));
-        }
-        for (int j = 6; j < 9; j++) {
-            dst[j] = SkFractToFloat(matrix->get(j));
-        }
-#else
-        for (int i = 0; i < 9; i++) {
-            dst[i] = matrix->get(i);
-        }
-#endif
-    }
- 
-    static void setValues(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloatArray values) {
-        AutoJavaFloatArray autoValues(env, values, 9);
-        const float* src = autoValues.ptr();
-
-#ifdef SK_SCALAR_IS_FIXED
-        for (int i = 0; i < 6; i++) {
-            matrix->set(i, SkFloatToFixed(src[i]));
-        }
-        for (int j = 6; j < 9; j++) {
-            matrix->set(j, SkFloatToFract(src[j]));
-        }
-#else
-        for (int i = 0; i < 9; i++) {
-            matrix->set(i, src[i]);
-        }
-#endif
-    }
-
-    static jboolean equals(JNIEnv* env, jobject clazz, const SkMatrix* a, const SkMatrix* b) {
-        return *a == *b;
-    }
- };
-
-static JNINativeMethod methods[] = {
-    {"finalizer", "(I)V", (void*) SkMatrixGlue::finalizer},
-    {"native_create","(I)I", (void*) SkMatrixGlue::create},
-    {"native_isIdentity","(I)Z", (void*) SkMatrixGlue::isIdentity},
-    {"native_rectStaysRect","(I)Z", (void*) SkMatrixGlue::rectStaysRect},
-    {"native_reset","(I)V", (void*) SkMatrixGlue::reset},
-    {"native_set","(II)V", (void*) SkMatrixGlue::set},
-    {"native_setTranslate","(IFF)V", (void*) SkMatrixGlue::setTranslate},
-    {"native_setScale","(IFFFF)V", (void*) SkMatrixGlue::setScale__FFFF},
-    {"native_setScale","(IFF)V", (void*) SkMatrixGlue::setScale__FF},
-    {"native_setRotate","(IFFF)V", (void*) SkMatrixGlue::setRotate__FFF},
-    {"native_setRotate","(IF)V", (void*) SkMatrixGlue::setRotate__F},
-    {"native_setSinCos","(IFFFF)V", (void*) SkMatrixGlue::setSinCos__FFFF},
-    {"native_setSinCos","(IFF)V", (void*) SkMatrixGlue::setSinCos__FF},
-    {"native_setSkew","(IFFFF)V", (void*) SkMatrixGlue::setSkew__FFFF},
-    {"native_setSkew","(IFF)V", (void*) SkMatrixGlue::setSkew__FF},
-    {"native_setConcat","(III)Z", (void*) SkMatrixGlue::setConcat},
-    {"native_preTranslate","(IFF)Z", (void*) SkMatrixGlue::preTranslate},
-    {"native_preScale","(IFFFF)Z", (void*) SkMatrixGlue::preScale__FFFF},
-    {"native_preScale","(IFF)Z", (void*) SkMatrixGlue::preScale__FF},
-    {"native_preRotate","(IFFF)Z", (void*) SkMatrixGlue::preRotate__FFF},
-    {"native_preRotate","(IF)Z", (void*) SkMatrixGlue::preRotate__F},
-    {"native_preSkew","(IFFFF)Z", (void*) SkMatrixGlue::preSkew__FFFF},
-    {"native_preSkew","(IFF)Z", (void*) SkMatrixGlue::preSkew__FF},
-    {"native_preConcat","(II)Z", (void*) SkMatrixGlue::preConcat},
-    {"native_postTranslate","(IFF)Z", (void*) SkMatrixGlue::postTranslate},
-    {"native_postScale","(IFFFF)Z", (void*) SkMatrixGlue::postScale__FFFF},
-    {"native_postScale","(IFF)Z", (void*) SkMatrixGlue::postScale__FF},
-    {"native_postRotate","(IFFF)Z", (void*) SkMatrixGlue::postRotate__FFF},
-    {"native_postRotate","(IF)Z", (void*) SkMatrixGlue::postRotate__F},
-    {"native_postSkew","(IFFFF)Z", (void*) SkMatrixGlue::postSkew__FFFF},
-    {"native_postSkew","(IFF)Z", (void*) SkMatrixGlue::postSkew__FF},
-    {"native_postConcat","(II)Z", (void*) SkMatrixGlue::postConcat},
-    {"native_setRectToRect","(ILandroid/graphics/RectF;Landroid/graphics/RectF;I)Z", (void*) SkMatrixGlue::setRectToRect},
-    {"native_setPolyToPoly","(I[FI[FII)Z", (void*) SkMatrixGlue::setPolyToPoly},
-    {"native_invert","(II)Z", (void*) SkMatrixGlue::invert},
-    {"native_mapPoints","(I[FI[FIIZ)V", (void*) SkMatrixGlue::mapPoints},
-    {"native_mapRect","(ILandroid/graphics/RectF;Landroid/graphics/RectF;)Z", (void*) SkMatrixGlue::mapRect__RectFRectF},
-    {"native_mapRadius","(IF)F", (void*) SkMatrixGlue::mapRadius},
-    {"native_getValues","(I[F)V", (void*) SkMatrixGlue::getValues},
-    {"native_setValues","(I[F)V", (void*) SkMatrixGlue::setValues},
-    {"native_equals", "(II)Z", (void*) SkMatrixGlue::equals}
-};
-
-int register_android_graphics_Matrix(JNIEnv* env) {
-    int result = AndroidRuntime::registerNativeMethods(env, "android/graphics/Matrix", methods,
-        sizeof(methods) / sizeof(methods[0]));
-    return result;
-}
-
-}
diff --git a/core/jni/android/graphics/Movie.cpp b/core/jni/android/graphics/Movie.cpp
deleted file mode 100644
index de18f9f..0000000
--- a/core/jni/android/graphics/Movie.cpp
+++ /dev/null
@@ -1,155 +0,0 @@
-#include "SkMovie.h"
-#include "SkStream.h"
-#include "GraphicsJNI.h"
-#include "SkTemplates.h"
-#include "SkUtils.h"
-#include "CreateJavaOutputStreamAdaptor.h"
-
-#include <utils/Asset.h>
-#include <utils/ResourceTypes.h>
-#include <netinet/in.h>
-
-#if 0
-    #define TRACE_BITMAP(code)  code
-#else
-    #define TRACE_BITMAP(code)
-#endif
-
-static jclass       gMovie_class;
-static jmethodID    gMovie_constructorMethodID;
-static jfieldID     gMovie_nativeInstanceID;
-
-jobject create_jmovie(JNIEnv* env, SkMovie* moov) {
-    if (NULL == moov) {
-        return NULL;
-    }
-    jobject obj = env->AllocObject(gMovie_class);
-    if (obj) {
-        env->CallVoidMethod(obj, gMovie_constructorMethodID, (jint)moov);
-    }
-    return obj;
-}
-
-static SkMovie* J2Movie(JNIEnv* env, jobject movie) {
-    SkASSERT(env);
-    SkASSERT(movie);
-    SkASSERT(env->IsInstanceOf(movie, gMovie_class));
-    SkMovie* m = (SkMovie*)env->GetIntField(movie, gMovie_nativeInstanceID);
-    SkASSERT(m);
-    return m;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-static int movie_width(JNIEnv* env, jobject movie) {
-    NPE_CHECK_RETURN_ZERO(env, movie);
-    return J2Movie(env, movie)->width();
-}
-
-static int movie_height(JNIEnv* env, jobject movie) {
-    NPE_CHECK_RETURN_ZERO(env, movie);
-    return J2Movie(env, movie)->height();
-}
-
-static jboolean movie_isOpaque(JNIEnv* env, jobject movie) {
-    NPE_CHECK_RETURN_ZERO(env, movie);
-    return J2Movie(env, movie)->isOpaque();
-}
-
-static int movie_duration(JNIEnv* env, jobject movie) {
-    NPE_CHECK_RETURN_ZERO(env, movie);
-    return J2Movie(env, movie)->duration();
-}
-
-static jboolean movie_setTime(JNIEnv* env, jobject movie, int ms) {
-    NPE_CHECK_RETURN_ZERO(env, movie);
-    return J2Movie(env, movie)->setTime(ms);
-}
-
-static void movie_draw(JNIEnv* env, jobject movie, jobject canvas,
-                       jfloat fx, jfloat fy, jobject jpaint) {
-    NPE_CHECK_RETURN_VOID(env, movie);
-    NPE_CHECK_RETURN_VOID(env, canvas);
-    // its OK for paint to be null
-
-    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);
-}
-
-static jobject movie_decodeStream(JNIEnv* env, jobject clazz, jobject istream) {
-                              
-    NPE_CHECK_RETURN_ZERO(env, istream);
-
-    // what is the lifetime of the array? Can the skstream hold onto it?
-    jbyteArray byteArray = env->NewByteArray(16*1024);
-    SkStream* strm = CreateJavaInputStreamAdaptor(env, istream, byteArray);
-    if (NULL == strm) {
-        return 0;
-    }
-
-    SkMovie* moov = SkMovie::DecodeStream(strm);
-    strm->unref();
-    return create_jmovie(env, moov);
-}
-
-static jobject movie_decodeByteArray(JNIEnv* env, jobject clazz,
-                                     jbyteArray byteArray,
-                                     int offset, int length) {
-                              
-    NPE_CHECK_RETURN_ZERO(env, byteArray);
-
-    int totalLength = env->GetArrayLength(byteArray);
-    if ((offset | length) < 0 || offset + length > totalLength) {
-        doThrow(env, "java/lang/ArrayIndexOutOfBoundsException");
-        return 0;
-    }
-
-    AutoJavaByteArray   ar(env, byteArray);
-    SkMovie* moov = SkMovie::DecodeMemory(ar.ptr() + offset, length);
-    return create_jmovie(env, moov);
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////
-
-#include <android_runtime/AndroidRuntime.h>
-
-static JNINativeMethod gMethods[] = {
-    {   "width",    "()I",  (void*)movie_width  },
-    {   "height",   "()I",  (void*)movie_height  },
-    {   "isOpaque", "()Z",  (void*)movie_isOpaque  },
-    {   "duration", "()I",  (void*)movie_duration  },
-    {   "setTime",  "(I)Z", (void*)movie_setTime  },
-    {   "draw",     "(Landroid/graphics/Canvas;FFLandroid/graphics/Paint;)V",
-                            (void*)movie_draw  },
-    { "decodeStream", "(Ljava/io/InputStream;)Landroid/graphics/Movie;",
-                            (void*)movie_decodeStream },
-    { "decodeByteArray", "([BII)Landroid/graphics/Movie;",
-                            (void*)movie_decodeByteArray },
-};
-
-#define kClassPathName  "android/graphics/Movie"
-
-#define RETURN_ERR_IF_NULL(value)   do { if (!(value)) { assert(0); return -1; } } while (false)
-
-int register_android_graphics_Movie(JNIEnv* env);
-int register_android_graphics_Movie(JNIEnv* env)
-{
-    gMovie_class = env->FindClass(kClassPathName);
-    RETURN_ERR_IF_NULL(gMovie_class);
-    gMovie_class = (jclass)env->NewGlobalRef(gMovie_class);
-    
-    gMovie_constructorMethodID = env->GetMethodID(gMovie_class, "<init>", "(I)V");
-    RETURN_ERR_IF_NULL(gMovie_constructorMethodID);
-
-    gMovie_nativeInstanceID = env->GetFieldID(gMovie_class, "mNativeMovie", "I");
-    RETURN_ERR_IF_NULL(gMovie_nativeInstanceID);
-
-    return android::AndroidRuntime::registerNativeMethods(env, kClassPathName,
-                                                       gMethods, SK_ARRAY_COUNT(gMethods));
-}
diff --git a/core/jni/android/graphics/NIOBuffer.cpp b/core/jni/android/graphics/NIOBuffer.cpp
deleted file mode 100644
index cb937a3..0000000
--- a/core/jni/android/graphics/NIOBuffer.cpp
+++ /dev/null
@@ -1,143 +0,0 @@
-#include "NIOBuffer.h"
-#include "GraphicsJNI.h"
-
-// enable this to dump each time we ref/unref a global java object (buffer)
-//
-//#define TRACE_GLOBAL_REFS
-
-//#define TRACE_ARRAY_LOCKS
-
-static jclass gNIOAccess_classID;
-static jmethodID gNIOAccess_getBasePointer;
-static jmethodID gNIOAccess_getBaseArray;
-static jmethodID gNIOAccess_getBaseArrayOffset;
-static jmethodID gNIOAccess_getRemainingBytes;
-
-void NIOBuffer::RegisterJNI(JNIEnv* env) {
-    if (0 != gNIOAccess_classID) {
-        return; // already called
-    }
-
-    jclass c = env->FindClass("java/nio/NIOAccess");
-    gNIOAccess_classID = (jclass)env->NewGlobalRef(c);
-
-    gNIOAccess_getBasePointer = env->GetStaticMethodID(gNIOAccess_classID,
-                                    "getBasePointer", "(Ljava/nio/Buffer;)J");
-    gNIOAccess_getBaseArray = env->GetStaticMethodID(gNIOAccess_classID,
-                    "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;");
-    gNIOAccess_getBaseArrayOffset = env->GetStaticMethodID(gNIOAccess_classID,
-                                "getBaseArrayOffset", "(Ljava/nio/Buffer;)I");
-    gNIOAccess_getRemainingBytes = env->GetStaticMethodID(gNIOAccess_classID,
-                                "getRemainingBytes", "(Ljava/nio/Buffer;)I");
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-#ifdef TRACE_GLOBAL_REFS
-    static int gGlobalRefs;
-#endif
-
-#ifdef TRACE_ARRAY_LOCKS
-    static int gLockCount;
-#endif
-
-NIOBuffer::NIOBuffer(JNIEnv* env, jobject buffer) {
-    fBuffer = env->NewGlobalRef(buffer);
-#ifdef TRACE_GLOBAL_REFS
-    SkDebugf("------------ newglobalref bbuffer %X %d\n", buffer, gGlobalRefs++);
-#endif
-    fLockedPtr = NULL;
-    fLockedArray = NULL;
-}
-
-NIOBuffer::~NIOBuffer() {
-    // free() needs to have already been called
-    if (NULL != fBuffer) {
-        SkDebugf("----- leaked fBuffer in NIOBuffer");
-        sk_throw();
-    }
-}
-
-void NIOBuffer::free(JNIEnv* env) {
-
-    if (NULL != fLockedPtr) {
-        SkDebugf("======= free: array still locked %x %p\n", fLockedArray, fLockedPtr);
-    }
-    
-    
-    if (NULL != fBuffer) {
-#ifdef TRACE_GLOBAL_REFS
-        SkDebugf("----------- deleteglobalref buffer %X %d\n", fBuffer, --gGlobalRefs);
-#endif
-        env->DeleteGlobalRef(fBuffer);
-        fBuffer = NULL;
-    }
-}
-
-void* NIOBuffer::lock(JNIEnv* env, int* remaining) {
-    if (NULL != fLockedPtr) {
-        SkDebugf("======= lock: array still locked %x %p\n", fLockedArray, fLockedPtr);
-    }
-
-    fLockedPtr = NULL;
-    fLockedArray = NULL;
-
-    if (NULL != remaining) {
-        *remaining = env->CallStaticIntMethod(gNIOAccess_classID,
-                                              gNIOAccess_getRemainingBytes,
-                                              fBuffer);
-        if (GraphicsJNI::hasException(env)) {
-            return NULL;
-        }
-    }
-    
-    jlong pointer = env->CallStaticLongMethod(gNIOAccess_classID,
-                                              gNIOAccess_getBasePointer,
-                                              fBuffer);
-    if (GraphicsJNI::hasException(env)) {
-        return NULL;
-    }
-    if (0 != pointer) {
-        return reinterpret_cast<void*>(pointer);
-    }
-    
-    fLockedArray = (jbyteArray)env->CallStaticObjectMethod(gNIOAccess_classID,
-                                                        gNIOAccess_getBaseArray,
-                                                        fBuffer);
-    if (GraphicsJNI::hasException(env) || NULL == fLockedArray) {
-        return NULL;
-    }
-    jint offset = env->CallStaticIntMethod(gNIOAccess_classID,
-                                           gNIOAccess_getBaseArrayOffset,
-                                           fBuffer);
-    fLockedPtr = env->GetByteArrayElements(fLockedArray, NULL);
-    if (GraphicsJNI::hasException(env)) {
-        SkDebugf("------------ failed to lockarray %x\n", fLockedArray);
-        return NULL;
-    }
-#ifdef TRACE_ARRAY_LOCKS
-    SkDebugf("------------ lockarray %x %p %d\n",
-             fLockedArray, fLockedPtr, gLockCount++);
-#endif
-    if (NULL == fLockedPtr) {
-        offset = 0;
-    }
-    return (char*)fLockedPtr + offset;
-}
-
-void NIOBuffer::unlock(JNIEnv* env, bool dataChanged) {
-    if (NULL != fLockedPtr) {
-#ifdef TRACE_ARRAY_LOCKS
-        SkDebugf("------------ unlockarray %x %p %d\n",
-                 fLockedArray, fLockedPtr, --gLockCount);
-#endif
-        env->ReleaseByteArrayElements(fLockedArray, (jbyte*)fLockedPtr,
-                                      dataChanged ? 0 : JNI_ABORT);
-        
-        fLockedPtr = NULL;
-        fLockedArray = NULL;
-    } else {
-        SkDebugf("============= unlock called with null ptr %x\n", fLockedArray);
-    }
-}
-
diff --git a/core/jni/android/graphics/NIOBuffer.h b/core/jni/android/graphics/NIOBuffer.h
deleted file mode 100644
index 36b5554..0000000
--- a/core/jni/android/graphics/NIOBuffer.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#ifndef NIOBuffer_DEFINED
-#define NIOBuffer_DEFINED
-
-#include <jni.h>
-#include "SkBitmap.h"
-
-class NIOBuffer {
-public:
-    NIOBuffer(JNIEnv* env, jobject buffer);
-    // this checks to ensure that free() was called
-    ~NIOBuffer();
-
-    void* lock(JNIEnv* env, int* remaining);
-    void unlock(JNIEnv* env, bool dataChanged);
-    // must be called before destructor
-    void free(JNIEnv* env);
-
-    // call once on boot, to setup JNI globals
-    static void RegisterJNI(JNIEnv*);
-
-private:
-    jobject     fBuffer;
-    void*       fLockedPtr;
-    jbyteArray  fLockedArray;
-};
-
-#endif
diff --git a/core/jni/android/graphics/NinePatch.cpp b/core/jni/android/graphics/NinePatch.cpp
deleted file mode 100644
index b11edfc..0000000
--- a/core/jni/android/graphics/NinePatch.cpp
+++ /dev/null
@@ -1,142 +0,0 @@
-#include <utils/ResourceTypes.h>
-
-#include "SkRegion.h"
-#include "GraphicsJNI.h"
-
-#include "JNIHelp.h"
-
-extern void NinePatch_Draw(SkCanvas* canvas, const SkRect& bounds,
-                const SkBitmap& bitmap, const android::Res_png_9patch& chunk,
-                           const SkPaint* paint, SkRegion** outRegion);
-    
-using namespace android;
-
-class SkNinePatchGlue {
-public:
-    static jboolean isNinePatchChunk(JNIEnv* env, jobject, jbyteArray obj)
-    {
-        if (NULL == obj) {
-            return false;
-        }
-        if (env->GetArrayLength(obj) < (int)sizeof(Res_png_9patch)) {
-            return false;
-        }
-        const jbyte* array = env->GetByteArrayElements(obj, 0);
-        if (array != NULL) {
-            const Res_png_9patch* chunk =
-                                reinterpret_cast<const Res_png_9patch*>(array);
-            int8_t wasDeserialized = chunk->wasDeserialized;
-            env->ReleaseByteArrayElements(obj, const_cast<jbyte*>(array),
-                                          JNI_ABORT);
-            return wasDeserialized != -1;
-        }
-        return false;
-    }
-
-    static void validateNinePatchChunk(JNIEnv* env, jobject, jint, jbyteArray obj)
-    {
-        if (env->GetArrayLength(obj) < (int) (sizeof(Res_png_9patch))) {
-            jniThrowException(env, "java/lang/RuntimeException",
-                              "Array too small for chunk.");
-            return;
-        }
-
-        // XXX Also check that dimensions are correct.
-    }
-
-    static void draw(JNIEnv* env, SkCanvas* canvas, SkRect& bounds,
-                      const SkBitmap* bitmap, jbyteArray chunkObj, const SkPaint* paint)
-    {
-        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
-            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);
-        }
-    } 
-
-    static void drawF(JNIEnv* env, jobject, SkCanvas* canvas, jobject boundsRectF,
-                      const SkBitmap* bitmap, jbyteArray chunkObj, const SkPaint* paint)
-    {
-        SkASSERT(canvas);
-        SkASSERT(boundsRectF);
-        SkASSERT(bitmap);
-        SkASSERT(chunkObj);
-        // paint is optional
-
-        SkRect      bounds;
-        GraphicsJNI::jrectf_to_rect(env, boundsRectF, &bounds);
-
-        draw(env, canvas, bounds, bitmap, chunkObj, paint);
-    }
- 
-    static void drawI(JNIEnv* env, jobject, SkCanvas* canvas, jobject boundsRect,
-                      const SkBitmap* bitmap, jbyteArray chunkObj, const SkPaint* paint)
-    {
-        SkASSERT(canvas);
-        SkASSERT(boundsRect);
-        SkASSERT(bitmap);
-        SkASSERT(chunkObj);
-        // paint is optional
-
-        SkRect      bounds;
-        GraphicsJNI::jrect_to_rect(env, boundsRect, &bounds);
-        draw(env, canvas, bounds, bitmap, chunkObj, paint);
-    }
-    
-    static jint getTransparentRegion(JNIEnv* env, jobject,
-                    const SkBitmap* bitmap, jbyteArray chunkObj,
-                    jobject boundsRect)
-    {
-        SkASSERT(bitmap);
-        SkASSERT(chunkObj);
-        SkASSERT(boundsRect);
-        
-        SkRect      bounds;
-        GraphicsJNI::jrect_to_rect(env, boundsRect, &bounds);
-        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
-            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);
-            SkRegion* region = NULL;
-            NinePatch_Draw(NULL, bounds, *bitmap, *chunk, NULL, &region);
-            return (jint)region;
-        }
-        return 0;
-    }
-
-};
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-#include <android_runtime/AndroidRuntime.h>
-
-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   },
-    { "nativeGetTransparentRegion", "(I[BLandroid/graphics/Rect;)I", 
-                                                        (void*)SkNinePatchGlue::getTransparentRegion   }
-};
-
-int register_android_graphics_NinePatch(JNIEnv* env);
-int register_android_graphics_NinePatch(JNIEnv* env)
-{
-    return android::AndroidRuntime::registerNativeMethods(env,
-                                                       "android/graphics/NinePatch",
-                                                       gNinePatchMethods,
-                                                       SK_ARRAY_COUNT(gNinePatchMethods));
-}
diff --git a/core/jni/android/graphics/NinePatchImpl.cpp b/core/jni/android/graphics/NinePatchImpl.cpp
deleted file mode 100644
index f82053c..0000000
--- a/core/jni/android/graphics/NinePatchImpl.cpp
+++ /dev/null
@@ -1,324 +0,0 @@
-/*
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License");
-** you may not use this file except in compliance with the License.
-** You may obtain a copy of the License at
-**
-**     http://www.apache.org/licenses/LICENSE-2.0
-**
-** Unless required by applicable law or agreed to in writing, software
-** distributed under the License is distributed on an "AS IS" BASIS,
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-** See the License for the specific language governing permissions and
-** limitations under the License.
-*/
-
-#define LOG_TAG "NinePatch"
-
-#include <utils/ResourceTypes.h>
-
-#include "SkBitmap.h"
-#include "SkCanvas.h"
-#include "SkNinePatch.h"
-#include "SkPaint.h"
-#include "SkUnPreMultiply.h"
-
-#define USE_TRACEx
-
-#ifdef USE_TRACE
-    static bool gTrace;
-#endif
-
-#include "SkColorPriv.h"
-
-#include <utils/Log.h>
-
-static bool getColor(const SkBitmap& bitmap, int x, int y, SkColor* c) {
-    switch (bitmap.getConfig()) {
-        case SkBitmap::kARGB_8888_Config:
-            *c = SkUnPreMultiply::PMColorToColor(*bitmap.getAddr32(x, y));
-            break;
-        case SkBitmap::kRGB_565_Config:
-            *c = SkPixel16ToPixel32(*bitmap.getAddr16(x, y));
-            break;
-        case SkBitmap::kARGB_4444_Config:
-            *c = SkUnPreMultiply::PMColorToColor(
-                                SkPixel4444ToPixel32(*bitmap.getAddr16(x, y)));
-            break;
-        case SkBitmap::kIndex8_Config: {
-            SkColorTable* ctable = bitmap.getColorTable();
-            *c = SkUnPreMultiply::PMColorToColor(
-                                            (*ctable)[*bitmap.getAddr8(x, y)]);
-            break;
-        }
-        default:
-            return false;
-    }
-    return true;
-}
-
-static SkColor modAlpha(SkColor c, int alpha) {
-    int scale = alpha + (alpha >> 7);
-    int a = SkColorGetA(c) * scale >> 8;
-    return SkColorSetA(c, a);
-}
-
-static void drawStretchyPatch(SkCanvas* canvas, SkIRect& src, const SkRect& dst,
-                              const SkBitmap& bitmap, const SkPaint& paint,
-                              SkColor initColor, uint32_t colorHint,
-                              bool hasXfer) {
-    if (colorHint !=  android::Res_png_9patch::NO_COLOR) {
-        ((SkPaint*)&paint)->setColor(modAlpha(colorHint, paint.getAlpha()));
-        canvas->drawRect(dst, paint);
-        ((SkPaint*)&paint)->setColor(initColor);
-    } else if (src.width() == 1 && src.height() == 1) {
-        SkColor c;
-        if (!getColor(bitmap, src.fLeft, src.fTop, &c)) {
-            goto SLOW_CASE;
-        }
-        if (0 != c || hasXfer) {
-            SkColor prev = paint.getColor();
-            ((SkPaint*)&paint)->setColor(c);
-            canvas->drawRect(dst, paint);
-            ((SkPaint*)&paint)->setColor(prev);
-        }
-    } else {
-    SLOW_CASE:
-        canvas->drawBitmapRect(bitmap, &src, dst, &paint);
-    }
-}
-
-SkScalar calculateStretch(SkScalar boundsLimit, SkScalar startingPoint,
-                          int srcSpace, int numStrechyPixelsRemaining,
-                          int numFixedPixelsRemaining) {
-    SkScalar spaceRemaining = boundsLimit - startingPoint;
-    SkScalar stretchySpaceRemaining =
-                spaceRemaining - SkIntToScalar(numFixedPixelsRemaining);
-    return SkScalarMulDiv(srcSpace, stretchySpaceRemaining,
-                          numStrechyPixelsRemaining);
-}
-
-void NinePatch_Draw(SkCanvas* canvas, const SkRect& bounds,
-                       const SkBitmap& bitmap, const android::Res_png_9patch& chunk,
-                       const SkPaint* paint, SkRegion** outRegion) {
-    if (canvas && canvas->quickReject(bounds, SkCanvas::kBW_EdgeType)) {
-        return;
-    }
-    
-    // if our canvas is GL, draw this as a mesh, which will be faster than
-    // in parts (which is faster for raster)
-    if (canvas && canvas->getViewport(NULL)) {
-        SkNinePatch::DrawMesh(canvas, bounds, bitmap,
-                              chunk.xDivs, chunk.numXDivs,
-                              chunk.yDivs, chunk.numYDivs,
-                              paint);
-        return;
-    }
-
-#ifdef USE_TRACE
-    gTrace = true;
-#endif
-
-    SkASSERT(canvas || outRegion);
-
-#if 0
-    if (canvas) {
-        const SkMatrix& m = canvas->getTotalMatrix();
-        SkDebugf("ninepatch [%g %g %g] [%g %g %g]\n",
-                 SkScalarToFloat(m[0]), SkScalarToFloat(m[1]), SkScalarToFloat(m[2]),
-                 SkScalarToFloat(m[3]), SkScalarToFloat(m[4]), SkScalarToFloat(m[5]));
-    }
-#endif
-
-#ifdef USE_TRACE
-    if (gTrace) {
-        SkDEBUGF(("======== ninepatch bounds [%g %g]\n", SkScalarToFloat(bounds.width()), SkScalarToFloat(bounds.height())));
-        SkDEBUGF(("======== ninepatch paint bm [%d,%d]\n", bitmap.width(), bitmap.height()));
-        SkDEBUGF(("======== ninepatch xDivs [%d,%d]\n", chunk.xDivs[0], chunk.xDivs[1]));
-        SkDEBUGF(("======== ninepatch yDivs [%d,%d]\n", chunk.yDivs[0], chunk.yDivs[1]));
-    }
-#endif
-
-    if (bounds.isEmpty() ||
-        bitmap.width() == 0 || bitmap.height() == 0 ||
-        (paint && paint->getXfermode() == NULL && paint->getAlpha() == 0))
-    {
-#ifdef USE_TRACE
-        if (gTrace) SkDEBUGF(("======== abort ninepatch draw\n"));
-#endif
-        return;
-    }
-    
-    // should try a quick-reject test before calling lockPixels 
-
-    SkAutoLockPixels alp(bitmap);
-    // after the lock, it is valid to check getPixels()
-    if (bitmap.getPixels() == NULL)
-        return;
-
-    SkPaint defaultPaint;
-    if (NULL == paint) {
-        paint = &defaultPaint;
-    }
-
-    const bool hasXfer = paint->getXfermode() != NULL;
-    SkRect      dst;
-    SkIRect     src;
-
-    const int32_t x0 = chunk.xDivs[0];
-    const int32_t y0 = chunk.yDivs[0];
-    const SkColor initColor = ((SkPaint*)paint)->getColor();
-    const uint8_t numXDivs = chunk.numXDivs;
-    const uint8_t numYDivs = chunk.numYDivs;
-    int i;
-    int j;
-    int colorIndex = 0;
-    uint32_t color;
-    bool xIsStretchable;
-    const bool initialXIsStretchable =  (x0 == 0);
-    bool yIsStretchable = (y0 == 0);
-    const int bitmapWidth = bitmap.width();
-    const int bitmapHeight = bitmap.height();
-
-    SkScalar* dstRights = (SkScalar*) alloca((numXDivs + 1) * sizeof(SkScalar));
-    bool dstRightsHaveBeenCached = false;
-
-    int numStretchyXPixelsRemaining = 0;
-    for (i = 0; i < numXDivs; i += 2) {
-        numStretchyXPixelsRemaining += chunk.xDivs[i + 1] - chunk.xDivs[i];
-    }
-    int numFixedXPixelsRemaining = bitmapWidth - numStretchyXPixelsRemaining;
-    int numStretchyYPixelsRemaining = 0;
-    for (i = 0; i < numYDivs; i += 2) {
-        numStretchyYPixelsRemaining += chunk.yDivs[i + 1] - chunk.yDivs[i];
-    }
-    int numFixedYPixelsRemaining = bitmapHeight - numStretchyYPixelsRemaining;
-
-#if 0
-    SkDebugf("NinePatch [%d %d] bounds [%g %g %g %g] divs [%d %d]\n",
-             bitmap.width(), bitmap.height(),
-             SkScalarToFloat(bounds.fLeft), SkScalarToFloat(bounds.fTop),
-             SkScalarToFloat(bounds.width()), SkScalarToFloat(bounds.height()),
-             numXDivs, numYDivs);
-#endif
-
-    src.fTop = 0;
-    dst.fTop = bounds.fTop;
-    // The first row always starts with the top being at y=0 and the bottom
-    // being either yDivs[1] (if yDivs[0]=0) of yDivs[0].  In the former case
-    // the first row is stretchable along the Y axis, otherwise it is fixed.
-    // The last row always ends with the bottom being bitmap.height and the top
-    // being either yDivs[numYDivs-2] (if yDivs[numYDivs-1]=bitmap.height) or
-    // yDivs[numYDivs-1]. In the former case the last row is stretchable along
-    // the Y axis, otherwise it is fixed.
-    //
-    // The first and last columns are similarly treated with respect to the X
-    // axis.
-    //
-    // The above is to help explain some of the special casing that goes on the
-    // code below.
-
-    // The initial yDiv and whether the first row is considered stretchable or
-    // not depends on whether yDiv[0] was zero or not.
-    for (j = yIsStretchable ? 1 : 0;
-          j <= numYDivs && src.fTop < bitmapHeight;
-          j++, yIsStretchable = !yIsStretchable) {
-        src.fLeft = 0;
-        dst.fLeft = bounds.fLeft;
-        if (j == numYDivs) {
-            src.fBottom = bitmapHeight;
-            dst.fBottom = bounds.fBottom;
-        } else {
-            src.fBottom = chunk.yDivs[j];
-            const int srcYSize = src.fBottom - src.fTop;
-            if (yIsStretchable) {
-                dst.fBottom = dst.fTop + calculateStretch(bounds.fBottom, dst.fTop,
-                                                          srcYSize,
-                                                          numStretchyYPixelsRemaining,
-                                                          numFixedYPixelsRemaining);
-                numStretchyYPixelsRemaining -= srcYSize;
-            } else {
-                dst.fBottom = dst.fTop + SkIntToScalar(srcYSize);
-                numFixedYPixelsRemaining -= srcYSize;
-            }
-        }
-
-        xIsStretchable = initialXIsStretchable;
-        // The initial xDiv and whether the first column is considered
-        // stretchable or not depends on whether xDiv[0] was zero or not.
-        for (i = xIsStretchable ? 1 : 0;
-              i <= numXDivs && src.fLeft < bitmapWidth;
-              i++, xIsStretchable = !xIsStretchable) {
-            color = chunk.colors[colorIndex++];
-            if (i == numXDivs) {
-                src.fRight = bitmapWidth;
-                dst.fRight = bounds.fRight;
-            } else {
-                src.fRight = chunk.xDivs[i];
-                if (dstRightsHaveBeenCached) {
-                    dst.fRight = dstRights[i];
-                } else {
-                    const int srcXSize = src.fRight - src.fLeft;
-                    if (xIsStretchable) {
-                        dst.fRight = dst.fLeft + calculateStretch(bounds.fRight, dst.fLeft,
-                                                                  srcXSize,
-                                                                  numStretchyXPixelsRemaining,
-                                                                  numFixedXPixelsRemaining);
-                        numStretchyXPixelsRemaining -= srcXSize;
-                    } else {
-                        dst.fRight = dst.fLeft + SkIntToScalar(srcXSize);
-                        numFixedXPixelsRemaining -= srcXSize;
-                    }
-                    dstRights[i] = dst.fRight;
-                }
-            }
-            // If this horizontal patch is too small to be displayed, leave
-            // the destination left edge where it is and go on to the next patch
-            // in the source.
-            if (src.fLeft >= src.fRight) {
-                src.fLeft = src.fRight;
-                continue;
-            }
-            // Make sure that we actually have room to draw any bits
-            if (dst.fRight <= dst.fLeft || dst.fBottom <= dst.fTop) {
-                goto nextDiv;
-            }
-            // If this patch is transparent, skip and don't draw.
-            if (color == android::Res_png_9patch::TRANSPARENT_COLOR && !hasXfer) {
-                if (outRegion) {
-                    if (*outRegion == NULL) {
-                        *outRegion = new SkRegion();
-                    }
-                    SkIRect idst;
-                    dst.round(&idst);
-                    //LOGI("Adding trans rect: (%d,%d)-(%d,%d)\n",
-                    //     idst.fLeft, idst.fTop, idst.fRight, idst.fBottom);
-                    (*outRegion)->op(idst, SkRegion::kUnion_Op);
-                }
-                goto nextDiv;
-            }
-            if (canvas) {
-#if 0
-                SkDebugf("-- src [%d %d %d %d] dst [%g %g %g %g]\n",
-                         src.fLeft, src.fTop, src.width(), src.height(),
-                         SkScalarToFloat(dst.fLeft), SkScalarToFloat(dst.fTop),
-                         SkScalarToFloat(dst.width()), SkScalarToFloat(dst.height()));
-                if (2 == src.width() && SkIntToScalar(5) == dst.width()) {
-                    SkDebugf("--- skip patch\n");
-                }
-#endif
-                drawStretchyPatch(canvas, src, dst, bitmap, *paint, initColor,
-                                  color, hasXfer);
-            }
-
-nextDiv:
-            src.fLeft = src.fRight;
-            dst.fLeft = dst.fRight;
-        }
-        src.fTop = src.fBottom;
-        dst.fTop = dst.fBottom;
-        dstRightsHaveBeenCached = true;
-    }
-}
diff --git a/core/jni/android/graphics/Paint.cpp b/core/jni/android/graphics/Paint.cpp
deleted file mode 100644
index 76e6f02..0000000
--- a/core/jni/android/graphics/Paint.cpp
+++ /dev/null
@@ -1,612 +0,0 @@
-/* libs/android_runtime/android/graphics/Paint.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
-**
-**     http://www.apache.org/licenses/LICENSE-2.0 
-**
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
-** limitations under the License.
-*/
-
-// This file was generated from the C++ include file: SkPaint.h
-// Any changes made to this file will be discarded by the build.
-// To change this file, either edit the include, or device/tools/gluemaker/main.cpp, 
-// or one of the auxilary file specifications in device/tools/gluemaker.
-
-#include "jni.h"
-#include "GraphicsJNI.h"
-#include <android_runtime/AndroidRuntime.h>
-
-#include "SkBlurDrawLooper.h"
-#include "SkColorFilter.h"
-#include "SkMaskFilter.h"
-#include "SkRasterizer.h"
-#include "SkShader.h"
-#include "SkTypeface.h"
-#include "SkXfermode.h"
-
-namespace android {
-
-struct JMetricsID {
-    jfieldID    top;
-    jfieldID    ascent;
-    jfieldID    descent;
-    jfieldID    bottom;
-    jfieldID    leading;
-};
-
-static jclass   gFontMetrics_class;
-static JMetricsID gFontMetrics_fieldID;
-
-static jclass   gFontMetricsInt_class;
-static JMetricsID gFontMetricsInt_fieldID;
-
-class SkPaintGlue {
-public:
-
-    static void finalizer(JNIEnv* env, jobject clazz, SkPaint* obj) {
-        delete obj;
-    }
-
-    static SkPaint* init(JNIEnv* env, jobject clazz) {
-        SkPaint* obj = new SkPaint();
-        // utf16 is required for java
-        obj->setTextEncoding(SkPaint::kUTF16_TextEncoding);
-        return obj;
-    }
-
-    static SkPaint* intiWithPaint(JNIEnv* env, jobject clazz, SkPaint* paint) {
-        SkPaint* obj = new SkPaint(*paint);
-        return obj;
-    }
- 
-    static void reset(JNIEnv* env, jobject clazz, SkPaint* obj) {
-        obj->reset();
-    }
- 
-    static void assign(JNIEnv* env, jobject clazz, SkPaint* dst, const SkPaint* src) {
-        *dst = *src;
-    }
- 
-    static jint getFlags(JNIEnv* env, jobject paint) {
-        NPE_CHECK_RETURN_ZERO(env, paint);
-        return GraphicsJNI::getNativePaint(env, paint)->getFlags();
-    }
- 
-    static void setFlags(JNIEnv* env, jobject paint, jint flags) {
-        NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setFlags(flags);
-    }
- 
-    static void setAntiAlias(JNIEnv* env, jobject paint, jboolean aa) {
-        NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setAntiAlias(aa);
-    }
- 
-    static void setLinearText(JNIEnv* env, jobject paint, jboolean linearText) {
-        NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setLinearText(linearText);
-    }
-    
-    static void setSubpixelText(JNIEnv* env, jobject paint, jboolean subpixelText) {
-        NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setSubpixelText(subpixelText);
-    }
-    
-    static void setUnderlineText(JNIEnv* env, jobject paint, jboolean underlineText) {
-        NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setUnderlineText(underlineText);
-    }
- 
-    static void setStrikeThruText(JNIEnv* env, jobject paint, jboolean strikeThruText) {
-        NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setStrikeThruText(strikeThruText);
-    }
- 
-    static void setFakeBoldText(JNIEnv* env, jobject paint, jboolean fakeBoldText) {
-        NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setFakeBoldText(fakeBoldText);
-    }
-    
-    static void setFilterBitmap(JNIEnv* env, jobject paint, jboolean filterBitmap) {
-        NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setFilterBitmap(filterBitmap);
-    }
-    
-    static void setDither(JNIEnv* env, jobject paint, jboolean dither) {
-        NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setDither(dither);
-    }
-    
-    static jint getStyle(JNIEnv* env, jobject clazz, SkPaint* obj) {
-        return obj->getStyle();
-    }
- 
-    static void setStyle(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Style style) {
-        obj->setStyle(style);
-    }
- 
-    static jint getColor(JNIEnv* env, jobject paint) {
-        NPE_CHECK_RETURN_ZERO(env, paint);
-        return GraphicsJNI::getNativePaint(env, paint)->getColor();
-    }
- 
-    static jint getAlpha(JNIEnv* env, jobject paint) {
-        NPE_CHECK_RETURN_ZERO(env, paint);
-        return GraphicsJNI::getNativePaint(env, paint)->getAlpha();
-    }
- 
-    static void setColor(JNIEnv* env, jobject paint, jint color) {
-        NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setColor(color);
-    }
- 
-    static void setAlpha(JNIEnv* env, jobject paint, jint a) {
-        NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setAlpha(a);
-    }
- 
-    static jfloat getStrokeWidth(JNIEnv* env, jobject paint) {
-        NPE_CHECK_RETURN_ZERO(env, paint);
-        return SkScalarToFloat(GraphicsJNI::getNativePaint(env, paint)->getStrokeWidth());
-    }
- 
-    static void setStrokeWidth(JNIEnv* env, jobject paint, jfloat width) {
-        NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setStrokeWidth(SkFloatToScalar(width));
-    }
- 
-    static jfloat getStrokeMiter(JNIEnv* env, jobject paint) {
-        NPE_CHECK_RETURN_ZERO(env, paint);
-        return SkScalarToFloat(GraphicsJNI::getNativePaint(env, paint)->getStrokeMiter());
-    }
- 
-    static void setStrokeMiter(JNIEnv* env, jobject paint, jfloat miter) {
-        NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setStrokeMiter(SkFloatToScalar(miter));
-    }
- 
-    static jint getStrokeCap(JNIEnv* env, jobject clazz, SkPaint* obj) {
-        return obj->getStrokeCap();
-    }
- 
-    static void setStrokeCap(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Cap cap) {
-        obj->setStrokeCap(cap);
-    }
- 
-    static jint getStrokeJoin(JNIEnv* env, jobject clazz, SkPaint* obj) {
-        return obj->getStrokeJoin();
-    }
- 
-    static void setStrokeJoin(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Join join) {
-        obj->setStrokeJoin(join);
-    }
- 
-    static jboolean getFillPath(JNIEnv* env, jobject clazz, SkPaint* obj, SkPath* src, SkPath* dst) {
-        return obj->getFillPath(*src, dst);
-    }
- 
-    static SkShader* setShader(JNIEnv* env, jobject clazz, SkPaint* obj, SkShader* shader) {
-        return obj->setShader(shader);
-    }
- 
-    static SkColorFilter* setColorFilter(JNIEnv* env, jobject clazz, SkPaint* obj, SkColorFilter* filter) {
-        return obj->setColorFilter(filter);
-    }
- 
-    static SkXfermode* setXfermode(JNIEnv* env, jobject clazz, SkPaint* obj, SkXfermode* xfermode) {
-        return obj->setXfermode(xfermode);
-    }
- 
-    static SkPathEffect* setPathEffect(JNIEnv* env, jobject clazz, SkPaint* obj, SkPathEffect* effect) {
-        return obj->setPathEffect(effect);
-    }
- 
-    static SkMaskFilter* setMaskFilter(JNIEnv* env, jobject clazz, SkPaint* obj, SkMaskFilter* maskfilter) {
-        return obj->setMaskFilter(maskfilter);
-    }
- 
-    static SkTypeface* setTypeface(JNIEnv* env, jobject clazz, SkPaint* obj, SkTypeface* typeface) {
-        return obj->setTypeface(typeface);
-    }
- 
-    static SkRasterizer* setRasterizer(JNIEnv* env, jobject clazz, SkPaint* obj, SkRasterizer* rasterizer) {
-        return obj->setRasterizer(rasterizer);
-    }
- 
-    static jint getTextAlign(JNIEnv* env, jobject clazz, SkPaint* obj) {
-        return obj->getTextAlign();
-    }
- 
-    static void setTextAlign(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Align align) {
-        obj->setTextAlign(align);
-    }
- 
-    static jfloat getTextSize(JNIEnv* env, jobject paint) {
-        NPE_CHECK_RETURN_ZERO(env, paint);
-        return SkScalarToFloat(GraphicsJNI::getNativePaint(env, paint)->getTextSize());
-    }
- 
-    static void setTextSize(JNIEnv* env, jobject paint, jfloat textSize) {
-        NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setTextSize(SkFloatToScalar(textSize));
-    }
- 
-    static jfloat getTextScaleX(JNIEnv* env, jobject paint) {
-        NPE_CHECK_RETURN_ZERO(env, paint);
-        return SkScalarToFloat(GraphicsJNI::getNativePaint(env, paint)->getTextScaleX());
-    }
- 
-    static void setTextScaleX(JNIEnv* env, jobject paint, jfloat scaleX) {
-        NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setTextScaleX(SkFloatToScalar(scaleX));
-    }
- 
-    static jfloat getTextSkewX(JNIEnv* env, jobject paint) {
-        NPE_CHECK_RETURN_ZERO(env, paint);
-        return SkScalarToFloat(GraphicsJNI::getNativePaint(env, paint)->getTextSkewX());
-    }
- 
-    static void setTextSkewX(JNIEnv* env, jobject paint, jfloat skewX) {
-        NPE_CHECK_RETURN_VOID(env, paint);
-        GraphicsJNI::getNativePaint(env, paint)->setTextSkewX(SkFloatToScalar(skewX));
-    }
- 
-    static jfloat ascent(JNIEnv* env, jobject paint) {
-        NPE_CHECK_RETURN_ZERO(env, paint);
-        SkPaint::FontMetrics    metrics;
-        (void)GraphicsJNI::getNativePaint(env, paint)->getFontMetrics(&metrics);
-        return SkScalarToFloat(metrics.fAscent);
-    }
- 
-    static jfloat descent(JNIEnv* env, jobject paint) {
-        NPE_CHECK_RETURN_ZERO(env, paint);
-        SkPaint::FontMetrics    metrics;
-        (void)GraphicsJNI::getNativePaint(env, paint)->getFontMetrics(&metrics);
-        return SkScalarToFloat(metrics.fDescent);
-    }
- 
-    static jfloat getFontMetrics(JNIEnv* env, jobject paint, jobject metricsObj) {
-        NPE_CHECK_RETURN_ZERO(env, paint);
-        SkPaint::FontMetrics metrics;
-        SkScalar             spacing = GraphicsJNI::getNativePaint(env, paint)->getFontMetrics(&metrics);
-
-        if (metricsObj) {
-            SkASSERT(env->IsInstanceOf(metricsObj, gFontMetrics_class));
-            env->SetFloatField(metricsObj, gFontMetrics_fieldID.top, SkScalarToFloat(metrics.fTop));
-            env->SetFloatField(metricsObj, gFontMetrics_fieldID.ascent, SkScalarToFloat(metrics.fAscent));
-            env->SetFloatField(metricsObj, gFontMetrics_fieldID.descent, SkScalarToFloat(metrics.fDescent));
-            env->SetFloatField(metricsObj, gFontMetrics_fieldID.bottom, SkScalarToFloat(metrics.fBottom));
-            env->SetFloatField(metricsObj, gFontMetrics_fieldID.leading, SkScalarToFloat(metrics.fLeading));
-        }
-        return SkScalarToFloat(spacing);
-    }
-    
-    static jint getFontMetricsInt(JNIEnv* env, jobject paint, jobject metricsObj) {
-        NPE_CHECK_RETURN_ZERO(env, paint);
-        SkPaint::FontMetrics metrics;
-        
-        GraphicsJNI::getNativePaint(env, paint)->getFontMetrics(&metrics);
-        int ascent = SkScalarRound(metrics.fAscent);
-        int descent = SkScalarRound(metrics.fDescent);
-        int leading = SkScalarRound(metrics.fLeading);
-
-        if (metricsObj) {
-            SkASSERT(env->IsInstanceOf(metricsObj, gFontMetricsInt_class));
-            env->SetIntField(metricsObj, gFontMetricsInt_fieldID.top, SkScalarFloor(metrics.fTop));
-            env->SetIntField(metricsObj, gFontMetricsInt_fieldID.ascent, ascent);
-            env->SetIntField(metricsObj, gFontMetricsInt_fieldID.descent, descent);
-            env->SetIntField(metricsObj, gFontMetricsInt_fieldID.bottom, SkScalarCeil(metrics.fBottom));
-            env->SetIntField(metricsObj, gFontMetricsInt_fieldID.leading, leading);
-        }
-        return descent - ascent + leading;
-    }
-
-    static jfloat measureText_CII(JNIEnv* env, jobject jpaint, jcharArray text, int index, int count) {
-        NPE_CHECK_RETURN_ZERO(env, jpaint);
-        NPE_CHECK_RETURN_ZERO(env, text);
-
-        size_t textLength = env->GetArrayLength(text);
-        
-        if ((index | count) < 0 || (size_t)(index + count) > textLength) {
-            doThrow(env, "java/lang/ArrayIndexOutOfBoundsException");
-            return 0;
-        }
-
-        const SkPaint* paint = GraphicsJNI::getNativePaint(env, jpaint);        
-        const jchar* textArray = env->GetCharArrayElements(text, NULL);
-        // we double count, since measureText wants a byteLength
-        SkScalar width = paint->measureText(textArray + index, count << 1);
-        env->ReleaseCharArrayElements(text, const_cast<jchar*>(textArray),
-                                      JNI_ABORT);
-
-        return SkScalarToFloat(width);
-    }
- 
-    static jfloat measureText_StringII(JNIEnv* env, jobject jpaint, jstring text, int start, int end) {
-        NPE_CHECK_RETURN_ZERO(env, jpaint);
-        NPE_CHECK_RETURN_ZERO(env, text);
-        
-        SkPaint* paint = GraphicsJNI::getNativePaint(env, jpaint);        
-        const jchar* textArray = env->GetStringChars(text, NULL);
-        size_t textLength = env->GetStringLength(text);
-        
-        int count = end - start;
-        if ((start | count) < 0 || (size_t)count > textLength) {
-            doThrow(env, "java/lang/IndexOutOfBoundsException");
-            return 0;
-        }
-        
-        jfloat width = SkScalarToFloat(paint->measureText(textArray + start, count << 1));
-        env->ReleaseStringChars(text, textArray);
-        return width;
-    }
-    
-    static jfloat measureText_String(JNIEnv* env, jobject jpaint, jstring text) {
-        NPE_CHECK_RETURN_ZERO(env, jpaint);
-        NPE_CHECK_RETURN_ZERO(env, text);
-        
-        SkPaint* paint = GraphicsJNI::getNativePaint(env, jpaint);        
-        const jchar* textArray = env->GetStringChars(text, NULL);
-        size_t textLength = env->GetStringLength(text);
-        
-        jfloat width = SkScalarToFloat(paint->measureText(textArray, textLength << 1));
-        env->ReleaseStringChars(text, textArray);
-        return width;
-    }
-    
-    static int dotextwidths(JNIEnv* env, SkPaint* paint, const jchar text[], int count, jfloatArray widths) {
-        AutoJavaFloatArray autoWidths(env, widths, count);
-        jfloat* widthsArray = autoWidths.ptr();
-        SkScalar* scalarArray = (SkScalar*)widthsArray;
-
-        count = paint->getTextWidths(text, count << 1, scalarArray);        
-        for (int i = 0; i < count; i++) {
-            widthsArray[i] = SkScalarToFloat(scalarArray[i]);
-        }
-        return count;
-    }
-    
-    static int getTextWidths___CII_F(JNIEnv* env, jobject clazz, SkPaint* paint, jcharArray text, int index, int count, jfloatArray widths) {
-        const jchar* textArray = env->GetCharArrayElements(text, NULL);
-        count = dotextwidths(env, paint, textArray + index, count, widths);
-        env->ReleaseCharArrayElements(text, const_cast<jchar*>(textArray),
-                                      JNI_ABORT);        
-        return count;
-    }
- 
-    static int getTextWidths__StringII_F(JNIEnv* env, jobject clazz, SkPaint* paint, jstring text, int start, int end, jfloatArray widths) {
-        const jchar* textArray = env->GetStringChars(text, NULL);
-        int count = dotextwidths(env, paint, textArray + start, end - start, widths);
-        env->ReleaseStringChars(text, textArray);
-        return count;
-    }
-    
-    static void getTextPath___CIIFFPath(JNIEnv* env, jobject clazz, SkPaint* paint, jcharArray text, int index, int count, jfloat x, jfloat y, SkPath* path) {
-        const jchar* textArray = env->GetCharArrayElements(text, NULL);
-        paint->getTextPath(textArray + index, count << 1, SkFloatToScalar(x), SkFloatToScalar(y), path);
-        env->ReleaseCharArrayElements(text, const_cast<jchar*>(textArray),
-                                      JNI_ABORT);
-    }
- 
-    static void getTextPath__StringIIFFPath(JNIEnv* env, jobject clazz, SkPaint* paint, jstring text, int start, int end, jfloat x, jfloat y, SkPath* path) {
-        const jchar* textArray = env->GetStringChars(text, NULL);
-        paint->getTextPath(textArray + start, (end - start) << 1, SkFloatToScalar(x), SkFloatToScalar(y), path);
-        env->ReleaseStringChars(text, textArray);
-    }
- 
-    static void setShadowLayer(JNIEnv* env, jobject jpaint, jfloat radius,
-                               jfloat dx, jfloat dy, int color) {
-        NPE_CHECK_RETURN_VOID(env, jpaint);
-        
-        SkPaint* paint = GraphicsJNI::getNativePaint(env, jpaint);        
-        if (radius <= 0) {
-            paint->setLooper(NULL);
-        }
-        else {
-            paint->setLooper(new SkBlurDrawLooper(SkFloatToScalar(radius),
-                                                  SkFloatToScalar(dx),
-                                                  SkFloatToScalar(dy),
-                                                  (SkColor)color))->unref();
-        }
-    }
-
-    static int breakText(JNIEnv* env, const SkPaint& paint, const jchar text[],
-                         int count, float maxWidth, jfloatArray jmeasured,
-                         SkPaint::TextBufferDirection tbd) {
-        SkASSERT(paint.getTextEncoding() == SkPaint::kUTF16_TextEncoding);
-
-        SkScalar     measured;
-        size_t       bytes = paint.breakText(text, count << 1,
-                                   SkFloatToScalar(maxWidth), &measured, tbd);
-        SkASSERT((bytes & 1) == 0);
-
-        if (jmeasured && env->GetArrayLength(jmeasured) > 0) {
-            AutoJavaFloatArray autoMeasured(env, jmeasured, 1);
-            jfloat* array = autoMeasured.ptr();
-            array[0] = SkScalarToFloat(measured);
-        }
-        return bytes >> 1;
-    }
-
-    static int breakTextC(JNIEnv* env, jobject jpaint, jcharArray jtext,
-            int index, int count, float maxWidth, jfloatArray jmeasuredWidth) {
-        NPE_CHECK_RETURN_ZERO(env, jpaint);
-        NPE_CHECK_RETURN_ZERO(env, jtext);
-
-        SkPaint::TextBufferDirection tbd;
-        if (count < 0) {
-            tbd = SkPaint::kBackward_TextBufferDirection;
-            count = -count;
-        }
-        else {
-            tbd = SkPaint::kForward_TextBufferDirection;
-        }
-
-        if ((index < 0) || (index + count > env->GetArrayLength(jtext))) {
-            doThrow(env, "java/lang/ArrayIndexOutOfBoundsException");
-            return 0;
-        }
-
-        SkPaint*     paint = GraphicsJNI::getNativePaint(env, jpaint);
-        const jchar* text = env->GetCharArrayElements(jtext, NULL);
-        count = breakText(env, *paint, text + index, count, maxWidth,
-                          jmeasuredWidth, tbd);
-        env->ReleaseCharArrayElements(jtext, const_cast<jchar*>(text),
-                                      JNI_ABORT);
-        return count;
-    }
-
-    static int breakTextS(JNIEnv* env, jobject jpaint, jstring jtext,
-                bool forwards, float maxWidth, jfloatArray jmeasuredWidth) {
-        NPE_CHECK_RETURN_ZERO(env, jpaint);
-        NPE_CHECK_RETURN_ZERO(env, jtext);
-
-        SkPaint::TextBufferDirection tbd = forwards ?
-                                        SkPaint::kForward_TextBufferDirection :
-                                        SkPaint::kBackward_TextBufferDirection;
-
-        SkPaint* paint = GraphicsJNI::getNativePaint(env, jpaint);
-        int count = env->GetStringLength(jtext);
-        const jchar* text = env->GetStringChars(jtext, NULL);
-        count = breakText(env, *paint, text, count, maxWidth,
-                          jmeasuredWidth, tbd);
-        env->ReleaseStringChars(jtext, text);
-        return count;
-    }
-
-    static void doTextBounds(JNIEnv* env, const jchar* text, int count,
-                             jobject bounds, const SkPaint& paint)
-    {
-        SkRect  r;
-        SkIRect ir;
-        
-        paint.measureText(text, count << 1, &r);
-        r.roundOut(&ir);
-        GraphicsJNI::irect_to_jrect(ir, env, bounds);
-    }
-
-    static void getStringBounds(JNIEnv* env, jobject, const SkPaint* paint,
-                                jstring text, int start, int end, jobject bounds)
-    {
-        const jchar* textArray = env->GetStringChars(text, NULL);
-        doTextBounds(env, textArray + start, end - start, bounds, *paint);
-        env->ReleaseStringChars(text, textArray);
-    }
-    
-    static void getCharArrayBounds(JNIEnv* env, jobject, const SkPaint* paint,
-                        jcharArray text, int index, int count, jobject bounds)
-    {
-        const jchar* textArray = env->GetCharArrayElements(text, NULL);
-        doTextBounds(env, textArray + index, count, bounds, *paint);
-        env->ReleaseCharArrayElements(text, const_cast<jchar*>(textArray),
-                                      JNI_ABORT);
-    }
-    
-};
-
-static JNINativeMethod methods[] = {
-    {"finalizer", "(I)V", (void*) SkPaintGlue::finalizer},
-    {"native_init","()I", (void*) SkPaintGlue::init},
-    {"native_initWithPaint","(I)I", (void*) SkPaintGlue::intiWithPaint},
-    {"native_reset","(I)V", (void*) SkPaintGlue::reset},
-    {"native_set","(II)V", (void*) SkPaintGlue::assign},
-    {"getFlags","()I", (void*) SkPaintGlue::getFlags},
-    {"setFlags","(I)V", (void*) SkPaintGlue::setFlags},
-    {"setAntiAlias","(Z)V", (void*) SkPaintGlue::setAntiAlias},
-    {"setSubpixelText","(Z)V", (void*) SkPaintGlue::setSubpixelText},
-    {"setLinearText","(Z)V", (void*) SkPaintGlue::setLinearText},
-    {"setUnderlineText","(Z)V", (void*) SkPaintGlue::setUnderlineText},
-    {"setStrikeThruText","(Z)V", (void*) SkPaintGlue::setStrikeThruText},
-    {"setFakeBoldText","(Z)V", (void*) SkPaintGlue::setFakeBoldText},
-    {"setFilterBitmap","(Z)V", (void*) SkPaintGlue::setFilterBitmap},
-    {"setDither","(Z)V", (void*) SkPaintGlue::setDither},
-    {"native_getStyle","(I)I", (void*) SkPaintGlue::getStyle},
-    {"native_setStyle","(II)V", (void*) SkPaintGlue::setStyle},
-    {"getColor","()I", (void*) SkPaintGlue::getColor},
-    {"setColor","(I)V", (void*) SkPaintGlue::setColor},
-    {"getAlpha","()I", (void*) SkPaintGlue::getAlpha},
-    {"setAlpha","(I)V", (void*) SkPaintGlue::setAlpha},
-    {"getStrokeWidth","()F", (void*) SkPaintGlue::getStrokeWidth},
-    {"setStrokeWidth","(F)V", (void*) SkPaintGlue::setStrokeWidth},
-    {"getStrokeMiter","()F", (void*) SkPaintGlue::getStrokeMiter},
-    {"setStrokeMiter","(F)V", (void*) SkPaintGlue::setStrokeMiter},
-    {"native_getStrokeCap","(I)I", (void*) SkPaintGlue::getStrokeCap},
-    {"native_setStrokeCap","(II)V", (void*) SkPaintGlue::setStrokeCap},
-    {"native_getStrokeJoin","(I)I", (void*) SkPaintGlue::getStrokeJoin},
-    {"native_setStrokeJoin","(II)V", (void*) SkPaintGlue::setStrokeJoin},
-    {"native_getFillPath","(III)Z", (void*) SkPaintGlue::getFillPath},
-    {"native_setShader","(II)I", (void*) SkPaintGlue::setShader},
-    {"native_setColorFilter","(II)I", (void*) SkPaintGlue::setColorFilter},
-    {"native_setXfermode","(II)I", (void*) SkPaintGlue::setXfermode},
-    {"native_setPathEffect","(II)I", (void*) SkPaintGlue::setPathEffect},
-    {"native_setMaskFilter","(II)I", (void*) SkPaintGlue::setMaskFilter},
-    {"native_setTypeface","(II)I", (void*) SkPaintGlue::setTypeface},
-    {"native_setRasterizer","(II)I", (void*) SkPaintGlue::setRasterizer},
-    {"native_getTextAlign","(I)I", (void*) SkPaintGlue::getTextAlign},
-    {"native_setTextAlign","(II)V", (void*) SkPaintGlue::setTextAlign},
-    {"getTextSize","()F", (void*) SkPaintGlue::getTextSize},
-    {"setTextSize","(F)V", (void*) SkPaintGlue::setTextSize},
-    {"getTextScaleX","()F", (void*) SkPaintGlue::getTextScaleX},
-    {"setTextScaleX","(F)V", (void*) SkPaintGlue::setTextScaleX},
-    {"getTextSkewX","()F", (void*) SkPaintGlue::getTextSkewX},
-    {"setTextSkewX","(F)V", (void*) SkPaintGlue::setTextSkewX},
-    {"ascent","()F", (void*) SkPaintGlue::ascent},
-    {"descent","()F", (void*) SkPaintGlue::descent},
-    {"getFontMetrics", "(Landroid/graphics/Paint$FontMetrics;)F", (void*)SkPaintGlue::getFontMetrics},
-    {"getFontMetricsInt", "(Landroid/graphics/Paint$FontMetricsInt;)I", (void*)SkPaintGlue::getFontMetricsInt},
-    {"measureText","([CII)F", (void*) SkPaintGlue::measureText_CII},
-    {"measureText","(Ljava/lang/String;)F", (void*) SkPaintGlue::measureText_String},
-    {"measureText","(Ljava/lang/String;II)F", (void*) SkPaintGlue::measureText_StringII},
-    {"breakText","([CIIF[F)I", (void*) SkPaintGlue::breakTextC},
-    {"breakText","(Ljava/lang/String;ZF[F)I", (void*) SkPaintGlue::breakTextS},
-    {"native_getTextWidths","(I[CII[F)I", (void*) SkPaintGlue::getTextWidths___CII_F},
-    {"native_getTextWidths","(ILjava/lang/String;II[F)I", (void*) SkPaintGlue::getTextWidths__StringII_F},
-    {"native_getTextPath","(I[CIIFFI)V", (void*) SkPaintGlue::getTextPath___CIIFFPath},
-    {"native_getTextPath","(ILjava/lang/String;IIFFI)V", (void*) SkPaintGlue::getTextPath__StringIIFFPath},
-    {"nativeGetStringBounds", "(ILjava/lang/String;IILandroid/graphics/Rect;)V",
-                                        (void*) SkPaintGlue::getStringBounds },
-    {"nativeGetCharArrayBounds", "(I[CIILandroid/graphics/Rect;)V",
-                                    (void*) SkPaintGlue::getCharArrayBounds },
-    {"setShadowLayer", "(FFFI)V", (void*)SkPaintGlue::setShadowLayer}
-};
-
-static jfieldID req_fieldID(jfieldID id) {
-    SkASSERT(id);
-    return id;
-}
-
-int register_android_graphics_Paint(JNIEnv* env) {
-    gFontMetrics_class = env->FindClass("android/graphics/Paint$FontMetrics");
-    SkASSERT(gFontMetrics_class);
-    gFontMetrics_class = (jclass)env->NewGlobalRef(gFontMetrics_class);
-
-    gFontMetrics_fieldID.top = req_fieldID(env->GetFieldID(gFontMetrics_class, "top", "F"));
-    gFontMetrics_fieldID.ascent = req_fieldID(env->GetFieldID(gFontMetrics_class, "ascent", "F"));
-    gFontMetrics_fieldID.descent = req_fieldID(env->GetFieldID(gFontMetrics_class, "descent", "F"));
-    gFontMetrics_fieldID.bottom = req_fieldID(env->GetFieldID(gFontMetrics_class, "bottom", "F"));
-    gFontMetrics_fieldID.leading = req_fieldID(env->GetFieldID(gFontMetrics_class, "leading", "F"));
-
-    gFontMetricsInt_class = env->FindClass("android/graphics/Paint$FontMetricsInt");
-    SkASSERT(gFontMetricsInt_class);
-    gFontMetricsInt_class = (jclass)env->NewGlobalRef(gFontMetricsInt_class);
-
-    gFontMetricsInt_fieldID.top = req_fieldID(env->GetFieldID(gFontMetricsInt_class, "top", "I"));
-    gFontMetricsInt_fieldID.ascent = req_fieldID(env->GetFieldID(gFontMetricsInt_class, "ascent", "I"));
-    gFontMetricsInt_fieldID.descent = req_fieldID(env->GetFieldID(gFontMetricsInt_class, "descent", "I"));
-    gFontMetricsInt_fieldID.bottom = req_fieldID(env->GetFieldID(gFontMetricsInt_class, "bottom", "I"));
-    gFontMetricsInt_fieldID.leading = req_fieldID(env->GetFieldID(gFontMetricsInt_class, "leading", "I"));
-
-    int result = AndroidRuntime::registerNativeMethods(env, "android/graphics/Paint", methods,
-        sizeof(methods) / sizeof(methods[0]));
-    return result;
-}
-
-}
diff --git a/core/jni/android/graphics/Path.cpp b/core/jni/android/graphics/Path.cpp
deleted file mode 100644
index effb1c8..0000000
--- a/core/jni/android/graphics/Path.cpp
+++ /dev/null
@@ -1,306 +0,0 @@
-/* libs/android_runtime/android/graphics/Path.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
-**
-**     http://www.apache.org/licenses/LICENSE-2.0 
-**
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
-** limitations under the License.
-*/
-
-// This file was generated from the C++ include file: SkPath.h
-// Any changes made to this file will be discarded by the build.
-// To change this file, either edit the include, or device/tools/gluemaker/main.cpp, 
-// or one of the auxilary file specifications in device/tools/gluemaker.
-
-#include "jni.h"
-#include "GraphicsJNI.h"
-#include <android_runtime/AndroidRuntime.h>
-
-#include "SkPath.h"
-
-namespace android {
-
-class SkPathGlue {
-public:
-
-    static void finalizer(JNIEnv* env, jobject clazz, SkPath* obj) {
-        delete obj;
-    }
-
-    static SkPath* init1(JNIEnv* env, jobject clazz) {
-        return new SkPath();
-    }
- 
-    static SkPath* init2(JNIEnv* env, jobject clazz, SkPath* val) {
-        return new SkPath(*val);
-    }
- 
-    static void reset(JNIEnv* env, jobject clazz, SkPath* obj) {
-        obj->reset();
-    }
-
-    static void rewind(JNIEnv* env, jobject clazz, SkPath* obj) {
-        obj->rewind();
-    }
-
-    static void assign(JNIEnv* env, jobject clazz, SkPath* dst, const SkPath* src) {
-        *dst = *src;
-    }
- 
-    static jint getFillType(JNIEnv* env, jobject clazz, SkPath* obj) {
-        return obj->getFillType();
-    }
- 
-    static void setFillType(JNIEnv* env, jobject clazz, SkPath* path,
-                            SkPath::FillType ft) {
-        path->setFillType(ft);
-    }
- 
-    static jboolean isEmpty(JNIEnv* env, jobject clazz, SkPath* obj) {
-        return obj->isEmpty();
-    }
- 
-    static jboolean isRect(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect) {
-        SkRect rect_;
-        jboolean result = obj->isRect(&rect_);
-        GraphicsJNI::rect_to_jrectf(rect_, env, rect);
-        return result;
-    }
- 
-    static void computeBounds(JNIEnv* env, jobject clazz, SkPath* obj, jobject bounds, SkPath::BoundsType btype) {
-        SkRect bounds_;
-        obj->computeBounds(&bounds_, btype);
-        GraphicsJNI::rect_to_jrectf(bounds_, env, bounds);
-    }
- 
-    static void incReserve(JNIEnv* env, jobject clazz, SkPath* obj, jint extraPtCount) {
-        obj->incReserve(extraPtCount);
-    }
- 
-    static void moveTo__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y) {
-        SkScalar x_ = SkFloatToScalar(x);
-        SkScalar y_ = SkFloatToScalar(y);
-        obj->moveTo(x_, y_);
-    }
- 
-    static void rMoveTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) {
-        SkScalar dx_ = SkFloatToScalar(dx);
-        SkScalar dy_ = SkFloatToScalar(dy);
-        obj->rMoveTo(dx_, dy_);
-    }
- 
-    static void lineTo__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y) {
-        SkScalar x_ = SkFloatToScalar(x);
-        SkScalar y_ = SkFloatToScalar(y);
-        obj->lineTo(x_, y_);
-    }
- 
-    static void rLineTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) {
-        SkScalar dx_ = SkFloatToScalar(dx);
-        SkScalar dy_ = SkFloatToScalar(dy);
-        obj->rLineTo(dx_, dy_);
-    }
- 
-    static void quadTo__FFFF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2) {
-        SkScalar x1_ = SkFloatToScalar(x1);
-        SkScalar y1_ = SkFloatToScalar(y1);
-        SkScalar x2_ = SkFloatToScalar(x2);
-        SkScalar y2_ = SkFloatToScalar(y2);
-        obj->quadTo(x1_, y1_, x2_, y2_);
-    }
- 
-    static void rQuadTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx1, jfloat dy1, jfloat dx2, jfloat dy2) {
-        SkScalar dx1_ = SkFloatToScalar(dx1);
-        SkScalar dy1_ = SkFloatToScalar(dy1);
-        SkScalar dx2_ = SkFloatToScalar(dx2);
-        SkScalar dy2_ = SkFloatToScalar(dy2);
-        obj->rQuadTo(dx1_, dy1_, dx2_, dy2_);
-    }
- 
-    static void cubicTo__FFFFFF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) {
-        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_);
-    }
- 
-    static void rCubicTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) {
-        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_);
-    }
- 
-    static void arcTo(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, jfloat startAngle, jfloat sweepAngle, jboolean forceMoveTo) {
-        SkRect oval_;
-        GraphicsJNI::jrectf_to_rect(env, oval, &oval_);
-        SkScalar startAngle_ = SkFloatToScalar(startAngle);
-        SkScalar sweepAngle_ = SkFloatToScalar(sweepAngle);
-        obj->arcTo(oval_, startAngle_, sweepAngle_, forceMoveTo);
-    }
- 
-    static void close(JNIEnv* env, jobject clazz, SkPath* obj) {
-        obj->close();
-    }
- 
-    static void addRect__RectFI(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect, SkPath::Direction dir) {
-        SkRect rect_;
-        GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
-        obj->addRect(rect_, dir);
-    }
- 
-    static void addRect__FFFFI(JNIEnv* env, jobject clazz, SkPath* obj, jfloat left, jfloat top, jfloat right, jfloat bottom, SkPath::Direction dir) {
-        SkScalar left_ = SkFloatToScalar(left);
-        SkScalar top_ = SkFloatToScalar(top);
-        SkScalar right_ = SkFloatToScalar(right);
-        SkScalar bottom_ = SkFloatToScalar(bottom);
-        obj->addRect(left_, top_, right_, bottom_, dir);
-    }
- 
-    static void addOval(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, SkPath::Direction dir) {
-        SkRect oval_;
-        GraphicsJNI::jrectf_to_rect(env, oval, &oval_);
-        obj->addOval(oval_, dir);
-    }
- 
-    static void addCircle(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y, jfloat radius, SkPath::Direction dir) {
-        SkScalar x_ = SkFloatToScalar(x);
-        SkScalar y_ = SkFloatToScalar(y);
-        SkScalar radius_ = SkFloatToScalar(radius);
-        obj->addCircle(x_, y_, radius_, dir);
-    }
- 
-    static void addArc(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, jfloat startAngle, jfloat sweepAngle) {
-        SkRect oval_;
-        GraphicsJNI::jrectf_to_rect(env, oval, &oval_);
-        SkScalar startAngle_ = SkFloatToScalar(startAngle);
-        SkScalar sweepAngle_ = SkFloatToScalar(sweepAngle);
-        obj->addArc(oval_, startAngle_, sweepAngle_);
-    }
- 
-    static void addRoundRectXY(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect,
-                               jfloat rx, jfloat ry, SkPath::Direction dir) {
-        SkRect rect_;
-        GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
-        SkScalar rx_ = SkFloatToScalar(rx);
-        SkScalar ry_ = SkFloatToScalar(ry);
-        obj->addRoundRect(rect_, rx_, ry_, dir);
-    }
-    
-    static void addRoundRect8(JNIEnv* env, jobject, SkPath* obj, jobject rect,
-                              jfloatArray array, SkPath::Direction dir) {
-        SkRect rect_;
-        GraphicsJNI::jrectf_to_rect(env, rect, &rect_);
-        AutoJavaFloatArray  afa(env, array, 8);
-        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);
-    }
-    
-    static void addPath__PathFF(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src, jfloat dx, jfloat dy) {
-        SkScalar dx_ = SkFloatToScalar(dx);
-        SkScalar dy_ = SkFloatToScalar(dy);
-        obj->addPath(*src, dx_, dy_);
-    }
- 
-    static void addPath__Path(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src) {
-        obj->addPath(*src);
-    }
- 
-    static void addPath__PathMatrix(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src, SkMatrix* matrix) {
-        obj->addPath(*src, *matrix);
-    }
- 
-    static void offset__FFPath(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy, SkPath* dst) {
-        SkScalar dx_ = SkFloatToScalar(dx);
-        SkScalar dy_ = SkFloatToScalar(dy);
-        obj->offset(dx_, dy_, dst);
-    }
- 
-    static void offset__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) {
-        SkScalar dx_ = SkFloatToScalar(dx);
-        SkScalar dy_ = SkFloatToScalar(dy);
-        obj->offset(dx_, dy_);
-    }
-
-    static void setLastPoint(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) {
-        SkScalar dx_ = SkFloatToScalar(dx);
-        SkScalar dy_ = SkFloatToScalar(dy);
-        obj->setLastPt(dx_, dy_);
-    }
- 
-    static void transform__MatrixPath(JNIEnv* env, jobject clazz, SkPath* obj, SkMatrix* matrix, SkPath* dst) {
-        obj->transform(*matrix, dst);
-    }
- 
-    static void transform__Matrix(JNIEnv* env, jobject clazz, SkPath* obj, SkMatrix* matrix) {
-        obj->transform(*matrix);
-    }
- 
-};
-
-static JNINativeMethod methods[] = {
-    {"finalizer", "(I)V", (void*) SkPathGlue::finalizer},
-    {"init1","()I", (void*) SkPathGlue::init1},
-    {"init2","(I)I", (void*) SkPathGlue::init2},
-    {"native_reset","(I)V", (void*) SkPathGlue::reset},
-    {"native_rewind","(I)V", (void*) SkPathGlue::rewind},
-    {"native_set","(II)V", (void*) SkPathGlue::assign},
-    {"native_getFillType","(I)I", (void*) SkPathGlue::getFillType},
-    {"native_setFillType","(II)V", (void*) SkPathGlue::setFillType},
-    {"native_isEmpty","(I)Z", (void*) SkPathGlue::isEmpty},
-    {"native_isRect","(ILandroid/graphics/RectF;)Z", (void*) SkPathGlue::isRect},
-    {"native_computeBounds","(ILandroid/graphics/RectF;I)V", (void*) SkPathGlue::computeBounds},
-    {"native_incReserve","(II)V", (void*) SkPathGlue::incReserve},
-    {"native_moveTo","(IFF)V", (void*) SkPathGlue::moveTo__FF},
-    {"native_rMoveTo","(IFF)V", (void*) SkPathGlue::rMoveTo},
-    {"native_lineTo","(IFF)V", (void*) SkPathGlue::lineTo__FF},
-    {"native_rLineTo","(IFF)V", (void*) SkPathGlue::rLineTo},
-    {"native_quadTo","(IFFFF)V", (void*) SkPathGlue::quadTo__FFFF},
-    {"native_rQuadTo","(IFFFF)V", (void*) SkPathGlue::rQuadTo},
-    {"native_cubicTo","(IFFFFFF)V", (void*) SkPathGlue::cubicTo__FFFFFF},
-    {"native_rCubicTo","(IFFFFFF)V", (void*) SkPathGlue::rCubicTo},
-    {"native_arcTo","(ILandroid/graphics/RectF;FFZ)V", (void*) SkPathGlue::arcTo},
-    {"native_close","(I)V", (void*) SkPathGlue::close},
-    {"native_addRect","(ILandroid/graphics/RectF;I)V", (void*) SkPathGlue::addRect__RectFI},
-    {"native_addRect","(IFFFFI)V", (void*) SkPathGlue::addRect__FFFFI},
-    {"native_addOval","(ILandroid/graphics/RectF;I)V", (void*) SkPathGlue::addOval},
-    {"native_addCircle","(IFFFI)V", (void*) SkPathGlue::addCircle},
-    {"native_addArc","(ILandroid/graphics/RectF;FF)V", (void*) SkPathGlue::addArc},
-    {"native_addRoundRect","(ILandroid/graphics/RectF;FFI)V", (void*) SkPathGlue::addRoundRectXY},
-    {"native_addRoundRect","(ILandroid/graphics/RectF;[FI)V", (void*) SkPathGlue::addRoundRect8},
-    {"native_addPath","(IIFF)V", (void*) SkPathGlue::addPath__PathFF},
-    {"native_addPath","(II)V", (void*) SkPathGlue::addPath__Path},
-    {"native_addPath","(III)V", (void*) SkPathGlue::addPath__PathMatrix},
-    {"native_offset","(IFFI)V", (void*) SkPathGlue::offset__FFPath},
-    {"native_offset","(IFF)V", (void*) SkPathGlue::offset__FF},
-    {"native_setLastPoint","(IFF)V", (void*) SkPathGlue::setLastPoint},
-    {"native_transform","(III)V", (void*) SkPathGlue::transform__MatrixPath},
-    {"native_transform","(II)V", (void*) SkPathGlue::transform__Matrix}
-};
-
-int register_android_graphics_Path(JNIEnv* env) {
-    int result = AndroidRuntime::registerNativeMethods(env, "android/graphics/Path", methods,
-        sizeof(methods) / sizeof(methods[0]));
-    return result;
-}
-
-}
diff --git a/core/jni/android/graphics/PathEffect.cpp b/core/jni/android/graphics/PathEffect.cpp
deleted file mode 100644
index 0ecb004..0000000
--- a/core/jni/android/graphics/PathEffect.cpp
+++ /dev/null
@@ -1,113 +0,0 @@
-#include <jni.h>
-#include "GraphicsJNI.h"
-
-#include "SkPathEffect.h"
-#include "SkCornerPathEffect.h"
-#include "SkDashPathEffect.h"
-#include "SkDiscretePathEffect.h"
-#include "Sk1DPathEffect.h"
-#include "SkTemplates.h"
-
-class SkPathEffectGlue {
-public:
-
-    static void destructor(JNIEnv* env, jobject, SkPathEffect* effect) {
-        effect->safeUnref();
-    }
-
-    static SkPathEffect* Compose_constructor(JNIEnv* env, jobject,
-                                   SkPathEffect* outer, SkPathEffect* inner) {
-        return new SkComposePathEffect(outer, inner);
-    }
-    
-    static SkPathEffect* Sum_constructor(JNIEnv* env, jobject,
-                                  SkPathEffect* first, SkPathEffect* second) {
-        return new SkSumPathEffect(first, second);
-    }
-    
-    static SkPathEffect* Dash_constructor(JNIEnv* env, jobject,
-                                      jfloatArray intervalArray, float 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]);
-        }
-        return new SkDashPathEffect(intervals, count, SkFloatToScalar(phase));
-    }
- 
-    static SkPathEffect* OneD_constructor(JNIEnv* env, jobject,
-                  const SkPath* shape, float advance, float phase, int style) {
-        SkASSERT(shape != NULL);
-        return new SkPath1DPathEffect(*shape, SkFloatToScalar(advance),
-                     SkFloatToScalar(phase), (SkPath1DPathEffect::Style)style);
-    }
-    
-    static SkPathEffect* Corner_constructor(JNIEnv* env, jobject, float radius){
-        return new SkCornerPathEffect(SkFloatToScalar(radius));
-    }
-    
-    static SkPathEffect* Discrete_constructor(JNIEnv* env, jobject,
-                                              float length, float deviation) {
-        return new SkDiscretePathEffect(SkFloatToScalar(length),
-                                        SkFloatToScalar(deviation));
-    }
-    
-};
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-static JNINativeMethod gPathEffectMethods[] = {
-    { "nativeDestructor", "(I)V", (void*)SkPathEffectGlue::destructor }
-};
-
-static JNINativeMethod gComposePathEffectMethods[] = {
-    { "nativeCreate", "(II)I", (void*)SkPathEffectGlue::Compose_constructor }
-};
-
-static JNINativeMethod gSumPathEffectMethods[] = {
-    { "nativeCreate", "(II)I", (void*)SkPathEffectGlue::Sum_constructor }
-};
-
-static JNINativeMethod gDashPathEffectMethods[] = {
-    { "nativeCreate", "([FF)I", (void*)SkPathEffectGlue::Dash_constructor }
-};
-
-static JNINativeMethod gPathDashPathEffectMethods[] = {
-    { "nativeCreate", "(IFFI)I", (void*)SkPathEffectGlue::OneD_constructor }
-};
-
-static JNINativeMethod gCornerPathEffectMethods[] = {
-    { "nativeCreate", "(F)I", (void*)SkPathEffectGlue::Corner_constructor }
-};
-
-static JNINativeMethod gDiscretePathEffectMethods[] = {
-    { "nativeCreate", "(FF)I", (void*)SkPathEffectGlue::Discrete_constructor }
-};
-
-#include <android_runtime/AndroidRuntime.h>
-
-#define REG(env, name, array)                                              \
-    result = android::AndroidRuntime::registerNativeMethods(env, name, array, \
-                                                  SK_ARRAY_COUNT(array));  \
-    if (result < 0) return result
-
-int register_android_graphics_PathEffect(JNIEnv* env);
-int register_android_graphics_PathEffect(JNIEnv* env)
-{
-    int result;
-    
-    REG(env, "android/graphics/PathEffect", gPathEffectMethods);
-    REG(env, "android/graphics/ComposePathEffect", gComposePathEffectMethods);
-    REG(env, "android/graphics/SumPathEffect", gSumPathEffectMethods);
-    REG(env, "android/graphics/DashPathEffect", gDashPathEffectMethods);
-    REG(env, "android/graphics/PathDashPathEffect", gPathDashPathEffectMethods);
-    REG(env, "android/graphics/CornerPathEffect", gCornerPathEffectMethods);
-    REG(env, "android/graphics/DiscretePathEffect", gDiscretePathEffectMethods);
-    
-    return 0;
-}
-
diff --git a/core/jni/android/graphics/PathMeasure.cpp b/core/jni/android/graphics/PathMeasure.cpp
deleted file mode 100644
index 51a3f3a..0000000
--- a/core/jni/android/graphics/PathMeasure.cpp
+++ /dev/null
@@ -1,138 +0,0 @@
-/* libs/android_runtime/android/graphics/PathMeasure.cpp
-**
-** Copyright 2007, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
-**
-**     http://www.apache.org/licenses/LICENSE-2.0 
-**
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
-** limitations under the License.
-*/
-
-#include "jni.h"
-#include "GraphicsJNI.h"
-#include <android_runtime/AndroidRuntime.h>
-
-#include "SkPathMeasure.h"
-
-/*  We declare an explicit pair, so that we don't have to rely on the java
-    client to be sure not to edit the path while we have an active measure
-    object associated with it.
- 
-    This costs us the copy of the path, for the sake of not allowing a bad
-    java client to randomly crash (since we can't detect the case where the
-    native path has been modified).
- 
-    The C side does have this risk, but it chooses for speed over safety. If it
-    later changes this, and is internally safe from changes to the path, then
-    we can remove this explicit copy from our JNI code.
- 
-    Note that we do not have a reference on the java side to the java path.
-    Were we to not need the native copy here, we would want to add a java
-    reference, so that the java path would not get GD'd while the measure object
-    was still alive.
-*/
-struct PathMeasurePair {
-    PathMeasurePair() {}
-    PathMeasurePair(const SkPath& path, bool forceClosed)
-        : fPath(path), fMeasure(fPath, forceClosed) {}
-
-    SkPath          fPath;      // copy of the user's path
-    SkPathMeasure   fMeasure;   // this guy points to fPath
-};
-
-namespace android {
-    
-class SkPathMeasureGlue {
-public:
-
-    static PathMeasurePair* create(JNIEnv* env, jobject clazz, const SkPath* path, jboolean forceClosed) {
-        return path ? new PathMeasurePair(*path, forceClosed) : new PathMeasurePair;
-    }
- 
-    static void setPath(JNIEnv* env, jobject clazz, PathMeasurePair* pair, const SkPath* path, jboolean forceClosed) {
-        if (NULL == path) {
-            pair->fPath.reset();
-        } else {
-            pair->fPath = *path;
-        }
-        pair->fMeasure.setPath(&pair->fPath, forceClosed);
-    }
- 
-    static jfloat getLength(JNIEnv* env, jobject clazz, PathMeasurePair* pair) {
-        return SkScalarToFloat(pair->fMeasure.getLength());
-    }
- 
-    static void convertTwoElemFloatArray(JNIEnv* env, jfloatArray array, const SkScalar src[2]) {
-        AutoJavaFloatArray autoArray(env, array, 2);
-        jfloat* ptr = autoArray.ptr();
-        ptr[0] = SkScalarToFloat(src[0]);
-        ptr[1] = SkScalarToFloat(src[1]);
-    }
-
-    static jboolean getPosTan(JNIEnv* env, jobject clazz, PathMeasurePair* pair, jfloat dist, jfloatArray pos, jfloatArray tan) {
-        SkScalar    tmpPos[2], tmpTan[2];
-        SkScalar*   posPtr = pos ? tmpPos : NULL;
-        SkScalar*   tanPtr = tan ? tmpTan : NULL;
-        
-        if (!pair->fMeasure.getPosTan(SkFloatToScalar(dist), (SkPoint*)posPtr, (SkVector*)tanPtr)) {
-            return false;
-        }
-    
-        if (pos) {
-            convertTwoElemFloatArray(env, pos, tmpPos);
-        }
-        if (tan) {
-            convertTwoElemFloatArray(env, tan, tmpTan);
-        }
-        return true;
-    }
- 
-    static jboolean getMatrix(JNIEnv* env, jobject clazz, PathMeasurePair* pair, jfloat dist,
-                          SkMatrix* matrix, int flags) {
-        return pair->fMeasure.getMatrix(SkFloatToScalar(dist), matrix, (SkPathMeasure::MatrixFlags)flags);
-    }
- 
-    static jboolean getSegment(JNIEnv* env, jobject clazz, PathMeasurePair* pair, jfloat startF,
-                               jfloat stopF, SkPath* dst, jboolean startWithMoveTo) {
-        return pair->fMeasure.getSegment(SkFloatToScalar(startF), SkFloatToScalar(stopF), dst, startWithMoveTo);
-    }
- 
-    static jboolean isClosed(JNIEnv* env, jobject clazz, PathMeasurePair* pair) {
-        return pair->fMeasure.isClosed();
-    }
- 
-    static jboolean nextContour(JNIEnv* env, jobject clazz, PathMeasurePair* pair) {
-        return pair->fMeasure.nextContour();
-    }
- 
-    static void destroy(JNIEnv* env, jobject clazz, PathMeasurePair* pair) {
-        delete pair;
-    } 
-};
-
-static JNINativeMethod methods[] = {
-    {"native_create",       "(IZ)I",        (void*) SkPathMeasureGlue::create      },
-    {"native_setPath",      "(IIZ)V",       (void*) SkPathMeasureGlue::setPath     },
-    {"native_getLength",    "(I)F",         (void*) SkPathMeasureGlue::getLength   },
-    {"native_getPosTan",    "(IF[F[F)Z",    (void*) SkPathMeasureGlue::getPosTan   },
-    {"native_getMatrix",    "(IFII)Z",      (void*) SkPathMeasureGlue::getMatrix   },
-    {"native_getSegment",   "(IFFIZ)Z",     (void*) SkPathMeasureGlue::getSegment  },
-    {"native_isClosed",     "(I)Z",         (void*) SkPathMeasureGlue::isClosed    },
-    {"native_nextContour",  "(I)Z",         (void*) SkPathMeasureGlue::nextContour },
-    {"native_destroy",      "(I)V",         (void*) SkPathMeasureGlue::destroy     }
-};
-
-int register_android_graphics_PathMeasure(JNIEnv* env) {
-    int result = AndroidRuntime::registerNativeMethods(env, "android/graphics/PathMeasure", methods,
-        sizeof(methods) / sizeof(methods[0]));
-    return result;
-}
-
-}
diff --git a/core/jni/android/graphics/Picture.cpp b/core/jni/android/graphics/Picture.cpp
deleted file mode 100644
index 5ab6dd3..0000000
--- a/core/jni/android/graphics/Picture.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Copyright (C) 2008 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "jni.h"
-#include "GraphicsJNI.h"
-#include <android_runtime/AndroidRuntime.h>
-
-#include "SkCanvas.h"
-#include "SkPicture.h"
-#include "SkTemplates.h"
-#include "CreateJavaOutputStreamAdaptor.h"
-
-namespace android {
-
-class SkPictureGlue {
-public:
-    static SkPicture* newPicture(JNIEnv* env, jobject, const SkPicture* src) {
-        if (src) {
-            return new SkPicture(*src);
-        } else {
-            return new SkPicture;
-        }
-    }
-    
-    static SkPicture* deserialize(JNIEnv* env, jobject, jobject jstream,
-                                  jbyteArray jstorage) {
-        SkPicture* picture = NULL;
-        SkStream* strm = CreateJavaInputStreamAdaptor(env, jstream, jstorage);
-        if (strm) {
-            picture = new SkPicture(strm);
-            delete strm;
-        }
-        return picture;
-    }
-    
-    static void killPicture(JNIEnv* env, jobject, SkPicture* picture) {
-        SkASSERT(picture);
-        delete picture;
-    }
-    
-    static void draw(JNIEnv* env, jobject, SkCanvas* canvas,
-                            SkPicture* picture) {
-        SkASSERT(canvas);
-        SkASSERT(picture);
-        picture->draw(canvas);
-    }
-    
-    static bool serialize(JNIEnv* env, jobject, SkPicture* picture,
-                          jobject jstream, jbyteArray jstorage) {
-        SkWStream* strm = CreateJavaOutputStreamAdaptor(env, jstream, jstorage);
-        
-        if (NULL != strm) {
-            picture->serialize(strm);
-            delete strm;
-            return true;
-        }
-        return false;
-    }
-        
-    static int getWidth(JNIEnv* env, jobject jpic) {
-        NPE_CHECK_RETURN_ZERO(env, jpic);
-        return GraphicsJNI::getNativePicture(env, jpic)->width();
-    }
-    
-    static int getHeight(JNIEnv* env, jobject jpic) {
-        NPE_CHECK_RETURN_ZERO(env, jpic);
-        return GraphicsJNI::getNativePicture(env, jpic)->height();
-    }
-    
-    static SkCanvas* beginRecording(JNIEnv* env, jobject, SkPicture* pict,
-                                    int w, int h) {
-        // beginRecording does not ref its return value, it just returns it.
-        SkCanvas* canvas = pict->beginRecording(w, h);
-        // the java side will wrap this guy in a Canvas.java, which will call
-        // unref in its finalizer, so we have to ref it here, so that both that
-        // Canvas.java and our picture can both be owners
-        canvas->ref();
-        return canvas;
-    }
-    
-    static void endRecording(JNIEnv* env, jobject, SkPicture* pict) {
-        pict->endRecording();
-    }
-};
-
-static JNINativeMethod gPictureMethods[] = {
-    {"getWidth", "()I", (void*) SkPictureGlue::getWidth},
-    {"getHeight", "()I", (void*) SkPictureGlue::getHeight},
-    {"nativeConstructor", "(I)I", (void*) SkPictureGlue::newPicture},
-    {"nativeCreateFromStream", "(Ljava/io/InputStream;[B)I", (void*)SkPictureGlue::deserialize},
-    {"nativeBeginRecording", "(III)I", (void*) SkPictureGlue::beginRecording},
-    {"nativeEndRecording", "(I)V", (void*) SkPictureGlue::endRecording},
-    {"nativeDraw", "(II)V", (void*) SkPictureGlue::draw},
-    {"nativeWriteToStream", "(ILjava/io/OutputStream;[B)Z", (void*)SkPictureGlue::serialize},
-    {"nativeDestructor","(I)V", (void*) SkPictureGlue::killPicture}
-};
-
-#include <android_runtime/AndroidRuntime.h>
-    
-#define REG(env, name, array) \
-    result = android::AndroidRuntime::registerNativeMethods(env, name, array, \
-    SK_ARRAY_COUNT(array));  \
-    if (result < 0) return result
-    
-int register_android_graphics_Picture(JNIEnv* env) {
-    int result;
-    
-    REG(env, "android/graphics/Picture", gPictureMethods);
-    
-    return result;
-}
-    
-}
-
-
diff --git a/core/jni/android/graphics/PorterDuff.cpp b/core/jni/android/graphics/PorterDuff.cpp
deleted file mode 100644
index 47de601..0000000
--- a/core/jni/android/graphics/PorterDuff.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-/* libs/android_runtime/android/graphics/PorterDuff.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
-**
-**     http://www.apache.org/licenses/LICENSE-2.0 
-**
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
-** limitations under the License.
-*/
-
-// This file was generated from the C++ include file: SkPorterDuff.h
-// Any changes made to this file will be discarded by the build.
-// To change this file, either edit the include, or device/tools/gluemaker/main.cpp, 
-// or one of the auxilary file specifications in device/tools/gluemaker.
-
-#include "jni.h"
-#include "GraphicsJNI.h"
-#include <android_runtime/AndroidRuntime.h>
-
-#include "SkPorterDuff.h"
-
-namespace android {
-
-class SkPorterDuffGlue {
-public:
-
-    static SkXfermode* CreateXfermode(JNIEnv* env, jobject,
-                                      SkPorterDuff::Mode mode) {
-        return SkPorterDuff::CreateXfermode(mode);
-    }
- 
-};
-
-static JNINativeMethod methods[] = {
-    {"nativeCreateXfermode","(I)I", (void*) SkPorterDuffGlue::CreateXfermode},
-};
-
-int register_android_graphics_PorterDuff(JNIEnv* env) {
-    int result = AndroidRuntime::registerNativeMethods(env,
-                                "android/graphics/PorterDuffXfermode", methods,
-                                        sizeof(methods) / sizeof(methods[0]));
-    return result;
-}
-
-}
diff --git a/core/jni/android/graphics/Rasterizer.cpp b/core/jni/android/graphics/Rasterizer.cpp
deleted file mode 100644
index db70b57..0000000
--- a/core/jni/android/graphics/Rasterizer.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-/* libs/android_runtime/android/graphics/Rasterizer.cpp
-**
-** Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
-**
-**     http://www.apache.org/licenses/LICENSE-2.0 
-**
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
-** limitations under the License.
-*/
-
-// This file was generated from the C++ include file: SkRasterizer.h
-// Any changes made to this file will be discarded by the build.
-// To change this file, either edit the include, or device/tools/gluemaker/main.cpp, 
-// or one of the auxilary file specifications in device/tools/gluemaker.
-
-#include "jni.h"
-#include "GraphicsJNI.h"
-#include <android_runtime/AndroidRuntime.h>
-
-#include "SkRasterizer.h"
-
-namespace android {
-
-class SkRasterizerGlue {
-public:
-
-    static void finalizer(JNIEnv* env, jobject clazz, SkRasterizer* obj) {
-        obj->safeUnref();
-    }
- 
-};
-
-static JNINativeMethod methods[] = {
-    {"finalizer", "(I)V", (void*) SkRasterizerGlue::finalizer}
-};
-
-int register_android_graphics_Rasterizer(JNIEnv* env) {
-    int result = AndroidRuntime::registerNativeMethods(env, "android/graphics/Rasterizer", methods,
-        sizeof(methods) / sizeof(methods[0]));
-    return result;
-}
-
-}
diff --git a/core/jni/android/graphics/Region.cpp b/core/jni/android/graphics/Region.cpp
deleted file mode 100644
index 00d6cd9..0000000
--- a/core/jni/android/graphics/Region.cpp
+++ /dev/null
@@ -1,231 +0,0 @@
-#include "SkRegion.h"
-#include "SkPath.h"
-#include "GraphicsJNI.h"
-
-#include <jni.h>
-
-static jfieldID gRegion_nativeInstanceFieldID;
-
-static inline SkRegion* GetSkRegion(JNIEnv* env, jobject regionObject) {
-    SkRegion* rgn = (SkRegion*)env->GetIntField(regionObject, gRegion_nativeInstanceFieldID);
-    SkASSERT(rgn != NULL);
-    return rgn;
-}
-
-static SkRegion* Region_constructor(JNIEnv* env, jobject) {
-    return new SkRegion;
-}
-
-static void Region_destructor(JNIEnv* env, jobject, SkRegion* region) {
-    SkASSERT(region);
-    delete region;
-}
-
-static void Region_setRegion(JNIEnv* env, jobject, SkRegion* dst, const SkRegion* src) {
-    SkASSERT(dst && src);
-    *dst = *src;
-}
-
-static jboolean Region_setRect(JNIEnv* env, jobject, SkRegion* dst, int left, int top, int right, int bottom) {
-    return dst->setRect(left, top, right, bottom);
-}
-
-static jboolean Region_setPath(JNIEnv* env, jobject, SkRegion* dst,
-                               const SkPath* path, const SkRegion* clip) {
-    SkASSERT(dst && path && clip);
-    return dst->setPath(*path, *clip);
-}
-
-static jboolean Region_getBounds(JNIEnv* env, jobject, SkRegion* region, jobject rectBounds) {
-    GraphicsJNI::irect_to_jrect(region->getBounds(), env, rectBounds);
-    return !region->isEmpty();
-}
-
-static jboolean Region_getBoundaryPath(JNIEnv* env, jobject, const SkRegion* region, SkPath* path) {
-    return region->getBoundaryPath(path);
-}
-
-static jboolean Region_op0(JNIEnv* env, jobject, SkRegion* dst, int left, int top, int right, int bottom, int op) {
-    SkIRect ir;
-    
-    ir.set(left, top, right, bottom);
-    return dst->op(ir, (SkRegion::Op)op);
-}
-
-static jboolean Region_op1(JNIEnv* env, jobject, SkRegion* dst, jobject rectObject, const SkRegion* region, int op) {
-    SkIRect    ir;
-    GraphicsJNI::jrect_to_irect(env, rectObject, &ir);
-    return dst->op(ir, *region, (SkRegion::Op)op);
-}
-
-static jboolean Region_op2(JNIEnv* env, jobject, SkRegion* dst, const SkRegion* region1, const SkRegion* region2, int op) {
-    return dst->op(*region1, *region2, (SkRegion::Op)op);
-}
-
-////////////////////////////////////  These are methods, not static 
-
-static jboolean Region_isEmpty(JNIEnv* env, jobject region) {
-    return GetSkRegion(env, region)->isEmpty();
-}
- 
-static jboolean Region_isRect(JNIEnv* env, jobject region) {
-    return GetSkRegion(env, region)->isRect();
-}
- 
-static jboolean Region_isComplex(JNIEnv* env, jobject region) {
-    return GetSkRegion(env, region)->isComplex();
-}
-
-static jboolean Region_contains(JNIEnv* env, jobject region, int x, int y) {
-    return GetSkRegion(env, region)->contains(x, y);
-}
- 
-static jboolean Region_quickContains(JNIEnv* env, jobject region, int left, int top, int right, int bottom) {
-    return GetSkRegion(env, region)->quickContains(left, top, right, bottom);
-}
- 
-static jboolean Region_quickRejectIIII(JNIEnv* env, jobject region, int left, int top, int right, int bottom) {
-    SkIRect ir;
-    ir.set(left, top, right, bottom);
-    return GetSkRegion(env, region)->quickReject(ir);
-}
- 
-static jboolean Region_quickRejectRgn(JNIEnv* env, jobject region, jobject other) {
-    return GetSkRegion(env, region)->quickReject(*GetSkRegion(env, other));
-}
- 
-static void Region_translate(JNIEnv* env, jobject region, int x, int y, jobject dst) {
-    SkRegion* rgn = GetSkRegion(env, region);
-    if (dst)
-        rgn->translate(x, y, GetSkRegion(env, dst));
-    else
-        rgn->translate(x, y);
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#include "Parcel.h"
-#include "android_util_Binder.h"
-
-static SkRegion* Region_createFromParcel(JNIEnv* env, jobject clazz, jobject parcel)
-{
-    if (parcel == NULL) {
-        return NULL;
-    }
-    
-    android::Parcel* p = android::parcelForJavaObject(env, parcel);
-    
-    SkRegion* region = new SkRegion;
-    size_t size = p->readInt32();
-    region->unflatten(p->readInplace(size));
-    
-    return region;
-}
-
-static jboolean Region_writeToParcel(JNIEnv* env, jobject clazz, const SkRegion* region, jobject parcel)
-{
-    if (parcel == NULL) {
-        return false;
-    }
-    
-    android::Parcel* p = android::parcelForJavaObject(env, parcel);
-
-    size_t size = region->flatten(NULL);
-    p->writeInt32(size);
-    region->flatten(p->writeInplace(size));
-
-    return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-struct RgnIterPair {
-    SkRegion            fRgn;   // a copy of the caller's region
-    SkRegion::Iterator  fIter;  // an iterator acting upon the copy (fRgn)
-    
-    RgnIterPair(const SkRegion& rgn) : fRgn(rgn) {
-        // have our iterator reference our copy (fRgn), so we know it will be
-        // unchanged for the lifetime of the iterator
-        fIter.reset(fRgn);
-    }
-};
-
-static RgnIterPair* RegionIter_constructor(JNIEnv* env, jobject, const SkRegion* region)
-{
-    SkASSERT(region);    
-    return new RgnIterPair(*region);
-}
-
-static void RegionIter_destructor(JNIEnv* env, jobject, RgnIterPair* pair)
-{
-    SkASSERT(pair);
-    delete pair;
-}
-
-static jboolean RegionIter_next(JNIEnv* env, jobject, RgnIterPair* pair, jobject rectObject)
-{
-    // the caller has checked that rectObject is not nul
-    SkASSERT(pair);
-    SkASSERT(rectObject);
-
-    if (!pair->fIter.done()) {
-        GraphicsJNI::irect_to_jrect(pair->fIter.rect(), env, rectObject);
-        pair->fIter.next();
-        return true;
-    }
-    return false;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-#include <android_runtime/AndroidRuntime.h>
-
-static JNINativeMethod gRegionIterMethods[] = {
-    { "nativeConstructor",  "(I)I",                         (void*)RegionIter_constructor   },
-    { "nativeDestructor",   "(I)V",                         (void*)RegionIter_destructor    },
-    { "nativeNext",         "(ILandroid/graphics/Rect;)Z",  (void*)RegionIter_next          }
-};
-
-static JNINativeMethod gRegionMethods[] = {
-    // these are static methods
-    { "nativeConstructor",      "()I",                              (void*)Region_constructor       },
-    { "nativeDestructor",       "(I)V",                             (void*)Region_destructor        },
-    { "nativeSetRegion",        "(II)Z",                            (void*)Region_setRegion         },
-    { "nativeSetRect",          "(IIIII)Z",                         (void*)Region_setRect           },
-    { "nativeSetPath",          "(III)Z",                           (void*)Region_setPath           },
-    { "nativeGetBounds",        "(ILandroid/graphics/Rect;)Z",      (void*)Region_getBounds         },
-    { "nativeGetBoundaryPath",  "(II)Z",                            (void*)Region_getBoundaryPath   },
-    { "nativeOp",               "(IIIIII)Z",                        (void*)Region_op0               },
-    { "nativeOp",               "(ILandroid/graphics/Rect;II)Z",    (void*)Region_op1               },
-    { "nativeOp",               "(IIII)Z",                          (void*)Region_op2               },
-    // these are methods that take the java region object
-    { "isEmpty",                "()Z",                              (void*)Region_isEmpty           },
-    { "isRect",                 "()Z",                              (void*)Region_isRect            },
-    { "isComplex",              "()Z",                              (void*)Region_isComplex         },
-    { "contains",               "(II)Z",                            (void*)Region_contains          },
-    { "quickContains",          "(IIII)Z",                          (void*)Region_quickContains     },
-    { "quickReject",            "(IIII)Z",                          (void*)Region_quickRejectIIII   },
-    { "quickReject",            "(Landroid/graphics/Region;)Z",     (void*)Region_quickRejectRgn    },
-    { "translate",              "(IILandroid/graphics/Region;)V",   (void*)Region_translate         },
-    // parceling methods
-    { "nativeCreateFromParcel", "(Landroid/os/Parcel;)I",           (void*)Region_createFromParcel  },
-    { "nativeWriteToParcel",    "(ILandroid/os/Parcel;)Z",          (void*)Region_writeToParcel     }
-};
-
-int register_android_graphics_Region(JNIEnv* env);
-int register_android_graphics_Region(JNIEnv* env)
-{
-    jclass clazz = env->FindClass("android/graphics/Region");
-    SkASSERT(clazz);
-    
-    gRegion_nativeInstanceFieldID = env->GetFieldID(clazz, "mNativeRegion", "I");
-    SkASSERT(gRegion_nativeInstanceFieldID);
-
-    int result = android::AndroidRuntime::registerNativeMethods(env, "android/graphics/Region",
-                                                             gRegionMethods, SK_ARRAY_COUNT(gRegionMethods));
-    if (result < 0)
-        return result;
-
-    return android::AndroidRuntime::registerNativeMethods(env, "android/graphics/RegionIterator",
-                                                       gRegionIterMethods, SK_ARRAY_COUNT(gRegionIterMethods));
-}
diff --git a/core/jni/android/graphics/Shader.cpp b/core/jni/android/graphics/Shader.cpp
deleted file mode 100644
index b28eb90..0000000
--- a/core/jni/android/graphics/Shader.cpp
+++ /dev/null
@@ -1,299 +0,0 @@
-#include <jni.h>
-#include "GraphicsJNI.h"
-
-#include "SkShader.h"
-#include "SkGradientShader.h"
-#include "SkPorterDuff.h"
-#include "SkComposeShader.h"
-#include "SkTemplates.h"
-#include "SkXfermode.h"
-
-static void ThrowIAE_IfNull(JNIEnv* env, void* ptr) {
-    if (NULL == ptr) {
-        doThrowIAE(env);
-    }
-}
-
-static void Color_RGBToHSV(JNIEnv* env, jobject, int red, int green, int blue, jfloatArray hsvArray)
-{
-    SkScalar hsv[3];
-    SkRGBToHSV(red, green, blue, hsv);
-
-    AutoJavaFloatArray  autoHSV(env, hsvArray, 3);
-    float* values = autoHSV.ptr();
-    for (int i = 0; i < 3; i++) {
-        values[i] = SkScalarToFloat(hsv[i]);
-    }
-}
- 
-static int Color_HSVToColor(JNIEnv* env, jobject, int 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]);
-    }
-    
-    return SkHSVToColor(alpha, hsv);
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////
-
-static void Shader_destructor(JNIEnv* env, jobject, SkShader* shader)
-{
-    SkASSERT(shader != NULL);
-    shader->unref();
-}
-
-static bool Shader_getLocalMatrix(JNIEnv* env, jobject, const SkShader* shader, SkMatrix* matrix)
-{
-    SkASSERT(shader != NULL);    
-    return shader->getLocalMatrix(matrix);
-}
- 
-static void Shader_setLocalMatrix(JNIEnv* env, jobject, SkShader* shader, const SkMatrix* matrix)
-{
-    SkASSERT(shader != NULL);
-    
-    if (NULL == matrix) {
-        shader->resetLocalMatrix();
-    }
-    else {
-        shader->setLocalMatrix(*matrix);
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////
-
-static SkShader* BitmapShader_constructor(JNIEnv* env, jobject, const SkBitmap* bitmap,
-                                          int tileModeX, int tileModeY)
-{
-    SkShader* s = SkShader::CreateBitmapShader(*bitmap,
-                                        (SkShader::TileMode)tileModeX,
-                                        (SkShader::TileMode)tileModeY);
-    ThrowIAE_IfNull(env, s);
-    return s;
-}
-    
-///////////////////////////////////////////////////////////////////////////////////////////////
-
-static SkShader* LinearGradient_create1(JNIEnv* env, jobject,
-                                        float x0, float y0, float x1, float y1,
-                                        jintArray colorArray, jfloatArray posArray, int tileMode)
-{
-    SkPoint pts[2];
-    pts[0].set(SkFloatToScalar(x0), SkFloatToScalar(y0));
-    pts[1].set(SkFloatToScalar(x1), SkFloatToScalar(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]);
-    }
-
-    SkShader* shader = SkGradientShader::CreateLinear(pts,
-                                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);
-    return shader;
-}
-
-static SkShader* LinearGradient_create2(JNIEnv* env, jobject,
-                                        float x0, float y0, float x1, float y1,
-                                        int color0, int color1, int tileMode)
-{
-    SkPoint pts[2];
-    pts[0].set(SkFloatToScalar(x0), SkFloatToScalar(y0));
-    pts[1].set(SkFloatToScalar(x1), SkFloatToScalar(y1));
-
-    SkColor colors[2];
-    colors[0] = color0;
-    colors[1] = color1;
-
-    SkShader* s = SkGradientShader::CreateLinear(pts, colors, NULL, 2, (SkShader::TileMode)tileMode);
-    ThrowIAE_IfNull(env, s);
-    return s;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////
-
-static SkShader* RadialGradient_create1(JNIEnv* env, jobject,
-                                        float x, float y, float radius,
-                                        jintArray colorArray, jfloatArray posArray, int tileMode)
-{
-    SkPoint center;
-    center.set(SkFloatToScalar(x), SkFloatToScalar(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]);
-    }
-
-    SkShader* shader = SkGradientShader::CreateRadial(center,
-                                SkFloatToScalar(radius),
-                                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);
-    return shader;
-}
-
-static SkShader* RadialGradient_create2(JNIEnv* env, jobject,
-                                        float x, float y, float radius,
-                                        int color0, int color1, int tileMode)
-{
-    SkPoint center;
-    center.set(SkFloatToScalar(x), SkFloatToScalar(y));
-
-    SkColor colors[2];
-    colors[0] = color0;
-    colors[1] = color1;
-
-    SkShader* s = SkGradientShader::CreateRadial(center, SkFloatToScalar(radius), colors, NULL,
-                                          2, (SkShader::TileMode)tileMode);
-    ThrowIAE_IfNull(env, s);
-    return s;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-static SkShader* SweepGradient_create1(JNIEnv* env, jobject, float x, float y,
-                                    jintArray jcolors, jfloatArray jpositions)
-{
-    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]);
-        }
-    }
-
-    SkShader* shader = SkGradientShader::CreateSweep(SkFloatToScalar(x),
-                                     SkFloatToScalar(y),
-                                     reinterpret_cast<const SkColor*>(colors),
-                                     pos, count);
-    env->ReleaseIntArrayElements(jcolors, const_cast<jint*>(colors),
-                                 JNI_ABORT);
-    ThrowIAE_IfNull(env, shader);
-    return shader;
-}
-
-static SkShader* SweepGradient_create2(JNIEnv* env, jobject, float x, float y,
-                                        int color0, int color1)
-{
-    SkColor colors[2];
-    colors[0] = color0;
-    colors[1] = color1;
-    SkShader* s = SkGradientShader::CreateSweep(SkFloatToScalar(x), SkFloatToScalar(y),
-                                         colors, NULL, 2);
-    ThrowIAE_IfNull(env, s);
-    return s;
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////
-
-static SkShader* ComposeShader_create1(JNIEnv* env, jobject,
-                                       SkShader* shaderA, SkShader* shaderB, SkXfermode* mode)
-{
-    return new SkComposeShader(shaderA, shaderB, mode);
-}
-
-static SkShader* ComposeShader_create2(JNIEnv* env, jobject,
-                                       SkShader* shaderA, SkShader* shaderB, SkPorterDuff::Mode mode)
-{
-    SkAutoUnref au(SkPorterDuff::CreateXfermode(mode));
-
-    return new SkComposeShader(shaderA, shaderB, (SkXfermode*)au.get());
-}
-
-///////////////////////////////////////////////////////////////////////////////////////////////
-
-static JNINativeMethod gColorMethods[] = {
-    { "nativeRGBToHSV",     "(III[F)V", (void*)Color_RGBToHSV   },
-    { "nativeHSVToColor",   "(I[F)I",   (void*)Color_HSVToColor }
-};
-
-static JNINativeMethod gShaderMethods[] = {
-    { "nativeDestructor",        "(I)V",     (void*)Shader_destructor        },
-    { "nativeGetLocalMatrix",    "(II)Z",    (void*)Shader_getLocalMatrix    },
-    { "nativeSetLocalMatrix",    "(II)V",    (void*)Shader_setLocalMatrix    }
-};
-
-static JNINativeMethod gBitmapShaderMethods[] = {
-    { "nativeCreate",   "(III)I",  (void*)BitmapShader_constructor }
-};
-
-static JNINativeMethod gLinearGradientMethods[] = {
-    { "nativeCreate1",  "(FFFF[I[FI)I", (void*)LinearGradient_create1   },
-    { "nativeCreate2",  "(FFFFIII)I",   (void*)LinearGradient_create2   }
-};
-
-static JNINativeMethod gRadialGradientMethods[] = {
-    {"nativeCreate1",   "(FFF[I[FI)I",  (void*)RadialGradient_create1   },
-    {"nativeCreate2",   "(FFFIII)I",    (void*)RadialGradient_create2   }
-};
-
-static JNINativeMethod gSweepGradientMethods[] = {
-    {"nativeCreate1",   "(FF[I[F)I",  (void*)SweepGradient_create1   },
-    {"nativeCreate2",   "(FFII)I",    (void*)SweepGradient_create2   }
-};
-
-static JNINativeMethod gComposeShaderMethods[] = {
-    {"nativeCreate1",  "(III)I",    (void*)ComposeShader_create1 },
-    {"nativeCreate2",  "(III)I",    (void*)ComposeShader_create2 }
-};
-
-#include <android_runtime/AndroidRuntime.h>
-
-#define REG(env, name, array)                                                                       \
-    result = android::AndroidRuntime::registerNativeMethods(env, name, array, SK_ARRAY_COUNT(array));  \
-    if (result < 0) return result
-
-int register_android_graphics_Shader(JNIEnv* env);
-int register_android_graphics_Shader(JNIEnv* env)
-{
-    int result;
-    
-    REG(env, "android/graphics/Color", gColorMethods);
-    REG(env, "android/graphics/Shader", gShaderMethods);
-    REG(env, "android/graphics/BitmapShader", gBitmapShaderMethods);
-    REG(env, "android/graphics/LinearGradient", gLinearGradientMethods);
-    REG(env, "android/graphics/RadialGradient", gRadialGradientMethods);
-    REG(env, "android/graphics/SweepGradient", gSweepGradientMethods);
-    REG(env, "android/graphics/ComposeShader", gComposeShaderMethods);
-    
-    return result;
-}
-
diff --git a/core/jni/android/graphics/Typeface.cpp b/core/jni/android/graphics/Typeface.cpp
deleted file mode 100644
index 32954ce..0000000
--- a/core/jni/android/graphics/Typeface.cpp
+++ /dev/null
@@ -1,156 +0,0 @@
-#include "jni.h"
-#include <android_runtime/AndroidRuntime.h>
-
-#include "GraphicsJNI.h"
-#include <android_runtime/android_util_AssetManager.h>
-#include "SkStream.h"
-#include "SkTypeface.h"
-#include <utils/AssetManager.h>
-
-using namespace android;
-
-class AutoJavaStringToUTF8 {
-public:
-    AutoJavaStringToUTF8(JNIEnv* env, jstring str) : fEnv(env), fJStr(str)
-    {
-        fCStr = env->GetStringUTFChars(str, NULL);
-    }
-    ~AutoJavaStringToUTF8()
-    {
-        fEnv->ReleaseStringUTFChars(fJStr, fCStr);
-    }
-    const char* c_str() const { return fCStr; }
-
-private:
-    JNIEnv*     fEnv;
-    jstring     fJStr;
-    const char* fCStr;
-};
-
-static SkTypeface* Typeface_create(JNIEnv* env, jobject, jstring name,
-                                   SkTypeface::Style style) {
-    SkTypeface* face;
-
-    if (NULL == name) {
-        face = SkTypeface::Create(NULL, (SkTypeface::Style)style);
-    }
-    else {
-        AutoJavaStringToUTF8    str(env, name);
-        face = SkTypeface::Create(str.c_str(), style);
-    }
-    return face;
-}
-
-static SkTypeface* Typeface_createFromTypeface(JNIEnv* env, jobject, SkTypeface* family, int style) {
-    return SkTypeface::CreateFromTypeface(family, (SkTypeface::Style)style);
-}
- 
-static void Typeface_unref(JNIEnv* env, jobject obj, SkTypeface* face) {
-    face->unref();
-}
-
-static int Typeface_getStyle(JNIEnv* env, jobject obj, SkTypeface* face) {
-    return face->getStyle();
-}
-
-class AssetStream : public SkStream {
-public:
-    AssetStream(Asset* asset, bool hasMemoryBase) : fAsset(asset)
-    {
-        fMemoryBase = hasMemoryBase ? fAsset->getBuffer(false) : NULL;
-    }
-
-    virtual ~AssetStream()
-    {
-        delete fAsset;
-    }
-    
-    virtual const void* getMemoryBase()
-    {
-        return fMemoryBase;
-    }
-
-	virtual bool rewind()
-    {
-        off_t pos = fAsset->seek(0, SEEK_SET);
-        return pos != (off_t)-1;
-    }
-    
-	virtual size_t read(void* buffer, size_t size)
-    {
-        ssize_t amount;
-        
-        if (NULL == buffer)
-        {
-            if (0 == size)  // caller is asking us for our total length
-                return fAsset->getLength();
-            
-            // asset->seek returns new total offset
-            // we want to return amount that was skipped
-            
-            off_t oldOffset = fAsset->seek(0, SEEK_CUR);
-            if (-1 == oldOffset)
-                return 0;
-            off_t newOffset = fAsset->seek(size, SEEK_CUR);
-            if (-1 == newOffset)
-                return 0;
-            
-            amount = newOffset - oldOffset;
-        }
-        else
-        {
-            amount = fAsset->read(buffer, size);
-        }
-        
-        if (amount < 0)
-            amount = 0;
-        return amount;
-    }
-    
-private:
-    Asset*      fAsset;
-    const void* fMemoryBase;
-};
-
-static SkTypeface* Typeface_createFromAsset(JNIEnv* env, jobject,
-                                            jobject jassetMgr,
-                                            jstring jpath) {
-    
-    NPE_CHECK_RETURN_ZERO(env, jassetMgr);
-    NPE_CHECK_RETURN_ZERO(env, jpath);
-    
-    AssetManager* mgr = assetManagerForJavaObject(env, jassetMgr);
-    if (NULL == mgr) {
-        return NULL;
-    }
-    
-    AutoJavaStringToUTF8    str(env, jpath);
-    Asset* asset = mgr->open(str.c_str(), Asset::ACCESS_BUFFER);
-    if (NULL == asset) {
-        return NULL;
-    }
-    
-    return SkTypeface::CreateFromStream(new AssetStream(asset, true));
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-static JNINativeMethod gTypefaceMethods[] = {
-    { "nativeCreate",        "(Ljava/lang/String;I)I", (void*)Typeface_create },
-    { "nativeCreateFromTypeface", "(II)I", (void*)Typeface_createFromTypeface },
-    { "nativeUnref",              "(I)V",  (void*)Typeface_unref },
-    { "nativeGetStyle",           "(I)I",  (void*)Typeface_getStyle },
-    { "nativeCreateFromAsset",
-                        "(Landroid/content/res/AssetManager;Ljava/lang/String;)I",
-                                            (void*)Typeface_createFromAsset }
-};
-
-int register_android_graphics_Typeface(JNIEnv* env);
-int register_android_graphics_Typeface(JNIEnv* env)
-{
-    return android::AndroidRuntime::registerNativeMethods(env,
-                                                       "android/graphics/Typeface",
-                                                       gTypefaceMethods,
-                                                       SK_ARRAY_COUNT(gTypefaceMethods));
-}
-
diff --git a/core/jni/android/graphics/Xfermode.cpp b/core/jni/android/graphics/Xfermode.cpp
deleted file mode 100644
index 2b53d28..0000000
--- a/core/jni/android/graphics/Xfermode.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright (C) 2007 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "jni.h"
-#include "GraphicsJNI.h"
-#include <android_runtime/AndroidRuntime.h>
-
-#include "SkAvoidXfermode.h"
-#include "SkPixelXorXfermode.h"
-
-namespace android {
-
-class SkXfermodeGlue {
-public:
-
-    static void finalizer(JNIEnv* env, jobject, SkXfermode* obj)
-    {
-        obj->safeUnref();
-    }
-    
-    static SkXfermode* avoid_create(JNIEnv* env, jobject, SkColor opColor,
-                                U8CPU tolerance, SkAvoidXfermode::Mode mode)
-    {
-        return new SkAvoidXfermode(opColor, tolerance, mode);
-    }
-    
-    static SkXfermode* pixelxor_create(JNIEnv* env, jobject, SkColor opColor)
-    {
-        return new SkPixelXorXfermode(opColor);
-    }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-
-static JNINativeMethod gXfermodeMethods[] = {
-    {"finalizer", "(I)V", (void*) SkXfermodeGlue::finalizer}
-};
-
-static JNINativeMethod gAvoidMethods[] = {
-    {"nativeCreate", "(III)I", (void*) SkXfermodeGlue::avoid_create}
-};
-
-static JNINativeMethod gPixelXorMethods[] = {
-    {"nativeCreate", "(I)I", (void*) SkXfermodeGlue::pixelxor_create}
-};
-
-#include <android_runtime/AndroidRuntime.h>
-
-#define REG(env, name, array)                                              \
-    result = android::AndroidRuntime::registerNativeMethods(env, name, array, \
-                                                  SK_ARRAY_COUNT(array));  \
-    if (result < 0) return result
-
-int register_android_graphics_Xfermode(JNIEnv* env) {
-    int result;
-    
-    REG(env, "android/graphics/Xfermode", gXfermodeMethods);
-    REG(env, "android/graphics/AvoidXfermode", gAvoidMethods);
-    REG(env, "android/graphics/PixelXorXfermode", gPixelXorMethods);
-
-    return 0;
-}
-
-}