Accelerate the lighten blendmode if GL_EXT_blend_minmax is enabled.

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 320 matching lines @@
   capabilities_.allow_partial_texture_updates = true;
 
   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;
 
   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 343 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::ShouldApplyBlendModeUsingBlendFunc(const DrawQuad* quad) {
-  SkXfermode::Mode blend_mode = quad->shared_quad_state->blend_mode;
-  return blend_mode == SkXfermode::kScreen_Mode ||
+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;
 }
 
-void GLRenderer::ApplyBlendModeUsingBlendFunc(const DrawQuad* quad) {
-  DCHECK(ShouldApplyBlendModeUsingBlendFunc(quad));
-  if (quad->shared_quad_state->blend_mode == SkXfermode::kScreen_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));
   }
 }
 
-void GLRenderer::RestoreBlendFuncToDefault() {
+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 (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 255 matching lines @@
 
   UseRenderPass(frame, target_render_pass);
 
   if (!using_background_texture)
     return nullptr;
   return background_texture.Pass();
 }
 
 void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
                                     const RenderPassDrawQuad* quad) {
+  SkXfermode::Mode blend_mode = quad->shared_quad_state->blend_mode;
   SetBlendEnabled(quad->ShouldDrawWithBlending() ||
-                  ShouldApplyBlendModeUsingBlendFunc(quad));
+                  (!IsDefaultBlendMode(blend_mode) &&
+                   CanApplyBlendModeUsingBlendFunc(blend_mode)));
 
   ScopedResource* contents_texture =
       render_pass_textures_.get(quad->render_pass_id);
   if (!contents_texture || !contents_texture->id())
     return;
 
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix, quad->quadTransform(), quad->rect);
   gfx::Transform contents_device_transform =
       frame->window_matrix * frame->projection_matrix * quad_rect_matrix;
   contents_device_transform.FlattenTo2d();
 
   // Can only draw surface if device matrix is invertible.
   gfx::Transform contents_device_transform_inverse(
       gfx::Transform::kSkipInitialization);
   if (!contents_device_transform.GetInverse(&contents_device_transform_inverse))
     return;
 
-  bool need_background_texture = !ShouldApplyBlendModeUsingBlendFunc(quad) ||
+  bool need_background_texture = !CanApplyBlendModeUsingBlendFunc(blend_mode) ||
                                  !quad->background_filters.IsEmpty();
   bool background_changed = false;
   scoped_ptr<ScopedResource> background_texture;
   if (need_background_texture) {
     // The pixels from the filtered background should completely replace the
     // current pixel values.
     bool disable_blending = blend_enabled();
     if (disable_blending)
       SetBlendEnabled(false);
 
@@ skipping 34 matching lines @@
             ApplyImageFilter(ScopedUseGrContext::Create(this, frame),
                              resource_provider_,
                              quad->rect.origin(),
                              quad->filters_scale,
                              filter.get(),
                              contents_texture);
       }
     }
   }
 
-  if (background_texture && !ShouldApplyBlendModeUsingBlendFunc(quad)) {
+  if (background_texture && !CanApplyBlendModeUsingBlendFunc(blend_mode)) {

[enne (OOO), 2014/10/07 17:51:17]

I think this CanApplyBlendModeUsingBlendFunc check is redundant here.  Maybe
just DCHECK it?

[Erik Dahlström (inactive), 2014/10/08 15:25:20]

No, I don't think it's redundant, have a look at the rebased version which
hopefully is a bit more clear.

     filter_bitmap =
         ApplyBlendModeWithBackdrop(ScopedUseGrContext::Create(this, frame),
                                    resource_provider_,
                                    filter_bitmap,
                                    contents_texture,
                                    background_texture.get(),
                                    quad->shared_quad_state->blend_mode);
   }
 
   // Draw the background texture if it has some filters applied.
@@ skipping 47 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 (ShouldApplyBlendModeUsingBlendFunc(quad))
-    ApplyBlendModeUsingBlendFunc(quad);
+  if (CanApplyBlendModeUsingBlendFunc(blend_mode))
+    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 228 matching lines @@
   SetShaderOpacity(quad->opacity(), shader_alpha_location);
   SetShaderQuadF(surface_quad, shader_quad_location);
   DrawQuadGeometry(
       frame, quad->quadTransform(), quad->rect, shader_matrix_location);
 
   // Flush the compositor context before the filter bitmap goes out of
   // scope, so the draw gets processed before the filter texture gets deleted.
   if (filter_bitmap)
     GLC(gl_, gl_->Flush());
 
-  if (ShouldApplyBlendModeUsingBlendFunc(quad))
-    RestoreBlendFuncToDefault();
+  if (CanApplyBlendModeUsingBlendFunc(blend_mode))
+    RestoreBlendFuncToDefault(blend_mode);
 }
 
 struct SolidColorProgramUniforms {
   unsigned program;
   unsigned matrix_location;
   unsigned viewport_location;
   unsigned quad_location;
   unsigned edge_location;
   unsigned color_location;
 };
@@ skipping 1824 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