Add support to GLRenderer for different blending for solid color quads

cc/output/gl_renderer.cc

 // Copyright 2010 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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 693 matching lines @@
          blend_mode == SkBlendMode::kDstIn ||
          blend_mode == SkBlendMode::kScreen;
 }
 
 void GLRenderer::ApplyBlendModeUsingBlendFunc(SkBlendMode blend_mode) {
   // Any modes set here must be reset in RestoreBlendFuncToDefault
   if (blend_mode == SkBlendMode::kSrcOver) {
     // Left no-op intentionally.
   } else if (blend_mode == SkBlendMode::kDstIn) {
     gl_->BlendFunc(GL_ZERO, GL_SRC_ALPHA);
+  } else if (blend_mode == SkBlendMode::kDstOut) {
+    gl_->BlendFunc(GL_ZERO, GL_ONE_MINUS_SRC_ALPHA);
   } else if (blend_mode == SkBlendMode::kScreen) {
     gl_->BlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE);
   } else {
     DCHECK(use_blend_equation_advanced_);
     GLenum equation = GL_FUNC_ADD;
     switch (blend_mode) {
       case SkBlendMode::kScreen:
         equation = GL_SCREEN_KHR;
         break;
       case SkBlendMode::kOverlay:
@@ skipping 45 matching lines @@
     }
     gl_->BlendEquation(equation);
   }
 }
 
 void GLRenderer::RestoreBlendFuncToDefault(SkBlendMode blend_mode) {
   switch (blend_mode) {
     case SkBlendMode::kSrcOver:
       break;
     case SkBlendMode::kDstIn:
+    case SkBlendMode::kDstOut:
     case SkBlendMode::kScreen:
       gl_->BlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
       break;
     default:
       DCHECK(use_blend_equation_advanced_);
       gl_->BlendEquation(GL_FUNC_ADD);
   }
 }
 
 bool GLRenderer::ShouldApplyBackgroundFilters(
@@ skipping 938 matching lines @@
 void GLRenderer::DrawSolidColorQuad(const SolidColorDrawQuad* quad,
                                     const gfx::QuadF* clip_region) {
   gfx::Rect tile_rect = quad->visible_rect;
 
   SkColor color = quad->color;
   float opacity = quad->shared_quad_state->opacity;
   float alpha = (SkColorGetA(color) * (1.0f / 255.0f)) * opacity;
 
   // Early out if alpha is small enough that quad doesn't contribute to output.
   if (alpha < std::numeric_limits<float>::epsilon() &&
-      quad->ShouldDrawWithBlending())
+      quad->ShouldDrawWithBlending() &&
+      quad->shared_quad_state->blend_mode == SkBlendMode::kSrcOver)
     return;
 
   gfx::Transform device_transform =
       current_frame()->window_matrix * current_frame()->projection_matrix *
       quad->shared_quad_state->quad_to_target_transform;
   device_transform.FlattenTo2d();
   if (!device_transform.IsInvertible())
     return;
 
   auto local_quad = gfx::QuadF(gfx::RectF(tile_rect));
@@ skipping 26 matching lines @@
                 quad_color_space);
   SetShaderColor(color, opacity);
 
   if (use_aa) {
     gl_->Uniform3fv(current_program_->edge_location(), 8, edge);
   }
 
   // Enable blending when the quad properties require it or if we decided
   // to use antialiasing.
   SetBlendEnabled(quad->ShouldDrawWithBlending() || use_aa);
+  ApplyBlendModeUsingBlendFunc(quad->shared_quad_state->blend_mode);
 
   // Antialising requires a normalized quad, but this could lead to floating
   // point precision errors, so only normalize when antialising is on.
   if (use_aa) {
     // Normalize to tile_rect.
     local_quad.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());
 
     SetShaderQuadF(local_quad);
 
     // The transform and vertex data are used to figure out the extents that the
     // un-antialiased quad should have and which vertex this is and the float
     // quad passed in via uniform is the actual geometry that gets used to draw
     // it. This is why this centered rect is used and not the original
     // quad_rect.
     gfx::RectF centered_rect(
         gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),
         gfx::SizeF(tile_rect.size()));
     DrawQuadGeometry(current_frame()->projection_matrix,
                      quad->shared_quad_state->quad_to_target_transform,
                      centered_rect);
   } else {
     PrepareGeometry(SHARED_BINDING);
     SetShaderQuadF(local_quad);
     SetShaderMatrix(current_frame()->projection_matrix *
                     quad->shared_quad_state->quad_to_target_transform);
     gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
   }
+  RestoreBlendFuncToDefault(quad->shared_quad_state->blend_mode);
 }
 
 void GLRenderer::DrawTileQuad(const TileDrawQuad* quad,
                               const gfx::QuadF* clip_region) {
   DrawContentQuad(quad, quad->resource_id(), clip_region);
 }
 
 void GLRenderer::DrawContentQuad(const ContentDrawQuadBase* quad,
                                  ResourceId resource_id,
                                  const gfx::QuadF* clip_region) {
@@ skipping 1790 matching lines @@
     return;
 
   // Report GPU overdraw as a percentage of |max_result|.
   TRACE_COUNTER1(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.overdraw"), "GPU Overdraw",
       (std::accumulate(overdraw->begin(), overdraw->end(), 0) * 100) /
           max_result);
 }
 
 }  // namespace cc