Make rrects.cpp compile in no-gpu mode

gm/rrects.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 "gm.h"
+#if SK_SUPPORT_GPU
 #include "GrTest.h"
+#include "effects/GrRRectEffect.h"
+#endif
 #include "SkDevice.h"
 #include "SkRRect.h"
-#include "effects/GrRRectEffect.h"
 
 namespace skiagm {
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class RRectGM : public GM {
 public:
     enum Type {
         kBW_Draw_Type,
         kAA_Draw_Type,
@@ skipping 33 matching lines @@
 
     virtual uint32_t onGetFlags() const SK_OVERRIDE {
         if (kEffect_Type == fType) {
             return kGPUOnly_Flag;
         } else {
             return 0;
         }
     }
 
     virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+        int numRRects = kNumRRects;
+#if SK_SUPPORT_GPU
         SkBaseDevice* device = canvas->getTopDevice();
         GrContext* context = NULL;
         GrRenderTarget* rt = device->accessRenderTarget();
         if (NULL != rt) {
             context = rt->getContext();
         }
         if (kEffect_Type == fType && NULL == context) {
             return;
         }
+        if (kEffect_Type == fType) {
+            numRRects *= GrRRectEffect::kEdgeTypeCnt;
+        }
+#endif
 
         SkPaint paint;
         if (kAA_Draw_Type == fType) {
             paint.setAntiAlias(true);
         }
         
         static const SkRect kMaxTileBound = SkRect::MakeWH(SkIntToScalar(kTileX), SkIntToScalar(kTileY));
 
         int curRRect = 0;
-        int numRRects = kNumRRects;
-        if (kEffect_Type == fType) {
-            numRRects *= GrRRectEffect::kEdgeTypeCnt;
-        }
         for (int y = 1; y < kImageHeight; y += kTileY) {
             for (int x = 1; x < kImageWidth; x += kTileX) {
                 if (curRRect >= numRRects) {
                     break;
                 }
                 int rrectIdx = curRRect % kNumRRects;
                 SkASSERT(kMaxTileBound.contains(fRRects[rrectIdx].getBounds()));
 
                 canvas->save();
                     canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
                     if (kEffect_Type == fType) {
+#if SK_SUPPORT_GPU
                         GrTestTarget tt;
                         context->getTestTarget(&tt);
                         if (NULL == tt.target()) {
                             SkDEBUGFAIL("Couldn't get Gr test target.");
                             return;
                         }
                         GrDrawState* drawState = tt.target()->drawState();
                         
                         SkRRect rrect = fRRects[rrectIdx];
                         rrect.offset(SkIntToScalar(x), SkIntToScalar(y));
                         GrRRectEffect::EdgeType edgeType = (GrRRectEffect::EdgeType)
                                                             (curRRect / kNumRRects);
                         SkAutoTUnref<GrEffectRef> effect(GrRRectEffect::Create(edgeType, rrect));
                         if (effect) {
                             drawState->addCoverageEffect(effect);
                             drawState->setIdentityViewMatrix();
                             drawState->setRenderTarget(rt);
                             drawState->setColor(0xff000000);
 
                             SkRect bounds = rrect.getBounds();
                             bounds.outset(2.f, 2.f);
                             
                             tt.target()->drawSimpleRect(bounds);
                         }
+#endif
                     } else if (kBW_Clip_Type == fType || kAA_Clip_Type == fType) {
                         bool aaClip = (kAA_Clip_Type == fType);
                         canvas->clipRRect(fRRects[rrectIdx], SkRegion::kReplace_Op, aaClip);
                         canvas->drawRect(kMaxTileBound, paint);
                     } else {
                         canvas->drawRRect(fRRects[rrectIdx], paint);
                     }
                     ++curRRect;
                 canvas->restore();
             }
@@ skipping 81 matching lines @@
     { { 0, 0 }, { 0, 0 }, { 20, 20 }, { 20, 20 } },
     { { 20, 20 }, { 0, 0 }, { 0, 0 }, { 20, 20 } },
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 DEF_GM( return new RRectGM(RRectGM::kAA_Draw_Type); )
 DEF_GM( return new RRectGM(RRectGM::kBW_Draw_Type); )
 DEF_GM( return new RRectGM(RRectGM::kAA_Clip_Type); )
 DEF_GM( return new RRectGM(RRectGM::kBW_Clip_Type); )
+#if SK_SUPPORT_GPU
 DEF_GM( return new RRectGM(RRectGM::kEffect_Type); )
+#endif
 
 }