Revert of Convert BBH APIs to use SkRect.

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"
 
 SkTileGrid::SkTileGrid(int xTiles, int yTiles, const SkTileGridFactory::TileGridInfo& info)
     : fXTiles(xTiles)
     , fYTiles(yTiles)
     , fInfo(info)
     , fCount(0)
     , fTiles(SkNEW_ARRAY(SkTDArray<Entry>, xTiles * yTiles)) {
     // 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++;
 }
 
 SkTileGrid::~SkTileGrid() {
     SkDELETE_ARRAY(fTiles);
 }
 
-void SkTileGrid::insert(void* data, const SkRect& fbounds, bool) {
-    SkASSERT(!fbounds.isEmpty());
-    SkIRect dilatedBounds;
-    if (fbounds.isLargest()) {
-        // Dilating the largest SkIRect will overflow.  Other nearly-largest rects may overflow too,
-        // but we don't make active use of them like we do the largest.
-        dilatedBounds.setLargest();
-    } else {
-        fbounds.roundOut(&dilatedBounds);
+void SkTileGrid::insert(void* data, const SkIRect& bounds, bool) {
+    SkASSERT(!bounds.isEmpty());
+    SkIRect dilatedBounds = bounds;
+
+    // Dilating the largest SkIRect will overflow.  Other nearly-largest rects may overflow too,
+    // but we don't make active use of them like we do the largest.
+    if (!bounds.isLargest()) {
         dilatedBounds.outset(fInfo.fMargin.width(), fInfo.fMargin.height());
         dilatedBounds.offset(fInfo.fOffset);
     }
 
     const SkIRect gridBounds =
         { 0, 0, fInfo.fTileInterval.width() * fXTiles, fInfo.fTileInterval.height() * fYTiles };
     if (!SkIRect::Intersects(dilatedBounds, gridBounds)) {
         return;
     }
 
@@ skipping 17 matching lines @@
 static int divide_ceil(int x, int y) {
     return (x + y - 1) / y;
 }
 
 // Number of tiles for which data is allocated on the stack in
 // SkTileGrid::search. If malloc becomes a bottleneck, we may consider
 // increasing this number. Typical large web page, say 2k x 16k, would
 // require 512 tiles of size 256 x 256 pixels.
 static const int kStackAllocationTileCount = 1024;
 
-void SkTileGrid::search(const SkRect& query, SkTDArray<void*>* results) const {
-    SkIRect adjusted;
-    query.roundOut(&adjusted);
+void SkTileGrid::search(const SkIRect& query, SkTDArray<void*>* results) const {
+    SkIRect adjusted = 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.
     adjusted.inset(fInfo.fMargin.width(), fInfo.fMargin.height());
     adjusted.offset(fInfo.fOffset);
     adjusted.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 75 matching lines @@
 }
 
 void SkTileGrid::rewindInserts() {
     SkASSERT(fClient);
     for (int i = 0; i < fXTiles * fYTiles; i++) {
         while (!fTiles[i].isEmpty() && fClient->shouldRewind(fTiles[i].top().data)) {
             fTiles[i].pop();
         }
     }
 }