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 321 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;
 
   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 341 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) ||
-         blend_mode == SkXfermode::kScreen_Mode ||
-         blend_mode == SkXfermode::kSrcOver_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_SRC_OVER_NV;
+
+      switch (blend_mode) {
+      case SkXfermode::kScreen_Mode:

[piman, 2014/10/16 20:13:28]

nit: indent style (run git cl format?)

[Erik Dahlström (inactive), 2014/10/17 15:33:17]

Done.

+          equation = GL_SCREEN_NV;
+          break;
+      case SkXfermode::kOverlay_Mode:
+          equation = GL_OVERLAY_NV;
+          break;
+      case SkXfermode::kDarken_Mode:
+          equation = GL_DARKEN_NV;
+          break;
+      case SkXfermode::kLighten_Mode:
+          equation = GL_LIGHTEN_NV;
+          break;
+      case SkXfermode::kColorDodge_Mode:
+          equation = GL_COLORDODGE_NV;
+          break;
+      case SkXfermode::kColorBurn_Mode:
+          equation = GL_COLORBURN_NV;
+          break;
+      case SkXfermode::kHardLight_Mode:
+          equation = GL_HARDLIGHT_NV;
+          break;
+      case SkXfermode::kSoftLight_Mode:
+          equation = GL_SOFTLIGHT_NV;
+          break;
+      case SkXfermode::kDifference_Mode:
+          equation = GL_DIFFERENCE_NV;
+          break;
+      case SkXfermode::kExclusion_Mode:
+          equation = GL_EXCLUSION_NV;
+          break;
+      case SkXfermode::kMultiply_Mode:
+          equation = GL_MULTIPLY_NV;
+          break;
+      case SkXfermode::kHue_Mode:
+          equation = GL_HSL_HUE_NV;
+          break;
+      case SkXfermode::kSaturation_Mode:
+          equation = GL_HSL_SATURATION_NV;
+          break;
+      case SkXfermode::kColor_Mode:
+          equation = GL_HSL_COLOR_NV;
+          break;
+      case SkXfermode::kLuminosity_Mode:
+          equation = GL_HSL_LUMINOSITY_NV;
+          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));
+  }
 }
 
 static skia::RefPtr<SkImage> ApplyBlendModeWithBackdrop(
     scoped_ptr<GLRenderer::ScopedUseGrContext> use_gr_context,
     ResourceProvider* resource_provider,
     skia::RefPtr<SkImage> source_bitmap_with_filters,
     ScopedResource* source_texture_resource,
     ScopedResource* background_texture_resource,
     SkXfermode::Mode blend_mode) {
   if (!use_gr_context)
@@ skipping 449 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))
-    ApplyBlendModeUsingBlendFunc(blend_mode);
+  if (CanApplyBlendModeUsingBlendFunc(blend_mode)) {
+      if (use_blend_equation_advanced_)
+          GLC(gl_, gl_->BlendBarrierNV());

[piman, 2014/10/16 20:13:29]

Is it worth skipping this if we have GL_*_blend_equation_advanced_coherent?

[Erik Dahlström (inactive), 2014/10/17 15:33:17]

Perhaps, my current card/driver setup doesn't support the coherent mode so I
can't test if that's better/faster.

+
+      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 2074 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