Update from https://crrev.com/317530

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 39 matching lines @@
 };
 
 #define EXPECT_PROGRAM_VALID(program_binding)      \
   do {                                             \
     EXPECT_TRUE((program_binding)->program());     \
     EXPECT_TRUE((program_binding)->initialized()); \
   } while (false)
 
 static inline SkXfermode::Mode BlendModeToSkXfermode(BlendMode blend_mode) {
   switch (blend_mode) {
-    case BlendModeNone:
-    case BlendModeNormal:
+    case BLEND_MODE_NONE:
+    case BLEND_MODE_NORMAL:
       return SkXfermode::kSrcOver_Mode;
-    case BlendModeScreen:
+    case BLEND_MODE_SCREEN:
       return SkXfermode::kScreen_Mode;
-    case BlendModeOverlay:
+    case BLEND_MODE_OVERLAY:
       return SkXfermode::kOverlay_Mode;
-    case BlendModeDarken:
+    case BLEND_MODE_DARKEN:
       return SkXfermode::kDarken_Mode;
-    case BlendModeLighten:
+    case BLEND_MODE_LIGHTEN:
       return SkXfermode::kLighten_Mode;
-    case BlendModeColorDodge:
+    case BLEND_MODE_COLOR_DODGE:
       return SkXfermode::kColorDodge_Mode;
-    case BlendModeColorBurn:
+    case BLEND_MODE_COLOR_BURN:
       return SkXfermode::kColorBurn_Mode;
-    case BlendModeHardLight:
+    case BLEND_MODE_HARD_LIGHT:
       return SkXfermode::kHardLight_Mode;
-    case BlendModeSoftLight:
+    case BLEND_MODE_SOFT_LIGHT:
       return SkXfermode::kSoftLight_Mode;
-    case BlendModeDifference:
+    case BLEND_MODE_DIFFERENCE:
       return SkXfermode::kDifference_Mode;
-    case BlendModeExclusion:
+    case BLEND_MODE_EXCLUSION:
       return SkXfermode::kExclusion_Mode;
-    case BlendModeMultiply:
+    case BLEND_MODE_MULTIPLY:
       return SkXfermode::kMultiply_Mode;
-    case BlendModeHue:
+    case BLEND_MODE_HUE:
       return SkXfermode::kHue_Mode;
-    case BlendModeSaturation:
+    case BLEND_MODE_SATURATION:
       return SkXfermode::kSaturation_Mode;
-    case BlendModeColor:
+    case BLEND_MODE_COLOR:
       return SkXfermode::kColor_Mode;
-    case BlendModeLuminosity:
+    case BLEND_MODE_LUMINOSITY:
       return SkXfermode::kLuminosity_Mode;
-    case NumBlendModes:
-      NOTREACHED();
   }
   return SkXfermode::kSrcOver_Mode;
 }
 
 // Explicitly named to be a friend in GLRenderer for shader access.
 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());
-    TestShadersWithTexCoordPrecision(TexCoordPrecisionMedium);
-    TestShadersWithTexCoordPrecision(TexCoordPrecisionHigh);
+    TestShadersWithTexCoordPrecision(TEX_COORD_PRECISION_MEDIUM);
+    TestShadersWithTexCoordPrecision(TEX_COORD_PRECISION_HIGH);
     ASSERT_FALSE(renderer()->IsContextLost());
   }
 
   void TestShadersWithTexCoordPrecision(TexCoordPrecision precision) {
-    for (int i = 0; i < NumBlendModes; ++i) {
+    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));
     }
     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, SamplerType2D);
