BBHs: void* data -> unsigned data

src/gpu/GrRecordReplaceDraw.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrRecordReplaceDraw.h"
 #include "SkCanvasPriv.h"
 #include "SkImage.h"
 #include "SkRecordDraw.h"
 #include "SkRecords.h"
 
-GrReplacements::ReplacementInfo* GrReplacements::newReplacement(uint32_t pictureID, 
+GrReplacements::ReplacementInfo* GrReplacements::newReplacement(uint32_t pictureID,
                                                                 unsigned int start,
                                                                 const SkMatrix& ctm) {
     ReplacementInfo* replacement = SkNEW_ARGS(ReplacementInfo, (pictureID, start, ctm));
     fReplacementHash.add(replacement);
     return replacement;
 }
 
 void GrReplacements::freeAll() {
     SkTDynamicHash<ReplacementInfo, ReplacementInfo::Key>::Iter iter(&fReplacementHash);
 
     for (; !iter.done(); ++iter) {
         ReplacementInfo* replacement = &(*iter);
         SkDELETE(replacement);
     }
 
     fReplacementHash.reset();
 }
 
-const GrReplacements::ReplacementInfo* GrReplacements::lookupByStart(uint32_t pictureID, 
-                                                                     size_t start, 
+const GrReplacements::ReplacementInfo* GrReplacements::lookupByStart(uint32_t pictureID,
+                                                                     size_t start,
                                                                      const SkMatrix& ctm) const {
     return fReplacementHash.find(ReplacementInfo::Key(pictureID, start, ctm));
 }
 
 static inline void draw_replacement_bitmap(const GrReplacements::ReplacementInfo* ri,
                                            SkCanvas* canvas,
                                            const SkMatrix& initialMatrix) {
     SkRect src = SkRect::Make(ri->fSrcRect);
     SkRect dst = SkRect::MakeXYWH(SkIntToScalar(ri->fPos.fX),
                                   SkIntToScalar(ri->fPos.fY),
@@ skipping 42 matching lines @@
             SkRect query = { 0, 0, 0, 0 };
             (void)fCanvas->getClipBounds(&query);
 
             bbh->search(query, &fOps);
 
             for (fIndex = 0; fIndex < fOps.count(); ++fIndex) {
                 if (fCallback && fCallback->abortDrawing()) {
                     return;
                 }
 
-                record->visit<void>((uintptr_t)fOps[fIndex], *this);
+                record->visit<void>(fOps[fIndex], *this);
             }
 
         } else {
             for (fIndex = 0; fIndex < (int) record->count(); ++fIndex) {
                 if (fCallback && fCallback->abortDrawing()) {
                     return;
                 }
 
                 record->visit<void>(fIndex, *this);
             }
         }
     }
 
     // Same as Draw for all ops except DrawPicture and SaveLayer.
     template <typename T> void operator()(const T& r) {
         this->INHERITED::operator()(r);
     }
     void operator()(const SkRecords::DrawPicture& dp) {
         SkAutoCanvasMatrixPaint acmp(fCanvas, dp.matrix, dp.paint, dp.picture->cullRect());
 
         // Draw sub-pictures with the same replacement list but a different picture
         ReplaceDraw draw(fCanvas, dp.picture, fReplacements, fInitialMatrix, fCallback);
 
         draw.draw();
     }
     void operator()(const SkRecords::SaveLayer& sl) {
-        
+
         // For a saveLayer command, check if it can be replaced by a drawBitmap
         // call and, if so, draw it and then update the current op index accordingly.
         size_t startOffset;
         if (fOps.count()) {
-            startOffset = (uintptr_t)fOps[fIndex];
+            startOffset = fOps[fIndex];
         } else {
             startOffset = fIndex;
         }
 
         const GrReplacements::ReplacementInfo* ri = fReplacements->lookupByStart(
-                                                            fPicture->uniqueID(), 
-                                                            startOffset, 
+                                                            fPicture->uniqueID(),
+                                                            startOffset,
                                                             fCanvas->getTotalMatrix());
 
         if (ri) {
             draw_replacement_bitmap(ri, fCanvas, fInitialMatrix);
 
             if (fPicture->fBBH.get()) {
-                while ((uintptr_t)fOps[fIndex] < ri->fStop) {
+                while (fOps[fIndex] < ri->fStop) {
                     ++fIndex;
                 }
-                SkASSERT((uintptr_t)fOps[fIndex] == ri->fStop);
+                SkASSERT(fOps[fIndex] == ri->fStop);
             } else {
                 fIndex = ri->fStop;
             }
             return;
         }
 
         // This is a fail for layer hoisting
         this->INHERITED::operator()(sl);
     }
 
 private:
     SkCanvas*              fCanvas;
     const SkPicture*       fPicture;
     const GrReplacements*  fReplacements;
     const SkMatrix         fInitialMatrix;
     SkDrawPictureCallback* fCallback;
 
-    SkTDArray<void*>       fOps;
+    SkTDArray<unsigned>    fOps;
     int                    fIndex;
 
     typedef Draw INHERITED;
 };
 
 void GrRecordReplaceDraw(const SkPicture* picture,
                          SkCanvas* canvas,
                          const GrReplacements* replacements,
                          const SkMatrix& initialMatrix,
                          SkDrawPictureCallback* callback) {
     SkAutoCanvasRestore saveRestore(canvas, true /*save now, restore at exit*/);
 
     ReplaceDraw draw(canvas, picture, replacements, initialMatrix, callback);
 
     draw.draw();
 }