Revert of Convert BBH APIs to use SkRect.

src/core/SkPicturePlayback.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 "SkCanvas.h"
 #include "SkPatchUtils.h"
 #include "SkPictureData.h"
@@ skipping 53 matching lines @@
 // FIXME: SkBitmaps are stateful, so we need to copy them to play back in multiple threads.
 static SkBitmap shallow_copy(const SkBitmap& bitmap) {
     return bitmap;
 }
 
 const SkPicture::OperationList* SkPicturePlayback::getActiveOps(const SkCanvas* canvas) {
 
     if (fUseBBH) {
         SkRect clipBounds;
         if (canvas->getClipBounds(&clipBounds)) {
-            return fPictureData->getActiveOps(clipBounds);
+            SkIRect query;
+            clipBounds.roundOut(&query);
+
+            return fPictureData->getActiveOps(query);
         }
-    }
+    } 
 
     return NULL;
 }
 
 // Initialize the state tree iterator. Return false if there is nothing left to draw.
-bool SkPicturePlayback::initIterator(SkPictureStateTree::Iterator* iter,
+bool SkPicturePlayback::initIterator(SkPictureStateTree::Iterator* iter, 
                                      SkCanvas* canvas,
                                      const SkPicture::OperationList *activeOpsList) {
 
     if (NULL != activeOpsList) {
         if (0 == activeOpsList->numOps()) {
             return false;  // nothing to draw
         }
 
         fPictureData->initIterator(iter, activeOpsList->fOps, canvas);
     }
@@ skipping 69 matching lines @@
             SkipIterTo(&it, &reader, fCurOffset + size);
             continue;
         }
 
         this->handleOp(&reader, op, size, canvas, initialMatrix);
 
         StepIterator(&it, &reader);
     }
 }
 
-void SkPicturePlayback::handleOp(SkReader32* reader,
-                                 DrawType op,
-                                 uint32_t size,
+void SkPicturePlayback::handleOp(SkReader32* reader, 
+                                 DrawType op, 
+                                 uint32_t size, 
                                  SkCanvas* canvas,
                                  const SkMatrix& initialMatrix) {
     switch (op) {
         case CLIP_PATH: {
             const SkPath& path = fPictureData->getPath(reader);
             uint32_t packed = reader->readInt();
             SkRegion::Op regionOp = ClipParams_unpackRegionOp(packed);
             bool doAA = ClipParams_unpackDoAA(packed);
             size_t offsetToRestore = reader->readInt();
             SkASSERT(!offsetToRestore || offsetToRestore >= reader->offset());
@@ skipping 115 matching lines @@
         } break;
         case DRAW_OVAL: {
             const SkPaint& paint = *fPictureData->getPaint(reader);
             canvas->drawOval(reader->skipT<SkRect>(), paint);
         } break;
         case DRAW_PAINT:
             canvas->drawPaint(*fPictureData->getPaint(reader));
             break;
         case DRAW_PATCH: {
             const SkPaint& paint = *fPictureData->getPaint(reader);
-
+            
             const SkPoint* cubics = (const SkPoint*)reader->skip(SkPatchUtils::kNumCtrlPts *
                                                                  sizeof(SkPoint));
             uint32_t flag = reader->readInt();
             const SkColor* colors = NULL;
             if (flag & DRAW_VERTICES_HAS_COLORS) {
                 colors = (const SkColor*)reader->skip(SkPatchUtils::kNumCorners * sizeof(SkColor));
             }
             const SkPoint* texCoords = NULL;
             if (flag & DRAW_VERTICES_HAS_TEXS) {
                 texCoords = (const SkPoint*)reader->skip(SkPatchUtils::kNumCorners *
@@ skipping 194 matching lines @@
         case TRANSLATE: {
             SkScalar dx = reader->readScalar();
             SkScalar dy = reader->readScalar();
             canvas->translate(dx, dy);
         } break;
         default:
             SkASSERT(0);
     }
 }