-    TestShadersWithSamplerType(precision, SamplerType2DRect);
+    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, SamplerTypeExternalOES);
+      TestShadersWithSamplerType(precision, SAMPLER_TYPE_EXTERNAL_OES);
   }
 
   void TestShadersWithSamplerType(TexCoordPrecision precision,
                                   SamplerType sampler) {
     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 < NumBlendModes; ++i) {
+    for (int i = 0; i <= LAST_BLEND_MODE; ++i) {
       BlendMode blend_mode = static_cast<BlendMode>(i);
       EXPECT_PROGRAM_VALID(
           renderer()->GetRenderPassMaskProgram(precision, sampler, blend_mode));
       EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskProgramAA(
           precision, sampler, blend_mode));
       EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskColorMatrixProgramAA(
           precision, sampler, blend_mode));
       EXPECT_PROGRAM_VALID(renderer()->GetRenderPassMaskColorMatrixProgram(
           precision, sampler, blend_mode));
     }
@@ skipping 1267 matching lines @@
   gfx::Rect viewport_rect(1, 1);
 
   gfx::Rect child_rect(50, 50);
   RenderPassId child_pass_id(2, 0);
   TestRenderPass* child_pass;
 
   RenderPassId root_pass_id(1, 0);
   TestRenderPass* root_pass;
 
   ResourceProvider::ResourceId mask = resource_provider_->CreateResource(
-      gfx::Size(20, 12),
-      GL_CLAMP_TO_EDGE,
-      ResourceProvider::TextureHintImmutable,
+      gfx::Size(20, 12), GL_CLAMP_TO_EDGE,
+      ResourceProvider::TEXTURE_HINT_IMMUTABLE,
       resource_provider_->best_texture_format());
   resource_provider_->AllocateForTesting(mask);
 
   SkScalar matrix[20];
   float amount = 0.5f;
   matrix[0] = 0.213f + 0.787f * amount;
   matrix[1] = 0.715f - 0.715f * amount;
   matrix[2] = 1.f - (matrix[0] + matrix[1]);
   matrix[3] = matrix[4] = 0;
   matrix[5] = 0.213f - 0.213f * amount;
   matrix[6] = 0.715f + 0.285f * amount;
   matrix[7] = 1.f - (matrix[5] + matrix[6]);
   matrix[8] = matrix[9] = 0;
   matrix[10] = 0.213f - 0.213f * amount;
   matrix[11] = 0.715f - 0.715f * amount;
   matrix[12] = 1.f - (matrix[10] + matrix[11]);
   matrix[13] = matrix[14] = 0;
   matrix[15] = matrix[16] = matrix[17] = matrix[19] = 0;
   matrix[18] = 1;
   skia::RefPtr<SkColorFilter> color_filter(
       skia::AdoptRef(SkColorMatrixFilter::Create(matrix)));
   skia::RefPtr<SkImageFilter> filter = skia::AdoptRef(
       SkColorFilterImageFilter::Create(color_filter.get(), NULL));
   FilterOperations filters;
   filters.Append(FilterOperation::CreateReferenceFilter(filter));
 
   gfx::Transform transform_causing_aa;
   transform_causing_aa.Rotate(20.0);
 
