cc: Add software renderer pixel tests

cc/output/gl_renderer_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/output/gl_renderer.h"
 
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/test/fake_impl_proxy.h"
@@ skipping 37 matching lines @@
 
 namespace cc {
 
 #define EXPECT_PROGRAM_VALID(program_binding)                                  \
   do {                                                                         \
     EXPECT_TRUE(program_binding->program());                                   \
     EXPECT_TRUE(program_binding->initialized());                               \
   } while (false)
 
 // Explicitly named to be a friend in GLRenderer for shader access.
-class GLRendererShaderPixelTest : public PixelTest {
+class GLRendererShaderPixelTest : public GLRendererPixelTest {
  public:
   void TestShaders() {
-    ASSERT_FALSE(renderer_->IsContextLost());
-    EXPECT_PROGRAM_VALID(renderer_->GetTileCheckerboardProgram());
-    EXPECT_PROGRAM_VALID(renderer_->GetDebugBorderProgram());
-    EXPECT_PROGRAM_VALID(renderer_->GetSolidColorProgram());
-    EXPECT_PROGRAM_VALID(renderer_->GetSolidColorProgramAA());
+    ASSERT_FALSE(renderer()->IsContextLost());
+    EXPECT_PROGRAM_VALID(renderer()->GetTileCheckerboardProgram());
+    EXPECT_PROGRAM_VALID(renderer()->GetDebugBorderProgram());
+    EXPECT_PROGRAM_VALID(renderer()->GetSolidColorProgram());
+    EXPECT_PROGRAM_VALID(renderer()->GetSolidColorProgramAA());
     TestShadersWithTexCoordPrecision(TexCoordPrecisionMedium);
     TestShadersWithTexCoordPrecision(TexCoordPrecisionHigh);
-    ASSERT_FALSE(renderer_->IsContextLost());
+    ASSERT_FALSE(renderer()->IsContextLost());
   }
 
   void TestShadersWithTexCoordPrecision(TexCoordPrecision precision) {
-    EXPECT_PROGRAM_VALID(renderer_->GetTileProgram(precision));
-    EXPECT_PROGRAM_VALID(renderer_->GetTileProgramOpaque(precision));
-    EXPECT_PROGRAM_VALID(renderer_->GetTileProgramAA(precision));
-    EXPECT_PROGRAM_VALID(renderer_->GetTileProgramSwizzle(precision));
-    EXPECT_PROGRAM_VALID(renderer_->GetTileProgramSwizzleOpaque(precision));
-    EXPECT_PROGRAM_VALID(renderer_->GetTileProgramSwizzleAA(precision));
-    EXPECT_PROGRAM_VALID(renderer_->GetRenderPassProgram(precision));
-    EXPECT_PROGRAM_VALID(renderer_->GetRenderPassProgramAA(precision));
-    EXPECT_PROGRAM_VALID(renderer_->GetRenderPassMaskProgram(precision));
-    EXPECT_PROGRAM_VALID(renderer_->GetRenderPassMaskProgramAA(precision));
+    EXPECT_PROGRAM_VALID(renderer()->GetTileProgram(precision));
+    EXPECT_PROGRAM_VALID(renderer()->GetTileProgramOpaque(precision));
+    EXPECT_PROGRAM_VALID(renderer()->GetTileProgramAA(precision));
+    EXPECT_PROGRAM_VALID(renderer()->GetTileProgramSwizzle(precision));
+    EXPECT_PROGRAM_VALID(renderer()->GetTileProgramSwizzleOpaque(precision));
+    EXPECT_PROGRAM_VALID(renderer()->GetTileProgramSwizzleAA(precision));
+    EXPECT_PROGRAM_VALID(renderer()->GetRenderPassProgram(precision));
+    EXPECT_PROGRAM_VALID(renderer()->GetRenderPassProgramAA(precision));
+    EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskProgram(precision));
+    EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskProgramAA(precision));
     EXPECT_PROGRAM_VALID(
-        renderer_->GetRenderPassColorMatrixProgram(precision));
+        renderer()->GetRenderPassColorMatrixProgram(precision));
     EXPECT_PROGRAM_VALID(
-        renderer_->GetRenderPassMaskColorMatrixProgramAA(precision));
+        renderer()->GetRenderPassMaskColorMatrixProgramAA(precision));
     EXPECT_PROGRAM_VALID(
-        renderer_->GetRenderPassColorMatrixProgramAA(precision));
+        renderer()->GetRenderPassColorMatrixProgramAA(precision));
     EXPECT_PROGRAM_VALID(
-        renderer_->GetRenderPassMaskColorMatrixProgram(precision));
-    EXPECT_PROGRAM_VALID(renderer_->GetTextureProgram(precision));
-    EXPECT_PROGRAM_VALID(renderer_->GetTextureProgramFlip(precision));
-    EXPECT_PROGRAM_VALID(renderer_->GetTextureIOSurfaceProgram(precision));
-    EXPECT_PROGRAM_VALID(renderer_->GetVideoYUVProgram(precision));
+        renderer()->GetRenderPassMaskColorMatrixProgram(precision));
+    EXPECT_PROGRAM_VALID(renderer()->GetTextureProgram(precision));
+    EXPECT_PROGRAM_VALID(renderer()->GetTextureProgramFlip(precision));
+    EXPECT_PROGRAM_VALID(renderer()->GetTextureIOSurfaceProgram(precision));
+    EXPECT_PROGRAM_VALID(renderer()->GetVideoYUVProgram(precision));
     // This is unlikely to be ever true in tests due to usage of osmesa.
-    if (renderer_->Capabilities().using_egl_image)
-      EXPECT_PROGRAM_VALID(renderer_->GetVideoStreamTextureProgram(precision));
+    if (renderer()->Capabilities().using_egl_image)
+      EXPECT_PROGRAM_VALID(renderer()->GetVideoStreamTextureProgram(precision));
     else
-      EXPECT_FALSE(renderer_->GetVideoStreamTextureProgram(precision));
+      EXPECT_FALSE(renderer()->GetVideoStreamTextureProgram(precision));
   }
 };
 
 namespace {
 
 #if !defined(OS_ANDROID)
 TEST_F(GLRendererShaderPixelTest, AllShadersCompile) { TestShaders(); }
 #endif
 
 class FrameCountingMemoryAllocationSettingContext
@@ skipping 1312 matching lines @@
   }
 };
 
 TEST_F(MockOutputSurfaceTestWithSendCompositorFrame, DrawFrame) {
   EXPECT_CALL(output_surface_, SendFrameToParentCompositor(_)).Times(1);
   DrawFrame();
 }
 
 }  // namespace
 }  // namespace cc