rename GrDrawTargetCaps to GrCaps

tests/GLProgramsTest.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.
  */
 
 // This is a GPU-backend specific test. It relies on static intializers to work
 
@@ skipping 76 matching lines @@
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(BigKeyProcessor);
 
 GrFragmentProcessor* BigKeyProcessor::TestCreate(SkRandom*,
                                                  GrContext*,
-                                                 const GrDrawTargetCaps&,
+                                                 const GrCaps&,
                                                  GrTexture*[]) {
     return BigKeyProcessor::Create();
 }
 
 /*
  * Begin test code
  */
 static const int kRenderTargetHeight = 1;
 static const int kRenderTargetWidth = 1;
 
 static GrRenderTarget* random_render_target(GrContext* context, SkRandom* random,
-                                            const GrDrawTargetCaps* caps) {
+                                            const GrCaps* caps) {
     // setup render target
     GrTextureParams params;
     GrSurfaceDesc texDesc;
     texDesc.fWidth = kRenderTargetWidth;
     texDesc.fHeight = kRenderTargetHeight;
     texDesc.fFlags = kRenderTarget_GrSurfaceFlag;
     texDesc.fConfig = kRGBA_8888_GrPixelConfig;
     texDesc.fOrigin = random->nextBool() == true ? kTopLeft_GrSurfaceOrigin :
                                                    kBottomLeft_GrSurfaceOrigin;
     texDesc.fSampleCnt = random->nextBool() == true ? SkTMin(4, caps->maxSampleCount()) : 0;
 
     GrUniqueKey key;
     static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
     GrUniqueKey::Builder builder(&key, kDomain, 2);
     builder[0] = texDesc.fOrigin;
     builder[1] = texDesc.fSampleCnt;
     builder.finish();
 
     GrTexture* texture = context->textureProvider()->findAndRefTextureByUniqueKey(key);
     if (!texture) {
         texture = context->textureProvider()->createTexture(texDesc, true);
         if (texture) {
             context->textureProvider()->assignUniqueKeyToTexture(key, texture);
         }
     }
     return texture ? texture->asRenderTarget() : NULL;
 }
 
-static void set_random_xpf(GrContext* context, const GrDrawTargetCaps& caps,
+static void set_random_xpf(GrContext* context, const GrCaps& caps,
                            GrPipelineBuilder* pipelineBuilder, SkRandom* random,
                            GrTexture* dummyTextures[]) {
     SkAutoTUnref<const GrXPFactory> xpf(
         GrProcessorTestFactory<GrXPFactory>::CreateStage(random, context, caps, dummyTextures));
     SkASSERT(xpf);
     pipelineBuilder->setXPFactory(xpf.get());
 }
 
 static void set_random_color_coverage_stages(GrGLGpu* gpu,
                                              GrPipelineBuilder* pipelineBuilder,
@@ skipping 164 matching lines @@
             }
 #endif
             GrTestTarget target;
             context->getTestTarget(&target);
             REPORTER_ASSERT(reporter, target.target()->programUnitTest(maxStages));
         }
     }
 }
 
 #endif