-  for (int i = 0; i < NumBlendModes; ++i) {
+  for (int i = 0; i <= LAST_BLEND_MODE; ++i) {
     BlendMode blend_mode = static_cast<BlendMode>(i);
     SkXfermode::Mode xfer_mode = BlendModeToSkXfermode(blend_mode);
-    settings_.force_blending_with_shaders = (blend_mode != BlendModeNone);
+    settings_.force_blending_with_shaders = (blend_mode != BLEND_MODE_NONE);
     // RenderPassProgram
     render_passes_in_draw_order_.clear();
     child_pass = AddRenderPass(&render_passes_in_draw_order_,
                                child_pass_id,
                                child_rect,
                                gfx::Transform());
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_,
                               root_pass_id,
                               viewport_rect,
                               gfx::Transform());
 
     AddRenderPassQuad(root_pass,
                       child_pass,
                       0,
                       FilterOperations(),
                       gfx::Transform(),
                       xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     renderer_->DrawFrame(&render_passes_in_draw_order_,
                          1.f,
                          viewport_rect,
                          viewport_rect,
                          false);
-    TestRenderPassProgram(TexCoordPrecisionMedium, blend_mode);
+    TestRenderPassProgram(TEX_COORD_PRECISION_MEDIUM, blend_mode);
 
     // RenderPassColorMatrixProgram
     render_passes_in_draw_order_.clear();
 
     child_pass = AddRenderPass(&render_passes_in_draw_order_,
                                child_pass_id,
                                child_rect,
                                transform_causing_aa);
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_,
                               root_pass_id,
                               viewport_rect,
                               gfx::Transform());
 
     AddRenderPassQuad(
         root_pass, child_pass, 0, filters, gfx::Transform(), xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     renderer_->DrawFrame(&render_passes_in_draw_order_,
                          1.f,
                          viewport_rect,
                          viewport_rect,
                          false);
-    TestRenderPassColorMatrixProgram(TexCoordPrecisionMedium, blend_mode);
+    TestRenderPassColorMatrixProgram(TEX_COORD_PRECISION_MEDIUM, blend_mode);
 
     // RenderPassMaskProgram
     render_passes_in_draw_order_.clear();
 
     child_pass = AddRenderPass(&render_passes_in_draw_order_,
                                child_pass_id,
                                child_rect,
                                gfx::Transform());
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_,
                               root_pass_id,
                               viewport_rect,
                               gfx::Transform());
 
     AddRenderPassQuad(root_pass,
                       child_pass,
                       mask,
                       FilterOperations(),
                       gfx::Transform(),
                       xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     renderer_->DrawFrame(&render_passes_in_draw_order_,
                          1.f,
                          viewport_rect,
                          viewport_rect,
                          false);
-    TestRenderPassMaskProgram(
-        TexCoordPrecisionMedium, SamplerType2D, blend_mode);
+    TestRenderPassMaskProgram(TEX_COORD_PRECISION_MEDIUM, SAMPLER_TYPE_2D,
+                              blend_mode);
 
     // RenderPassMaskColorMatrixProgram
     render_passes_in_draw_order_.clear();
 
     child_pass = AddRenderPass(&render_passes_in_draw_order_,
                                child_pass_id,
                                child_rect,
                                gfx::Transform());
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_,
                               root_pass_id,
                               viewport_rect,
                               gfx::Transform());
 
     AddRenderPassQuad(
         root_pass, child_pass, mask, filters, gfx::Transform(), xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     renderer_->DrawFrame(&render_passes_in_draw_order_,
                          1.f,
                          viewport_rect,
                          viewport_rect,
                          false);
-    TestRenderPassMaskColorMatrixProgram(
-        TexCoordPrecisionMedium, SamplerType2D, blend_mode);
+    TestRenderPassMaskColorMatrixProgram(TEX_COORD_PRECISION_MEDIUM,
+                                         SAMPLER_TYPE_2D, blend_mode);
 
     // RenderPassProgramAA
     render_passes_in_draw_order_.clear();
 
     child_pass = AddRenderPass(&render_passes_in_draw_order_,
                                child_pass_id,
                                child_rect,
                                transform_causing_aa);
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_,
                               root_pass_id,
                               viewport_rect,
                               gfx::Transform());
 
     AddRenderPassQuad(root_pass,
                       child_pass,
                       0,
                       FilterOperations(),
                       transform_causing_aa,
                       xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     renderer_->DrawFrame(&render_passes_in_draw_order_,
                          1.f,
                          viewport_rect,
                          viewport_rect,
                          false);
-    TestRenderPassProgramAA(TexCoordPrecisionMedium, blend_mode);
+    TestRenderPassProgramAA(TEX_COORD_PRECISION_MEDIUM, blend_mode);
 
     // RenderPassColorMatrixProgramAA
     render_passes_in_draw_order_.clear();
 
     child_pass = AddRenderPass(&render_passes_in_draw_order_,
                                child_pass_id,
                                child_rect,
                                transform_causing_aa);
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_,
                               root_pass_id,
                               viewport_rect,
                               gfx::Transform());
 
     AddRenderPassQuad(
         root_pass, child_pass, 0, filters, transform_causing_aa, xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     renderer_->DrawFrame(&render_passes_in_draw_order_,
                          1.f,
                          viewport_rect,
                          viewport_rect,
                          false);
-    TestRenderPassColorMatrixProgramAA(TexCoordPrecisionMedium, blend_mode);
+    TestRenderPassColorMatrixProgramAA(TEX_COORD_PRECISION_MEDIUM, blend_mode);
 
     // RenderPassMaskProgramAA
     render_passes_in_draw_order_.clear();
 
     child_pass = AddRenderPass(&render_passes_in_draw_order_,
                                child_pass_id,
                                child_rect,
                                transform_causing_aa);
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_,
                               root_pass_id,
                               viewport_rect,
                               gfx::Transform());
 
     AddRenderPassQuad(root_pass,
                       child_pass,
                       mask,
                       FilterOperations(),
                       transform_causing_aa,
                       xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     renderer_->DrawFrame(&render_passes_in_draw_order_,
                          1.f,
                          viewport_rect,
                          viewport_rect,
                          false);
-    TestRenderPassMaskProgramAA(
-        TexCoordPrecisionMedium, SamplerType2D, blend_mode);
+    TestRenderPassMaskProgramAA(TEX_COORD_PRECISION_MEDIUM, SAMPLER_TYPE_2D,
+                                blend_mode);
 
     // RenderPassMaskColorMatrixProgramAA
     render_passes_in_draw_order_.clear();
 
     child_pass = AddRenderPass(&render_passes_in_draw_order_,
                                child_pass_id,
                                child_rect,
                                transform_causing_aa);
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_,
                               root_pass_id,
                               viewport_rect,
                               transform_causing_aa);
 
     AddRenderPassQuad(
         root_pass, child_pass, mask, filters, transform_causing_aa, xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
     renderer_->DrawFrame(&render_passes_in_draw_order_,
                          1.f,
                          viewport_rect,
                          viewport_rect,
                          false);
-    TestRenderPassMaskColorMatrixProgramAA(
-        TexCoordPrecisionMedium, SamplerType2D, blend_mode);
+    TestRenderPassMaskColorMatrixProgramAA(TEX_COORD_PRECISION_MEDIUM,
+                                           SAMPLER_TYPE_2D, blend_mode);
   }
 }
 
 // At this time, the AA code path cannot be taken if the surface's rect would
 // project incorrectly by the given transform, because of w<0 clipping.
 TEST_F(GLRendererShaderTest, DrawRenderPassQuadSkipsAAForClippingTransform) {
   gfx::Rect child_rect(50, 50);
   RenderPassId child_pass_id(2, 0);
   TestRenderPass* child_pass;
 
@@ skipping 31 matching lines @@
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer_->DrawFrame(&render_passes_in_draw_order_,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
 
   // If use_aa incorrectly ignores clipping, it will use the
   // RenderPassProgramAA shader instead of the RenderPassProgram.
-  TestRenderPassProgram(TexCoordPrecisionMedium, BlendModeNone);
+  TestRenderPassProgram(TEX_COORD_PRECISION_MEDIUM, BLEND_MODE_NONE);
 }
 
 TEST_F(GLRendererShaderTest, DrawSolidColorShader) {
   gfx::Rect viewport_rect(1, 1);
   RenderPassId root_pass_id(1, 0);
   TestRenderPass* root_pass;
 
   gfx::Transform pixel_aligned_transform_causing_aa;
   pixel_aligned_transform_causing_aa.Translate(25.5f, 25.5f);
   pixel_aligned_transform_causing_aa.Scale(0.5f, 0.5f);
@@ skipping 217 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