Rename GPUAccelData to GrAccelData

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 1836 matching lines @@
     return SkSurface::NewRenderTarget(fContext, info, fRenderTarget->numSamples());
 }
 
 void SkGpuDevice::EXPERIMENTAL_optimize(const SkPicture* picture) {
     fContext->getLayerCache()->processDeletedPictures();
 
     if (NULL != picture->fData.get() && !picture->fData->suitableForLayerOptimization()) {
         return;
     }
 
-    SkPicture::AccelData::Key key = GPUAccelData::ComputeAccelDataKey();
+    SkPicture::AccelData::Key key = GrAccelData::ComputeAccelDataKey();
 
     const SkPicture::AccelData* existing = picture->EXPERIMENTAL_getAccelData(key);
     if (NULL != existing) {
         return;
     }
 
-    SkAutoTUnref<GPUAccelData> data(SkNEW_ARGS(GPUAccelData, (key)));
+    SkAutoTUnref<GrAccelData> data(SkNEW_ARGS(GrAccelData, (key)));
 
     picture->EXPERIMENTAL_addAccelData(data);
 
     GatherGPUInfo(picture, data);
 
     fContext->getLayerCache()->trackPicture(picture);
 }
 
 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();
 }
 
 bool SkGpuDevice::EXPERIMENTAL_drawPicture(SkCanvas* mainCanvas, const SkPicture* picture,
                                            const SkMatrix* matrix, const SkPaint* paint) {
     // todo: should handle these natively
     if (matrix || paint) {
         return false;
     }
 
     fContext->getLayerCache()->processDeletedPictures();
 
-    SkPicture::AccelData::Key key = GPUAccelData::ComputeAccelDataKey();
+    SkPicture::AccelData::Key key = GrAccelData::ComputeAccelDataKey();
 
     const SkPicture::AccelData* data = picture->EXPERIMENTAL_getAccelData(key);
     if (NULL == data) {
         return false;
     }
 
-    const GPUAccelData *gpuData = static_cast<const GPUAccelData*>(data);
+    const GrAccelData *gpuData = static_cast<const GrAccelData*>(data);
 
     if (0 == gpuData->numSaveLayers()) {
         return false;
     }
 
     SkAutoTArray<bool> pullForward(gpuData->numSaveLayers());
     for (int i = 0; i < gpuData->numSaveLayers(); ++i) {
         pullForward[i] = false;
     }
 
@@ skipping 12 matching lines @@
     // is used to limit which clips are pre-rendered.
     static const int kSaveLayerMaxSize = 256;
 
     if (NULL != ops.get()) {
         // In this case the picture has been generated with a BBH so we use
         // the BBH to limit the pre-rendering to just the layers needed to cover
         // the region being drawn
         for (int i = 0; i < ops->numOps(); ++i) {
             uint32_t offset = ops->offset(i);
 
-            // For now we're saving all the layers in the GPUAccelData so they
+            // For now we're saving all the layers in the GrAccelData so they
             // can be nested. Additionally, the nested layers appear before
             // their parent in the list.
             for (int j = 0 ; j < gpuData->numSaveLayers(); ++j) {
-                const GPUAccelData::SaveLayerInfo& info = gpuData->saveLayerInfo(j);
+                const GrAccelData::SaveLayerInfo& info = gpuData->saveLayerInfo(j);
 
                 if (pullForward[j]) {
                     continue;            // already pulling forward
                 }
 
                 if (offset < info.fSaveLayerOpID || offset > info.fRestoreOpID) {
                     continue;            // the op isn't in this range
                 }
 
                 // 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;            // this layer is unsuitable
                 }
 
                 pullForward[j] = 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 GPUAccelData::SaveLayerInfo& info = gpuData->saveLayerInfo(j);
+            const GrAccelData::SaveLayerInfo& info = gpuData->saveLayerInfo(j);
 
             SkIRect layerRect = SkIRect::MakeXYWH(info.fOffset.fX,
                                                   info.fOffset.fY,
                                                   info.fSize.fWidth,
                                                   info.fSize.fHeight);
 
             if (!SkIRect::Intersects(query, layerRect)) {
                 continue;
             }
 
@@ skipping 11 matching lines @@
     }
 
     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 GPUAccelData::SaveLayerInfo& info = gpuData->saveLayerInfo(i);
+            const GrAccelData::SaveLayerInfo& info = gpuData->saveLayerInfo(i);
 
             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;
@@ skipping 117 matching lines @@
         layerCanvas->flush();
     }
 
     // Render the entire picture using new layers
     SkPictureReplacementPlayback playback(picture, &replacements, ops.get());
 
     playback.draw(mainCanvas, NULL);
 
     // unlock the layers
     for (int i = 0; i < gpuData->numSaveLayers(); ++i) {
-        const GPUAccelData::SaveLayerInfo& info = gpuData->saveLayerInfo(i);
+        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 
     // 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
 
     return true;
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }