Chromium -> Mojo roll.

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 <set>
 
 #include "cc/base/math_util.h"
 #include "cc/output/compositor_frame_metadata.h"
@@ skipping 79 matching lines @@
       return SkXfermode::kColor_Mode;
     case BLEND_MODE_LUMINOSITY:
       return SkXfermode::kLuminosity_Mode;
   }
   return SkXfermode::kSrcOver_Mode;
 }
 
 // Explicitly named to be a friend in GLRenderer for shader access.
 class GLRendererShaderPixelTest : public GLRendererPixelTest {
  public:
-  void TestShaders() {
+  void SetUp() override {
+    GLRendererPixelTest::SetUp();
     ASSERT_FALSE(renderer()->IsContextLost());
+  }
+
+  void TearDown() override {
+    GLRendererPixelTest::TearDown();
+    ASSERT_FALSE(renderer()->IsContextLost());
+  }
+
+  void TestBasicShaders() {
     EXPECT_PROGRAM_VALID(renderer()->GetTileCheckerboardProgram());
     EXPECT_PROGRAM_VALID(renderer()->GetDebugBorderProgram());
     EXPECT_PROGRAM_VALID(renderer()->GetSolidColorProgram());
     EXPECT_PROGRAM_VALID(renderer()->GetSolidColorProgramAA());
-    TestShadersWithTexCoordPrecision(TEX_COORD_PRECISION_MEDIUM);
-    TestShadersWithTexCoordPrecision(TEX_COORD_PRECISION_HIGH);
-    ASSERT_FALSE(renderer()->IsContextLost());
   }
 
-  void TestShadersWithTexCoordPrecision(TexCoordPrecision precision) {
-    for (int i = 0; i <= LAST_BLEND_MODE; ++i) {
-      BlendMode blend_mode = static_cast<BlendMode>(i);
-      EXPECT_PROGRAM_VALID(
-          renderer()->GetRenderPassProgram(precision, blend_mode));
-      EXPECT_PROGRAM_VALID(
-          renderer()->GetRenderPassProgramAA(precision, blend_mode));
-    }
+  void TestShadersWithPrecision(TexCoordPrecision precision) {
     EXPECT_PROGRAM_VALID(renderer()->GetTextureProgram(precision));
     EXPECT_PROGRAM_VALID(
         renderer()->GetNonPremultipliedTextureProgram(precision));
     EXPECT_PROGRAM_VALID(renderer()->GetTextureBackgroundProgram(precision));
     EXPECT_PROGRAM_VALID(
         renderer()->GetNonPremultipliedTextureBackgroundProgram(precision));
     EXPECT_PROGRAM_VALID(renderer()->GetTextureIOSurfaceProgram(precision));
     EXPECT_PROGRAM_VALID(renderer()->GetVideoYUVProgram(precision));
     EXPECT_PROGRAM_VALID(renderer()->GetVideoYUVAProgram(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));
     else
       EXPECT_FALSE(renderer()->GetVideoStreamTextureProgram(precision));
-    TestShadersWithSamplerType(precision, SAMPLER_TYPE_2D);
-    TestShadersWithSamplerType(precision, SAMPLER_TYPE_2D_RECT);
-    // This is unlikely to be ever true in tests due to usage of osmesa.
-    if (renderer()->Capabilities().using_egl_image)
-      TestShadersWithSamplerType(precision, SAMPLER_TYPE_EXTERNAL_OES);
   }
 
-  void TestShadersWithSamplerType(TexCoordPrecision precision,
-                                  SamplerType sampler) {
+  void TestShadersWithPrecisionAndBlend(TexCoordPrecision precision,
+                                        BlendMode blend_mode) {
+    EXPECT_PROGRAM_VALID(
+        renderer()->GetRenderPassProgram(precision, blend_mode));
+    EXPECT_PROGRAM_VALID(
+        renderer()->GetRenderPassProgramAA(precision, blend_mode));
+  }
+
+  void TestShadersWithPrecisionAndSampler(TexCoordPrecision precision,
+                                          SamplerType sampler) {
+    if (!renderer()->Capabilities().using_egl_image &&
+        sampler == SAMPLER_TYPE_EXTERNAL_OES) {
+      // This will likely be hit in tests due to usage of osmesa.
+      return;
+    }
+
     EXPECT_PROGRAM_VALID(renderer()->GetTileProgram(precision, sampler));
     EXPECT_PROGRAM_VALID(renderer()->GetTileProgramOpaque(precision, sampler));
     EXPECT_PROGRAM_VALID(renderer()->GetTileProgramAA(precision, sampler));
     EXPECT_PROGRAM_VALID(renderer()->GetTileProgramSwizzle(precision, sampler));
     EXPECT_PROGRAM_VALID(
         renderer()->GetTileProgramSwizzleOpaque(precision, sampler));
     EXPECT_PROGRAM_VALID(
         renderer()->GetTileProgramSwizzleAA(precision, sampler));
-    for (int i = 0; i <= LAST_BLEND_MODE; ++i) {
-      BlendMode blend_mode = static_cast<BlendMode>(i);
-      for (int l = 0; l <= 1; ++l) {
-        bool mask_for_background = (l == 1);
-        EXPECT_PROGRAM_VALID(
-            renderer()->GetRenderPassMaskProgram(precision,
-                                                 sampler,
-                                                 blend_mode,
-                                                 mask_for_background));
-        EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskProgramAA(
-            precision, sampler, blend_mode, mask_for_background));
-        EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskColorMatrixProgramAA(
-            precision, sampler, blend_mode, mask_for_background));
-        EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskColorMatrixProgram(
-            precision, sampler, blend_mode, mask_for_background));
-      }
+  }
+
+  void TestShadersWithMasks(TexCoordPrecision precision,
+                            SamplerType sampler,
+                            BlendMode blend_mode,
+                            bool mask_for_background) {
+    if (!renderer()->Capabilities().using_egl_image &&
+        sampler == SAMPLER_TYPE_EXTERNAL_OES) {
+      // This will likely be hit in tests due to usage of osmesa.
+      return;
     }
+
+    EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskProgram(
+        precision, sampler, blend_mode, mask_for_background));
+    EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskProgramAA(
+        precision, sampler, blend_mode, mask_for_background));
+    EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskColorMatrixProgramAA(
+        precision, sampler, blend_mode, mask_for_background));
+    EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskColorMatrixProgram(
+        precision, sampler, blend_mode, mask_for_background));
   }
 };
 
 namespace {
 
 #if !defined(OS_ANDROID) && !defined(OS_WIN)
-TEST_F(GLRendererShaderPixelTest, AllShadersCompile) { TestShaders(); }
+static const TexCoordPrecision kPrecisionList[] = {TEX_COORD_PRECISION_MEDIUM,
+                                                   TEX_COORD_PRECISION_HIGH};
+
+static const BlendMode kBlendModeList[LAST_BLEND_MODE + 1] = {
+    BLEND_MODE_NONE,
+    BLEND_MODE_NORMAL,
+    BLEND_MODE_SCREEN,
+    BLEND_MODE_OVERLAY,
+    BLEND_MODE_DARKEN,
+    BLEND_MODE_LIGHTEN,
+    BLEND_MODE_COLOR_DODGE,
+    BLEND_MODE_COLOR_BURN,
+    BLEND_MODE_HARD_LIGHT,
+    BLEND_MODE_SOFT_LIGHT,
+    BLEND_MODE_DIFFERENCE,
+    BLEND_MODE_EXCLUSION,
+    BLEND_MODE_MULTIPLY,
+    BLEND_MODE_HUE,
+    BLEND_MODE_SATURATION,
+    BLEND_MODE_COLOR,
+    BLEND_MODE_LUMINOSITY,
+};
+
+static const SamplerType kSamplerList[] = {
+    SAMPLER_TYPE_2D,
+    SAMPLER_TYPE_2D_RECT,
+    SAMPLER_TYPE_EXTERNAL_OES,
+};
+
+TEST_F(GLRendererShaderPixelTest, BasicShadersCompile) {
+  TestBasicShaders();
+}
+
+class PrecisionShaderPixelTest
+    : public GLRendererShaderPixelTest,
+      public ::testing::WithParamInterface<TexCoordPrecision> {};
+
+TEST_P(PrecisionShaderPixelTest, ShadersCompile) {
+  TestShadersWithPrecision(GetParam());
+}
+
+INSTANTIATE_TEST_CASE_P(PrecisionShadersCompile,
+                        PrecisionShaderPixelTest,
+                        ::testing::ValuesIn(kPrecisionList));
+
+class PrecisionBlendShaderPixelTest
+    : public GLRendererShaderPixelTest,
+      public ::testing::WithParamInterface<
+          std::tr1::tuple<TexCoordPrecision, BlendMode>> {};
+
+TEST_P(PrecisionBlendShaderPixelTest, ShadersCompile) {
+  TestShadersWithPrecisionAndBlend(std::tr1::get<0>(GetParam()),
+                                   std::tr1::get<1>(GetParam()));
+}
+
+INSTANTIATE_TEST_CASE_P(
+    PrecisionBlendShadersCompile,
+    PrecisionBlendShaderPixelTest,
+    ::testing::Combine(::testing::ValuesIn(kPrecisionList),
+                       ::testing::ValuesIn(kBlendModeList)));
+
+class PrecisionSamplerShaderPixelTest
+    : public GLRendererShaderPixelTest,
+      public ::testing::WithParamInterface<
+          std::tr1::tuple<TexCoordPrecision, SamplerType>> {};
+
+TEST_P(PrecisionSamplerShaderPixelTest, ShadersCompile) {
+  TestShadersWithPrecisionAndSampler(std::tr1::get<0>(GetParam()),
+                                     std::tr1::get<1>(GetParam()));
+}
+
+INSTANTIATE_TEST_CASE_P(PrecisionSamplerShadersCompile,
+                        PrecisionSamplerShaderPixelTest,
+                        ::testing::Combine(::testing::ValuesIn(kPrecisionList),
+                                           ::testing::ValuesIn(kSamplerList)));
+
+class MaskShaderPixelTest
+    : public GLRendererShaderPixelTest,
+      public ::testing::WithParamInterface<
+          std::tr1::tuple<TexCoordPrecision, SamplerType, BlendMode, bool>> {};
+
+TEST_P(MaskShaderPixelTest, ShadersCompile) {
+  TestShadersWithMasks(
+      std::tr1::get<0>(GetParam()), std::tr1::get<1>(GetParam()),
+      std::tr1::get<2>(GetParam()), std::tr1::get<3>(GetParam()));
+}
+
+INSTANTIATE_TEST_CASE_P(MaskShadersCompile,
+                        MaskShaderPixelTest,
+                        ::testing::Combine(::testing::ValuesIn(kPrecisionList),
+                                           ::testing::ValuesIn(kSamplerList),
+                                           ::testing::ValuesIn(kBlendModeList),
+                                           ::testing::Bool()));
+
 #endif
 
 class FakeRendererGL : public GLRenderer {
  public:
   FakeRendererGL(RendererClient* client,
                  const RendererSettings* settings,
                  OutputSurface* output_surface,
                  ResourceProvider* resource_provider)
       : GLRenderer(client,
                    settings,
@@ skipping 1118 matching lines @@
                        viewport_rect,
                        clip_rect,
                        false);
     EXPECT_EQ(0, context->discarded());
     context->reset();
   }
 }
 
 class FlippedScissorAndViewportContext : public TestWebGraphicsContext3D {
  public:
-  FlippedScissorAndViewportContext()
-      : did_call_viewport_(false), did_call_scissor_(false) {}
-  ~FlippedScissorAndViewportContext() override {
-    EXPECT_TRUE(did_call_viewport_);
-    EXPECT_TRUE(did_call_scissor_);
-  }
-
-  void viewport(GLint x, GLint y, GLsizei width, GLsizei height) override {
-    EXPECT_EQ(10, x);
-    EXPECT_EQ(390, y);
-    EXPECT_EQ(100, width);
-    EXPECT_EQ(100, height);
-    did_call_viewport_ = true;
-  }
-
-  void scissor(GLint x, GLint y, GLsizei width, GLsizei height) override {
-    EXPECT_EQ(30, x);
-    EXPECT_EQ(450, y);
-    EXPECT_EQ(20, width);
-    EXPECT_EQ(20, height);
-    did_call_scissor_ = true;
-  }
-
- private:
-  bool did_call_viewport_;
-  bool did_call_scissor_;
+  MOCK_METHOD4(viewport, void(GLint x, GLint y, GLsizei width, GLsizei height));
+  MOCK_METHOD4(scissor, void(GLint x, GLint y, GLsizei width, GLsizei height));
 };
 
 TEST_F(GLRendererTest, ScissorAndViewportWithinNonreshapableSurface) {
   // In Android WebView, the OutputSurface is unable to respect reshape() calls
   // and maintains a fixed size. This test verifies that glViewport and
   // glScissor's Y coordinate is flipped correctly in this environment, and that
   // the glViewport can be at a nonzero origin within the surface.
   scoped_ptr<FlippedScissorAndViewportContext> context_owned(
       new FlippedScissorAndViewportContext);
 
+  // We expect exactly one call to viewport on this context and exactly two
+  // to scissor (one to scissor the clear, one to scissor the quad draw).
+  EXPECT_CALL(*context_owned, viewport(10, 390, 100, 100));
+  EXPECT_CALL(*context_owned, scissor(10, 390, 100, 100));
+  EXPECT_CALL(*context_owned, scissor(30, 450, 20, 20));
+
   FakeOutputSurfaceClient output_surface_client;
   scoped_ptr<OutputSurface> output_surface(
       new NonReshapableOutputSurface(context_owned.Pass()));
   CHECK(output_surface->BindToClient(&output_surface_client));
 
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get(),
                                shared_bitmap_manager.get(),
@@ skipping 624 matching lines @@
   base::MessageLoop::current()->Run();
 
   // The sync point should have happened.
   EXPECT_EQ(1, sync_point_callback_count);
   EXPECT_EQ(1, other_callback_count);
 }
 #endif  // OS_ANDROID
 
 }  // namespace
 }  // namespace cc