Rename GPUAccelData to GrAccelData

src/gpu/GrPictureUtils.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 "GrPictureUtils.h"
 #include "SkCanvasPriv.h"
 #include "SkDevice.h"
 #include "SkDraw.h"
 #include "SkPaintPriv.h"
 #include "SkPictureData.h"
 #include "SkPicturePlayback.h"
 
-SkPicture::AccelData::Key GPUAccelData::ComputeAccelDataKey() {
+SkPicture::AccelData::Key GrAccelData::ComputeAccelDataKey() {
     static const SkPicture::AccelData::Key gGPUID = SkPicture::AccelData::GenerateDomain();
 
     return gGPUID;
 }
 
 // The GrGather device performs GPU-backend-specific preprocessing on
-// a picture. The results are stored in a GPUAccelData.
+// a picture. The results are stored in a GrAccelData.
 //
 // Currently the only interesting work is done in drawDevice (i.e., when a
 // saveLayer is collapsed back into its parent) and, maybe, in onCreateDevice.
 // All the current work could be done much more efficiently by just traversing the
 // raw op codes in the SkPicture (although we would still need to replay all the
 // clip calls).
 class GrGatherDevice : public SkBaseDevice {
 public:
     SK_DECLARE_INST_COUNT(GrGatherDevice)
 
-    GrGatherDevice(int width, int height, SkPicturePlayback* playback, GPUAccelData* accelData,
+    GrGatherDevice(int width, int height, SkPicturePlayback* playback, GrAccelData* accelData,
                    int saveLayerDepth) {
         fPlayback = playback;
         fSaveLayerDepth = saveLayerDepth;
         fInfo.fValid = true;
         fInfo.fSize.set(width, height);
         fInfo.fPaint = NULL;
         fInfo.fSaveLayerOpID = fPlayback->curOpID();
         fInfo.fRestoreOpID = 0;
         fInfo.fHasNestedLayers = false;
         fInfo.fIsNested = (2 == fSaveLayerDepth);
@@ skipping 119 matching lines @@
         return false;
     }
 
 private:
     // The playback object driving this rendering
     SkPicturePlayback *fPlayback;
 
     SkBitmap fEmptyBitmap; // legacy -- need to remove
 
     // All information gathered during the gather process is stored here
-    GPUAccelData* fAccelData;
+    GrAccelData* fAccelData;
 
     // true if this device has already been drawn back to its parent(s) at least
     // once.
     bool   fAlreadyDrawn;
 
     // The information regarding the saveLayer call this device represents.
-    GPUAccelData::SaveLayerInfo fInfo;
+    GrAccelData::SaveLayerInfo fInfo;
 
     // The depth of this device in the saveLayer stack
     int fSaveLayerDepth;
 
     virtual void replaceBitmapBackendForRasterSurface(const SkBitmap&) SK_OVERRIDE {
         NotSupported();
     }
 
     virtual SkBaseDevice* onCreateDevice(const SkImageInfo& info, Usage usage) SK_OVERRIDE {
         // we expect to only get called via savelayer, in which case it is fine.
@@ skipping 60 matching lines @@
             picture->draw(this);
         }
     }
 
 private:
     typedef SkCanvas INHERITED;
 };
 
 // GatherGPUInfo is only intended to be called within the context of SkGpuDevice's
 // EXPERIMENTAL_optimize method.
-void GatherGPUInfo(const SkPicture* pict, GPUAccelData* accelData) {
+void GatherGPUInfo(const SkPicture* pict, GrAccelData* accelData) {
     if (NULL == pict || 0 == pict->width() || 0 == pict->height()) {
         return ;
     }
 
     // BBH-based rendering doesn't re-issue many of the operations the gather
     // process cares about (e.g., saves and restores) so it must be disabled.
     SkPicturePlayback playback(pict);
     playback.setUseBBH(false);
 
     GrGatherDevice device(pict->width(), pict->height(), &playback, accelData, 0);
     GrGatherCanvas canvas(&device);
 
     canvas.clipRect(SkRect::MakeWH(SkIntToScalar(pict->width()),
                                    SkIntToScalar(pict->height())),
                     SkRegion::kIntersect_Op, false);
     playback.draw(&canvas, NULL);
 }