add SK_ATTR_DEPRECATED -- will need to disable for chrome, since it triggers a warning

src/core/SkBitmap.cpp

 
 /*
  * Copyright 2008 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.
  */
 
 
 #include "SkBitmap.h"
@@ skipping 484 matching lines @@
     dst->lockPixels();
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 size_t SkBitmap::getSafeSize() const {
     // This is intended to be a size_t version of ComputeSafeSize64(), just
     // faster. The computation is meant to be identical.
     return (fHeight ? ((fHeight - 1) * fRowBytes) +
-            ComputeRowBytes(getConfig(), fWidth): 0);
+            ComputeRowBytes(this->config(), fWidth): 0);
 }
 
 Sk64 SkBitmap::getSafeSize64() const {
-    return ComputeSafeSize64(getConfig(), fWidth, fHeight, fRowBytes);
+    return ComputeSafeSize64(this->config(), fWidth, fHeight, fRowBytes);
 }
 
 bool SkBitmap::copyPixelsTo(void* const dst, size_t dstSize,
                             size_t dstRowBytes, bool preserveDstPad) const {
 
     if (0 == dstRowBytes) {
         dstRowBytes = fRowBytes;
     }
 
-    if (dstRowBytes < ComputeRowBytes(getConfig(), fWidth) ||
+    if (dstRowBytes < ComputeRowBytes(this->config(), fWidth) ||
         dst == NULL || (getPixels() == NULL && pixelRef() == NULL))
         return false;
 
     if (!preserveDstPad && static_cast<uint32_t>(dstRowBytes) == fRowBytes) {
-        size_t safeSize = getSafeSize();
+        size_t safeSize = this->getSafeSize();
         if (safeSize > dstSize || safeSize == 0)
             return false;
         else {
             SkAutoLockPixels lock(*this);
             // This implementation will write bytes beyond the end of each row,
             // excluding the last row, if the bitmap's stride is greater than
             // strictly required by the current config.
             memcpy(dst, getPixels(), safeSize);
 
             return true;
         }
     } else {
         // If destination has different stride than us, then copy line by line.
-        if (ComputeSafeSize(getConfig(), fWidth, fHeight, dstRowBytes) >
+        if (ComputeSafeSize(this->config(), fWidth, fHeight, dstRowBytes) >
             dstSize)
             return false;
         else {
             // Just copy what we need on each line.
-            size_t rowBytes = ComputeRowBytes(getConfig(), fWidth);
+            size_t rowBytes = ComputeRowBytes(this->config(), fWidth);
             SkAutoLockPixels lock(*this);
             const uint8_t* srcP = reinterpret_cast<const uint8_t*>(getPixels());
             uint8_t* dstP = reinterpret_cast<uint8_t*>(dst);
             for (uint32_t row = 0; row < fHeight;
                  row++, srcP += fRowBytes, dstP += dstRowBytes) {
                 memcpy(dstP, srcP, rowBytes);
             }
 
             return true;
         }
@@ skipping 313 matching lines @@
 #define SUB_OFFSET_FAILURE  ((size_t)-1)
 
 /**
  *  Based on the Config and rowBytes() of bm, return the offset into an SkPixelRef of the pixel at
  *  (x, y).
  *  Note that the SkPixelRef does not need to be set yet. deepCopyTo takes advantage of this fact.
  *  Also note that (x, y) may be outside the range of (0 - width(), 0 - height()), so long as it is
  *  within the bounds of the SkPixelRef being used.
  */
 static size_t get_sub_offset(const SkBitmap& bm, int x, int y) {
-    switch (bm.getConfig()) {
+    switch (bm.config()) {
         case SkBitmap::kA8_Config:
         case SkBitmap:: kIndex8_Config:
             // x is fine as is for the calculation
             break;
 
         case SkBitmap::kRGB_565_Config:
         case SkBitmap::kARGB_4444_Config:
             x <<= 1;
             break;
 
@@ skipping 110 matching lines @@
     result->swap(dst);
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkCanvas.h"
 #include "SkPaint.h"
 
 bool SkBitmap::canCopyTo(Config dstConfig) const {
-    if (this->getConfig() == kNo_Config) {
+    if (this->config() == kNo_Config) {
         return false;
     }
 
     bool sameConfigs = (this->config() == dstConfig);
     switch (dstConfig) {
         case kA8_Config:
         case kRGB_565_Config:
         case kARGB_8888_Config:
             break;
         case kA1_Config:
         case kIndex8_Config:
             if (!sameConfigs) {
                 return false;
             }
             break;
         case kARGB_4444_Config:
             return sameConfigs || kARGB_8888_Config == this->config();
         default:
             return false;
     }
 
     // do not copy src if srcConfig == kA1_Config while dstConfig != kA1_Config
-    if (this->getConfig() == kA1_Config && !sameConfigs) {
+    if (this->config() == kA1_Config && !sameConfigs) {
         return false;
     }
 
     return true;
 }
 
 bool SkBitmap::copyTo(SkBitmap* dst, Config dstConfig, Allocator* alloc) const {
     if (!this->canCopyTo(dstConfig)) {
         return false;
     }
@@ skipping 256 matching lines @@
 void SkBitmap::buildMipMap(bool forceRebuild) {
     if (forceRebuild)
         this->freeMipMap();
     else if (fMipMap)
         return; // we're already built
 
     SkASSERT(NULL == fMipMap);
 
     void (*proc)(SkBitmap* dst, int x, int y, const SkBitmap& src);
 
-    const SkBitmap::Config config = this->getConfig();
+    const SkBitmap::Config config = this->config();
 
     switch (config) {
         case kARGB_8888_Config:
             proc = downsampleby2_proc32;
             break;
         case kRGB_565_Config:
             proc = downsampleby2_proc16;
             break;
         case kARGB_4444_Config:
             proc = downsampleby2_proc4444;
@@ skipping 118 matching lines @@
     return SkIntToFixed(15 - clz) + ((unsigned)(sx << (clz + 1)) >> 16);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static bool GetBitmapAlpha(const SkBitmap& src, uint8_t* SK_RESTRICT alpha,
                            int alphaRowBytes) {
     SkASSERT(alpha != NULL);
     SkASSERT(alphaRowBytes >= src.width());
 
-    SkBitmap::Config config = src.getConfig();
+    SkBitmap::Config config = src.config();
     int              w = src.width();
     int              h = src.height();
     size_t           rb = src.rowBytes();
 
     SkAutoLockPixels alp(src);
     if (!src.readyToDraw()) {
         // zero out the alpha buffer and return
         while (--h >= 0) {
             memset(alpha, 0, w);
             alpha += alphaRowBytes;
@@ skipping 245 matching lines @@
         if (NULL != uri) {
             str->appendf(" uri:\"%s\"", uri);
         } else {
             str->appendf(" pixelref:%p", pr);
         }
     }
 
     str->append(")");
 }
 #endif