Revert "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 356 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;
   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();
@@ skipping 344 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_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 (use_blend_equation_advanced_) {
     GLenum equation = GL_FUNC_ADD;
@@ skipping 45 matching lines @@
         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;
 
   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));
   }
 }
 
 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
@@ skipping 2522 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