remove Sk64 from public API, and start to remove usage internally

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
 #define SkBitmap_DEFINED
 
-#include "Sk64.h"
 #include "SkColor.h"
 #include "SkColorTable.h"
 #include "SkImageInfo.h"
 #include "SkPoint.h"
 #include "SkRefCnt.h"
 
+#ifdef SK_SUPPORT_LEGACY_SK64
+    #include "Sk64.h"
+#endif
+
 struct SkIRect;
 struct SkRect;
 class SkPaint;
 class SkPixelRef;
 class SkRegion;
 class SkString;
 
 class GrTexture;
 
 /** \class SkBitmap
@@ skipping 112 matching lines @@
         if the real size exceeds 32bits.
     */
     size_t getSize() const { return fHeight * fRowBytes; }
 
     /** Return the number of bytes from the pointer returned by getPixels()
         to the end of the allocated space in the buffer. Required in
         cases where extractSubset has been called.
     */
     size_t getSafeSize() const ;
 
-    /** Return the byte size of the pixels, based on the height and rowBytes.
-        This routine is slightly slower than getSize(), but does not truncate
-        the answer to 32bits.
-    */
+    /**
+     *  Return the full size of the bitmap, in bytes.
+     */
+    int64_t computeSize64() const {
+        return sk_64_mul(fHeight, fRowBytes);
+    }
+
+    /**
+     *  Return the number of bytes from the pointer returned by getPixels()
+     *  to the end of the allocated space in the buffer. This may be smaller
+     *  than computeSize64() if there is any rowbytes padding beyond the width.
+     */
+    int64_t computeSafeSize64() const {
+        return ComputeSafeSize64((Config)fConfig, fWidth, fHeight, fRowBytes);
+    }
+
+#ifdef SK_SUPPORT_LEGACY_SK64
+    SK_ATTR_DEPRECATED("use getSize64()")
     Sk64 getSize64() const {
         Sk64 size;
-        size.setMul(fHeight, fRowBytes);
+        size.set64(this->computeSize64());
         return size;
     }
 
-    /** Same as getSafeSize(), but does not truncate the answer to 32bits.
-    */
-    Sk64 getSafeSize64() const ;
+    SK_ATTR_DEPRECATED("use getSafeSize64()")
+    Sk64 getSafeSize64() const {
+        Sk64 size;
+        size.set64(this->computeSafeSize64());
+        return size;
+    }
+#endif
 
     /** Returns true if this bitmap is marked as immutable, meaning that the
         contents of its pixels will not change for the lifetime of the bitmap.
     */
     bool isImmutable() const;
 
     /** Marks this bitmap as immutable, meaning that the contents of its
         pixels will not change for the lifetime of the bitmap and of the
         underlying pixelref. This state can be set, but it cannot be
         cleared once it is set. This state propagates to all other bitmaps
@@ skipping 35 matching lines @@
     */
     static int ComputeBytesPerPixel(Config c);
 
     /** Return the shift-per-pixel for the specified config. If the config is
      not at least 1-byte per pixel, return 0, including for kNo_Config.
      */
     static int ComputeShiftPerPixel(Config c) {
         return ComputeBytesPerPixel(c) >> 1;
     }
 
-    static Sk64 ComputeSize64(Config, int width, int height);
+    static int64_t ComputeSize64(Config, int width, int height);
     static size_t ComputeSize(Config, int width, int height);
 
     /**
      *  This will brute-force return true if all of the pixels in the bitmap
      *  are opaque. If it fails to read the pixels, or encounters an error,
      *  it will return false.
      *
      *  Since this can be an expensive operation, the bitmap stores a flag for
      *  this (isOpaque). Only call this if you need to compute this value from
      *  "unknown" pixels.
@@ skipping 440 matching lines @@
     uint32_t    fHeight;
     uint8_t     fConfig;
     uint8_t     fAlphaType;
     uint8_t     fFlags;
     uint8_t     fBytesPerPixel; // based on config
 
     void internalErase(const SkIRect&, U8CPU a, U8CPU r, U8CPU g, U8CPU b)const;
 
     /* Internal computations for safe size.
     */
-    static Sk64 ComputeSafeSize64(Config   config,
-                                  uint32_t width,
-                                  uint32_t height,
-                                  size_t   rowBytes);
+    static int64_t ComputeSafeSize64(Config   config,
+                                     uint32_t width,
+                                     uint32_t height,
+                                     size_t   rowBytes);
     static size_t ComputeSafeSize(Config   config,
                                   uint32_t width,
                                   uint32_t height,
                                   size_t   rowBytes);
 
     /*  Unreference any pixelrefs or colortables
     */
     void freePixels();
     void updatePixelsFromRef() const;
 
@@ skipping 110 matching lines @@
 
 inline SkPMColor SkBitmap::getIndex8Color(int x, int y) const {
     SkASSERT(fPixels);
     SkASSERT(fConfig == kIndex8_Config);
     SkASSERT((unsigned)x < fWidth && (unsigned)y < fHeight);
     SkASSERT(fColorTable);
     return (*fColorTable)[*((const uint8_t*)fPixels + y * fRowBytes + x)];
 }
 
 #endif