Add support for all blendmodes if we have GL_KHR_blend_equation_advanced.

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 <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 357 matching lines @@
 
   capabilities_.using_image = context_caps.gpu.image;
 
   capabilities_.using_discard_framebuffer =
       context_caps.gpu.discard_framebuffer;
 
   capabilities_.allow_rasterize_on_demand = true;
 
   use_sync_query_ = context_caps.gpu.sync_query;
   use_blend_minmax_ = context_caps.gpu.blend_minmax;
+  use_blend_equation_advanced_ = context_caps.gpu.blend_equation_advanced;
+  use_blend_equation_advanced_coherent_ =
+      context_caps.gpu.blend_equation_advanced_coherent;
 
   InitializeSharedObjects();
 }
 
 GLRenderer::~GLRenderer() {
   while (!pending_async_read_pixels_.empty()) {
     PendingAsyncReadPixels* pending_read = pending_async_read_pixels_.back();
     pending_read->finished_read_pixels_callback.Cancel();
     pending_async_read_pixels_.pop_back();
   }
@@ skipping 340 matching lines @@
 
   // Flush the GrContext to ensure all buffered GL calls are drawn to the
   // backing store before we access and return it, and have cc begin using the
   // GL context again.
   canvas->flush();
 
   return image;
 }
 
 bool GLRenderer::CanApplyBlendModeUsingBlendFunc(SkXfermode::Mode blend_mode) {
-  return (use_blend_minmax_ && blend_mode == SkXfermode::kLighten_Mode) ||
+  return use_blend_equation_advanced_ ||
+         (use_blend_minmax_ && blend_mode == SkXfermode::kLighten_Mode) ||
          blend_mode == SkXfermode::kScreen_Mode ||
          blend_mode == SkXfermode::kSrcOver_Mode;
 }
 
 void GLRenderer::ApplyBlendModeUsingBlendFunc(SkXfermode::Mode blend_mode) {
   DCHECK(CanApplyBlendModeUsingBlendFunc(blend_mode));
 
   // Any modes set here must be reset in RestoreBlendFuncToDefault
-  if (blend_mode == SkXfermode::kScreen_Mode) {
-    GLC(gl_, gl_->BlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE));
-  } else if (blend_mode == SkXfermode::kLighten_Mode) {
-    GLC(gl_, gl_->BlendFunc(GL_ONE, GL_ONE));
-    GLC(gl_, gl_->BlendEquation(GL_MAX_EXT));
+  if (use_blend_equation_advanced_) {
+    GLenum equation = GL_FUNC_ADD;
+
+    switch (blend_mode) {
+      case SkXfermode::kScreen_Mode:
+        equation = GL_SCREEN_KHR;
+        break;
+      case SkXfermode::kOverlay_Mode:
+        equation = GL_OVERLAY_KHR;
+        break;
+      case SkXfermode::kDarken_Mode:
+        equation = GL_DARKEN_KHR;
+        break;
+      case SkXfermode::kLighten_Mode:
+        equation = GL_LIGHTEN_KHR;
+        break;
+      case SkXfermode::kColorDodge_Mode:
+        equation = GL_COLORDODGE_KHR;
+        break;
+      case SkXfermode::kColorBurn_Mode:
+        equation = GL_COLORBURN_KHR;
+        break;
+      case SkXfermode::kHardLight_Mode:
+        equation = GL_HARDLIGHT_KHR;
+        break;
+      case SkXfermode::kSoftLight_Mode:
+        equation = GL_SOFTLIGHT_KHR;
+        break;
+      case SkXfermode::kDifference_Mode:
+        equation = GL_DIFFERENCE_KHR;
+        break;
+      case SkXfermode::kExclusion_Mode:
+        equation = GL_EXCLUSION_KHR;
+        break;
+      case SkXfermode::kMultiply_Mode:
+        equation = GL_MULTIPLY_KHR;
+        break;
+      case SkXfermode::kHue_Mode:
+        equation = GL_HSL_HUE_KHR;
+        break;
+      case SkXfermode::kSaturation_Mode:
+        equation = GL_HSL_SATURATION_KHR;
+        break;
+      case SkXfermode::kColor_Mode:
+        equation = GL_HSL_COLOR_KHR;
+        break;
+      case SkXfermode::kLuminosity_Mode:
+        equation = GL_HSL_LUMINOSITY_KHR;
+        break;
+      default:
+        return;
+    }
+
+    GLC(gl_, gl_->BlendEquation(equation));
+  } else {
+    if (blend_mode == SkXfermode::kScreen_Mode) {
+      GLC(gl_, gl_->BlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE));
+    } else if (blend_mode == SkXfermode::kLighten_Mode) {
+      GLC(gl_, gl_->BlendFunc(GL_ONE, GL_ONE));
+      GLC(gl_, gl_->BlendEquation(GL_MAX_EXT));
+    }
   }
 }
 
 void GLRenderer::RestoreBlendFuncToDefault(SkXfermode::Mode blend_mode) {
   if (blend_mode == SkXfermode::kSrcOver_Mode)
     return;
 
-  GLC(gl_, gl_->BlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
+  if (use_blend_equation_advanced_) {
+    GLC(gl_, gl_->BlendEquation(GL_FUNC_ADD));
+  } else {
+    GLC(gl_, gl_->BlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
 
-  if (blend_mode == SkXfermode::kLighten_Mode)
-    GLC(gl_, gl_->BlendEquation(GL_FUNC_ADD));
+    if (blend_mode == SkXfermode::kLighten_Mode)
+      GLC(gl_, gl_->BlendEquation(GL_FUNC_ADD));
+  }
 }
 
 bool GLRenderer::ShouldApplyBackgroundFilters(DrawingFrame* frame,
                                               const RenderPassDrawQuad* quad) {
   if (quad->background_filters.IsEmpty())
     return false;
 
   // TODO(danakj): We only allow background filters on an opaque render surface
   // because other surfaces may contain translucent pixels, and the contents
   // behind those translucent pixels wouldn't have the filter applied.
@@ skipping 315 matching lines @@
     DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
     gl_->BindTexture(GL_TEXTURE_2D, texture->getTextureHandle());
   } else {
     contents_resource_lock =
         make_scoped_ptr(new ResourceProvider::ScopedSamplerGL(
             resource_provider_, contents_texture->id(), GL_LINEAR));
     DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
               contents_resource_lock->target());
   }
 
-  if (CanApplyBlendModeUsingBlendFunc(blend_mode))
+  if (CanApplyBlendModeUsingBlendFunc(blend_mode)) {
+    if (!use_blend_equation_advanced_coherent_ && use_blend_equation_advanced_)
+      GLC(gl_, gl_->BlendBarrierKHR());
+
     ApplyBlendModeUsingBlendFunc(blend_mode);
+  }
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_,
       &highp_threshold_cache_,
       highp_threshold_min_,
       quad->shared_quad_state->visible_content_rect.bottom_right());
 
   int shader_quad_location = -1;
   int shader_edge_location = -1;
   int shader_viewport_location = -1;
@@ skipping 2180 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         overlay.display_rect,
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc