Convert BBH APIs to use SkRect.

src/gpu/SkGpuDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGpuDevice.h"
 
 #include "effects/GrBicubicEffect.h"
@@ skipping 1599 matching lines @@
 
 void SkGpuDevice::drawVertices(const SkDraw& draw, SkCanvas::VertexMode vmode,
                               int vertexCount, const SkPoint vertices[],
                               const SkPoint texs[], const SkColor colors[],
                               SkXfermode* xmode,
                               const uint16_t indices[], int indexCount,
                               const SkPaint& paint) {
     CHECK_SHOULD_DRAW(draw, false);
 
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::drawVertices", fContext);
-    
+
     const uint16_t* outIndices;
     SkAutoTDeleteArray<uint16_t> outAlloc(NULL);
     GrPrimitiveType primType;
     GrPaint grPaint;
 
     // If both textures and vertex-colors are NULL, strokes hairlines with the paint's color.
     if ((NULL == texs || NULL == paint.getShader()) && NULL == colors) {
-        
+
         texs = NULL;
-        
+
         SkPaint copy(paint);
         copy.setStyle(SkPaint::kStroke_Style);
         copy.setStrokeWidth(0);
-        
+
         // we ignore the shader if texs is null.
         SkPaint2GrPaintNoShader(this->context(), copy, SkColor2GrColor(copy.getColor()),
                                 NULL == colors, &grPaint);
 
         primType = kLines_GrPrimitiveType;
         int triangleCount = 0;
         int n = (NULL == indices) ? vertexCount : indexCount;
         switch (vmode) {
             case SkCanvas::kTriangles_VertexMode:
                 triangleCount = n / 3;
                 break;
             case SkCanvas::kTriangleStrip_VertexMode:
             case SkCanvas::kTriangleFan_VertexMode:
                 triangleCount = n - 2;
                 break;
         }
-        
+
         VertState       state(vertexCount, indices, indexCount);
         VertState::Proc vertProc = state.chooseProc(vmode);
-        
+
         //number of indices for lines per triangle with kLines
         indexCount = triangleCount * 6;
-        
+
         outAlloc.reset(SkNEW_ARRAY(uint16_t, indexCount));
         outIndices = outAlloc.get();
         uint16_t* auxIndices = outAlloc.get();
         int i = 0;
         while (vertProc(&state)) {
             auxIndices[i]     = state.f0;
             auxIndices[i + 1] = state.f1;
             auxIndices[i + 2] = state.f1;
             auxIndices[i + 3] = state.f2;
             auxIndices[i + 4] = state.f2;
             auxIndices[i + 5] = state.f0;
             i += 6;
         }
     } else {
         outIndices = indices;
         primType = gVertexMode2PrimitiveType[vmode];
-        
+
         if (NULL == texs || NULL == paint.getShader()) {
             SkPaint2GrPaintNoShader(this->context(), paint, SkColor2GrColor(paint.getColor()),
                                     NULL == colors, &grPaint);
         } else {
             SkPaint2GrPaintShader(this->context(), paint, NULL == colors, &grPaint);
         }
     }
 
 #if 0
     if (NULL != xmode && NULL != texs && NULL != colors) {
@@ skipping 187 matching lines @@
 
 static void wrap_texture(GrTexture* texture, int width, int height, SkBitmap* result) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
     result->setInfo(info);
     result->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref();
 }
 
 // Return true if any layers are suitable for hoisting
 bool SkGpuDevice::FindLayersToHoist(const GrAccelData *gpuData,
                                     const SkPicture::OperationList* ops,
-                                    const SkIRect& query,
+                                    const SkRect& query,
                                     bool* pullForward) {
     bool anyHoisted = false;
 
     // Layer hoisting pre-renders the entire layer since it will be cached and potentially
     // reused with different clips (e.g., in different tiles). Because of this the
     // clip will not be limiting the size of the pre-rendered layer. kSaveLayerMaxSize
     // is used to limit which clips are pre-rendered.
     static const int kSaveLayerMaxSize = 256;
 
     if (NULL != ops) {
@@ skipping 29 matching lines @@
                 pullForward[j] = true;
                 anyHoisted = true;
             }
         }
     } else {
         // In this case there is no BBH associated with the picture. Pre-render
         // all the layers that intersect the drawn region
         for (int j = 0; j < gpuData->numSaveLayers(); ++j) {
             const GrAccelData::SaveLayerInfo& info = gpuData->saveLayerInfo(j);
 
-            SkIRect layerRect = SkIRect::MakeXYWH(info.fOffset.fX,
-                                                  info.fOffset.fY,
-                                                  info.fSize.fWidth,
-                                                  info.fSize.fHeight);
+            SkRect layerRect = SkRect::MakeXYWH(SkIntToScalar(info.fOffset.fX),
+                                                SkIntToScalar(info.fOffset.fY),
+                                                SkIntToScalar(info.fSize.fWidth),
+                                                SkIntToScalar(info.fSize.fHeight));
 
-            if (!SkIRect::Intersects(query, layerRect)) {
+            if (!SkRect::Intersects(query, layerRect)) {
                 continue;
             }
 
             // TODO: once this code is more stable unsuitable layers can
             // just be omitted during the optimization stage
             if (!info.fValid ||
                 kSaveLayerMaxSize < info.fSize.fWidth ||
                 kSaveLayerMaxSize < info.fSize.fHeight ||
                 info.fIsNested) {
                 continue;
@@ skipping 31 matching lines @@
 
     SkAutoTArray<bool> pullForward(gpuData->numSaveLayers());
     for (int i = 0; i < gpuData->numSaveLayers(); ++i) {
         pullForward[i] = false;
     }
 
     SkRect clipBounds;
     if (!mainCanvas->getClipBounds(&clipBounds)) {
         return true;
     }
-    SkIRect query;
-    clipBounds.roundOut(&query);
 
-    SkAutoTDelete<const SkPicture::OperationList> ops(picture->EXPERIMENTAL_getActiveOps(query));
+    SkAutoTDelete<const SkPicture::OperationList> ops(
+            picture->EXPERIMENTAL_getActiveOps(clipBounds));
 
-    if (!FindLayersToHoist(gpuData, ops.get(), query, pullForward.get())) {
+    if (!FindLayersToHoist(gpuData, ops.get(), clipBounds, pullForward.get())) {
         return false;
     }
 
     SkPictureReplacementPlayback::PlaybackReplacements replacements;
 
     SkTDArray<GrCachedLayer*> atlased, nonAtlased;
     atlased.setReserve(gpuData->numSaveLayers());
 
     // Generate the layer and/or ensure it is locked
     for (int i = 0; i < gpuData->numSaveLayers(); ++i) {
         if (pullForward[i]) {
             const GrAccelData::SaveLayerInfo& info = gpuData->saveLayerInfo(i);
 
-            GrCachedLayer* layer = fContext->getLayerCache()->findLayerOrCreate(picture->uniqueID(), 
-                                                                                info.fSaveLayerOpID, 
-                                                                                info.fRestoreOpID, 
+            GrCachedLayer* layer = fContext->getLayerCache()->findLayerOrCreate(picture->uniqueID(),
+                                                                                info.fSaveLayerOpID,
+                                                                                info.fRestoreOpID,
                                                                                 info.fCTM);
 
             SkPictureReplacementPlayback::PlaybackReplacements::ReplacementInfo* layerInfo =
                                                                         replacements.push();
             layerInfo->fStart = info.fSaveLayerOpID;
             layerInfo->fStop = info.fRestoreOpID;
             layerInfo->fPos = info.fOffset;
 
             GrTextureDesc desc;
             desc.fFlags = kRenderTarget_GrTextureFlagBit;
             desc.fWidth = info.fSize.fWidth;
             desc.fHeight = info.fSize.fHeight;
             desc.fConfig = kSkia8888_GrPixelConfig;
             // TODO: need to deal with sample count
 
             bool needsRendering = fContext->getLayerCache()->lock(layer, desc,
                                                     info.fHasNestedLayers || info.fIsNested);
             if (NULL == layer->texture()) {
                 continue;
             }
 
             layerInfo->fBM = SkNEW(SkBitmap);  // fBM is allocated so ReplacementInfo can be POD
-            wrap_texture(layer->texture(), 
+            wrap_texture(layer->texture(),
                          !layer->isAtlased() ? desc.fWidth : layer->texture()->width(),
                          !layer->isAtlased() ? desc.fHeight : layer->texture()->height(),
                          layerInfo->fBM);
 
             SkASSERT(info.fPaint);
             layerInfo->fPaint = info.fPaint;
 
             layerInfo->fSrcRect = SkIRect::MakeXYWH(layer->rect().fLeft,
                                                     layer->rect().fTop,
                                                     layer->rect().width(),
@@ skipping 15 matching lines @@
     SkPictureReplacementPlayback playback(picture, &replacements, ops.get());
 
     playback.draw(mainCanvas, NULL);
 
     this->unlockLayers(picture);
 
     return true;
 }
 
 void SkGpuDevice::drawLayers(const SkPicture* picture,
-                             const SkTDArray<GrCachedLayer*>& atlased, 
+                             const SkTDArray<GrCachedLayer*>& atlased,
                              const SkTDArray<GrCachedLayer*>& nonAtlased) {
     // Render the atlased layers that require it
     if (atlased.count() > 0) {
         // All the atlased layers are rendered into the same GrTexture
         SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTargetDirect(
                                             atlased[0]->texture()->asRenderTarget(),
                                             SkSurface::kStandard_TextRenderMode,
                                             SkSurface::kDontClear_RenderTargetFlag));
 
         SkCanvas* atlasCanvas = surface->getCanvas();
@@ skipping 84 matching lines @@
         const GrAccelData::SaveLayerInfo& info = gpuData->saveLayerInfo(i);
 
         GrCachedLayer* layer = fContext->getLayerCache()->findLayer(picture->uniqueID(),
                                                                     info.fSaveLayerOpID,
                                                                     info.fRestoreOpID,
                                                                     info.fCTM);
         fContext->getLayerCache()->unlock(layer);
     }
 
 #if DISABLE_CACHING
-    // This code completely clears out the atlas. It is required when 
+    // This code completely clears out the atlas. It is required when
     // caching is disabled so the atlas doesn't fill up and force more
     // free floating layers
     fContext->getLayerCache()->purge(picture->uniqueID());
 
     fContext->getLayerCache()->purgeAll();
 #endif
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }