Upstream changes from Android.

include/core/SkBitmap.h

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkBitmap_DEFINED
@@ skipping 524 matching lines @@
     bool hasMipMap() const;
     void buildMipMap(bool forceRebuild = false);
     void freeMipMap();
 
     /** Given scale factors sx, sy, determine the miplevel available in the
         bitmap, and return it (this is the amount to shift matrix iterators
         by). If dst is not null, it is set to the correct level.
     */
     int extractMipLevel(SkBitmap* dst, SkFixed sx, SkFixed sy);
 
+#ifdef SK_BUILD_FOR_ANDROID
+    bool hasHardwareMipMap() const {
+        return (fFlags & kHasHardwareMipMap_Flag) != 0;
+    }
+
+    void setHasHardwareMipMap(bool hasHardwareMipMap) {
+        if (hasHardwareMipMap) {
+            fFlags |= kHasHardwareMipMap_Flag;
+        } else {
+            fFlags &= ~kHasHardwareMipMap_Flag;
+        }
+    }
+#endif
+
     bool extractAlpha(SkBitmap* dst) const {
         return this->extractAlpha(dst, NULL, NULL, NULL);
     }
 
     bool extractAlpha(SkBitmap* dst, const SkPaint* paint,
                       SkIPoint* offset) const {
         return this->extractAlpha(dst, paint, NULL, offset);
     }
 
     /** Set dst to contain alpha layer of this bitmap. If destination bitmap
@@ skipping 80 matching lines @@
     mutable size_t      fPixelRefOffset;
     mutable int         fPixelLockCount;
     // either user-specified (in which case it is not treated as mutable)
     // or a cache of the returned value from fPixelRef->lockPixels()
     mutable void*       fPixels;
     mutable SkColorTable* fColorTable;    // only meaningful for kIndex8
 
     enum Flags {
         kImageIsOpaque_Flag     = 0x01,
         kImageIsVolatile_Flag   = 0x02,
-        kImageIsImmutable_Flag  = 0x04
+        kImageIsImmutable_Flag  = 0x04,
+#ifdef SK_BUILD_FOR_ANDROID
+        /* A hint for the renderer responsible for drawing this bitmap
+         * indicating that it should attempt to use mipmaps when this bitmap
+         * is drawn scaled down.
+         */
+        kHasHardwareMipMap_Flag = 0x08,
+#endif
     };
 
     uint32_t    fRowBytes;
     uint32_t    fWidth;
     uint32_t    fHeight;
     uint8_t     fConfig;
     uint8_t     fFlags;
     uint8_t     fBytesPerPixel; // based on config
 
     /* Internal computations for safe size.
@@ skipping 120 matching lines @@
 
 // returns the address of the byte that contains the x coordinate
 inline uint8_t* SkBitmap::getAddr1(int x, int y) const {
     SkASSERT(fPixels);
     SkASSERT(fConfig == kA1_Config);
     SkASSERT((unsigned)x < fWidth && (unsigned)y < fHeight);
     return (uint8_t*)fPixels + y * fRowBytes + (x >> 3);
 }
 
 #endif