De-parameterize SkNextDatumFunction.

src/core/SkTileGrid.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTileGrid.h"
+#include "SkPictureStateTree.h"
 
-SkTileGrid::SkTileGrid(int xTileCount, int yTileCount, const SkTileGridFactory::TileGridInfo& info,
-                       SkTileGridNextDatumFunctionPtr nextDatumFunction) {
+SkTileGrid::SkTileGrid(int xTileCount, int yTileCount, const SkTileGridFactory::TileGridInfo& info) {
     fXTileCount = xTileCount;
     fYTileCount = yTileCount;
     fInfo = info;
     // Margin is offset by 1 as a provision for AA and
     // to cancel-out the outset applied by getClipDeviceBounds.
     fInfo.fMargin.fHeight++;
     fInfo.fMargin.fWidth++;
     fTileCount = fXTileCount * fYTileCount;
     fInsertionCount = 0;
     fGridBounds = SkIRect::MakeXYWH(0, 0, fInfo.fTileInterval.width() * fXTileCount,
         fInfo.fTileInterval.height() * fYTileCount);
-    fNextDatumFunction = nextDatumFunction;
     fTileData = SkNEW_ARRAY(SkTDArray<void *>, fTileCount);
 }
 
 SkTileGrid::~SkTileGrid() {
     SkDELETE_ARRAY(fTileData);
 }
 
 int SkTileGrid::tileCount(int x, int y) {
     return this->tile(x, y).count();
 }
@@ skipping 27 matching lines @@
         fYTileCount -1), 0);
 
     for (int x = minTileX; x <= maxTileX; x++) {
         for (int y = minTileY; y <= maxTileY; y++) {
             this->tile(x, y).push(data);
         }
     }
     fInsertionCount++;
 }
 
+static void* next_datum(const SkTDArray<void*>** tileData,
+                        SkAutoSTArray<SkTileGrid::kStackAllocationTileCount, int>& tileIndices) {
+    SkPictureStateTree::Draw* minVal = NULL;
+    int tileCount = tileIndices.count();
+    int minIndex = tileCount;
+    int maxIndex = 0;
+    // Find the next Datum; track where it's found so we reduce the size of the second loop.
+    for (int tile = 0; tile < tileCount; ++tile) {
+        int pos = tileIndices[tile];
+        if (pos != SkTileGrid::kTileFinished) {
+            SkPictureStateTree::Draw* candidate = (SkPictureStateTree::Draw*)(*tileData[tile])[pos];
+            if (NULL == minVal || (*candidate) < (*minVal)) {
+                minVal = candidate;
+                minIndex = tile;
+                maxIndex = tile;
+            } else if (!((*minVal) < (*candidate))) {
+                // We don't require operator==; if !(candidate<minVal) && !(minVal<candidate),
+                // candidate==minVal and we have to add this tile to the range searched.
+                maxIndex = tile;
+            }
+        }
+    }
+    // Increment indices past the next datum
+    if (minVal != NULL) {
+        for (int tile = minIndex; tile <= maxIndex; ++tile) {
+            int pos = tileIndices[tile];
+            if (pos != SkTileGrid::kTileFinished && (*tileData[tile])[pos] == minVal) {
+                if (++(tileIndices[tile]) >= tileData[tile]->count()) {
+                    tileIndices[tile] = SkTileGrid::kTileFinished;
+                }
+            }
+        }
+        return minVal;
+    }
+    return NULL;
+}
+
 void SkTileGrid::search(const SkIRect& query, SkTDArray<void*>* results) const {
     SkIRect adjustedQuery = query;
     // The inset is to counteract the outset that was applied in 'insert'
     // The outset/inset is to optimize for lookups of size
     // 'tileInterval + 2 * margin' that are aligned with the tile grid.
     adjustedQuery.inset(fInfo.fMargin.width(), fInfo.fMargin.height());
     adjustedQuery.offset(fInfo.fOffset);
     adjustedQuery.sort();  // in case the inset inverted the rectangle
     // Convert the query rectangle from device coordinates to tile coordinates
     // by rounding outwards to the nearest tile boundary so that the resulting tile
@@ skipping 20 matching lines @@
         SkAutoSTArray<kStackAllocationTileCount, SkTDArray<void *>*> storage(queryTileCount);
         const SkTDArray<void *>** tileRange = const_cast<const SkTDArray<void*>**>(storage.get());
         int tile = 0;
         for (int x = tileStartX; x < tileEndX; ++x) {
             for (int y = tileStartY; y < tileEndY; ++y) {
                 tileRange[tile] = &this->tile(x, y);
                 curPositions[tile] = tileRange[tile]->count() ? 0 : kTileFinished;
                 ++tile;
             }
         }
-        void *nextElement;
-        while(NULL != (nextElement = fNextDatumFunction(tileRange, curPositions))) {
+        while(void* nextElement = next_datum(tileRange, curPositions)) {
             results->push(nextElement);
         }
     }
 }
 
 void SkTileGrid::clear() {
     for (int i = 0; i < fTileCount; i++) {
         fTileData[i].reset();
     }
 }
 
 int SkTileGrid::getCount() const {
     return fInsertionCount;
 }
 
 void SkTileGrid::rewindInserts() {
     SkASSERT(fClient);
     for (int i = 0; i < fTileCount; ++i) {
         while (!fTileData[i].isEmpty() && fClient->shouldRewind(fTileData[i].top())) {
             fTileData[i].pop();
         }
     }
 }