Implement mix-blend-mode in GL renderer using shaders.

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 709 matching lines @@
 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)
-    return source_bitmap_with_filters;
-
-  DCHECK(background_texture_resource);
-  DCHECK(source_texture_resource);
-
-  gfx::Size source_size = source_texture_resource->size();
-  gfx::Size background_size = background_texture_resource->size();
-
-  DCHECK_LE(background_size.width(), source_size.width());
-  DCHECK_LE(background_size.height(), source_size.height());
-
-  int source_texture_with_filters_id;
-  scoped_ptr<ResourceProvider::ScopedReadLockGL> lock;
-  if (source_bitmap_with_filters) {
-    DCHECK_EQ(source_size.width(), source_bitmap_with_filters->width());
-    DCHECK_EQ(source_size.height(), source_bitmap_with_filters->height());
-    GrTexture* texture =
-        reinterpret_cast<GrTexture*>(source_bitmap_with_filters->getTexture());
-    source_texture_with_filters_id = texture->getTextureHandle();
-  } else {
-    lock.reset(new ResourceProvider::ScopedReadLockGL(
-        resource_provider, source_texture_resource->id()));
-    source_texture_with_filters_id = lock->texture_id();
-  }
-
-  ResourceProvider::ScopedReadLockGL lock_background(
-      resource_provider, background_texture_resource->id());
-
-  // Wrap the source texture in a Ganesh platform texture.
-  GrBackendTextureDesc backend_texture_description;
-  backend_texture_description.fConfig = kSkia8888_GrPixelConfig;
-  backend_texture_description.fOrigin = kBottomLeft_GrSurfaceOrigin;
-
-  backend_texture_description.fWidth = source_size.width();
-  backend_texture_description.fHeight = source_size.height();
-  backend_texture_description.fTextureHandle = source_texture_with_filters_id;
-  skia::RefPtr<GrTexture> source_texture =
-      skia::AdoptRef(use_gr_context->context()->wrapBackendTexture(
-          backend_texture_description));
-  if (!source_texture) {
-    TRACE_EVENT_INSTANT0(
-        "cc",
-        "ApplyBlendModeWithBackdrop wrap source texture failed",
-        TRACE_EVENT_SCOPE_THREAD);
-    return skia::RefPtr<SkImage>();
-  }
-
-  backend_texture_description.fWidth = background_size.width();
-  backend_texture_description.fHeight = background_size.height();
-  backend_texture_description.fTextureHandle = lock_background.texture_id();
-  skia::RefPtr<GrTexture> background_texture =
-      skia::AdoptRef(use_gr_context->context()->wrapBackendTexture(
-          backend_texture_description));
-  if (!background_texture) {
-    TRACE_EVENT_INSTANT0(
-        "cc",
-        "ApplyBlendModeWithBackdrop wrap background texture failed",
-        TRACE_EVENT_SCOPE_THREAD);
-    return skia::RefPtr<SkImage>();
-  }
-
-  SkImageInfo source_info =
-      SkImageInfo::MakeN32Premul(source_size.width(), source_size.height());
-  // Place the platform texture inside an SkBitmap.
-  SkBitmap source;
-  source.setInfo(source_info);
-  skia::RefPtr<SkGrPixelRef> source_pixel_ref =
-      skia::AdoptRef(new SkGrPixelRef(source_info, source_texture.get()));
-  source.setPixelRef(source_pixel_ref.get());
-
-  SkImageInfo background_info = SkImageInfo::MakeN32Premul(
-      background_size.width(), background_size.height());
-
-  SkBitmap background;
-  background.setInfo(background_info);
-  skia::RefPtr<SkGrPixelRef> background_pixel_ref =
-      skia::AdoptRef(new SkGrPixelRef(
-          background_info, background_texture.get()));
-  background.setPixelRef(background_pixel_ref.get());
-
-  // Create a scratch texture for backing store.
-  GrTextureDesc desc;
-  desc.fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit;
-  desc.fSampleCnt = 0;
-  desc.fWidth = source.width();
-  desc.fHeight = source.height();
-  desc.fConfig = kSkia8888_GrPixelConfig;
-  desc.fOrigin = kBottomLeft_GrSurfaceOrigin;
-  GrAutoScratchTexture scratch_texture(
-      use_gr_context->context(), desc, GrContext::kExact_ScratchTexMatch);
-  skia::RefPtr<GrTexture> backing_store =
-      skia::AdoptRef(scratch_texture.detach());
-  if (!backing_store) {
-    TRACE_EVENT_INSTANT0(
-        "cc",
-        "ApplyBlendModeWithBackdrop scratch texture allocation failed",
-        TRACE_EVENT_SCOPE_THREAD);
-    return source_bitmap_with_filters;
-  }
-
-  // Create a device and canvas using that backing store.
-  skia::RefPtr<SkSurface> surface = skia::AdoptRef(
-      SkSurface::NewRenderTargetDirect(backing_store->asRenderTarget()));
-  if (!surface)
-    return skia::RefPtr<SkImage>();
-  skia::RefPtr<SkCanvas> canvas = skia::SharePtr(surface->getCanvas());
-
-  // Draw the source bitmap through the filter to the canvas.
-  canvas->clear(SK_ColorTRANSPARENT);
-  canvas->drawSprite(background, 0, 0);
-  SkPaint paint;
-  paint.setXfermodeMode(blend_mode);
-  canvas->drawSprite(source, 0, 0, &paint);
-
-  skia::RefPtr<SkImage> image = skia::AdoptRef(surface->newImageSnapshot());
-  if (!image || !image->getTexture()) {
-    return skia::RefPtr<SkImage>();
-  }
-
-  // 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::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.
   if (frame->current_render_pass->has_transparent_background)
     return false;
@@ skipping 143 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() ||
-                  (!IsDefaultBlendMode(blend_mode) &&
-                   CanApplyBlendModeUsingBlendFunc(blend_mode)));
+  SetBlendEnabled(
+      CanApplyBlendModeUsingBlendFunc(blend_mode) &&
+      (quad->ShouldDrawWithBlending() || !IsDefaultBlendMode(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 = !CanApplyBlendModeUsingBlendFunc(blend_mode) ||
                                  ShouldApplyBackgroundFilters(frame, quad);
 
   scoped_ptr<ScopedResource> background_texture;
+  skia::RefPtr<SkImage> background_image;
+  gfx::Rect background_rect;
   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);
 
     // Compute a bounding box around the pixels that will be visible through
     // the quad.
-    gfx::Rect backdrop_rect = GetBackdropBoundingBoxForRenderPassQuad(
+    background_rect = GetBackdropBoundingBoxForRenderPassQuad(
         frame, quad, contents_device_transform);
 
     // Read the pixels in the bounding box into a buffer R.
     scoped_ptr<ScopedResource> scoped_background_texture =
-        GetBackdropTexture(backdrop_rect);
+        GetBackdropTexture(background_rect);
 
     skia::RefPtr<SkImage> background_with_filters;
     if (ShouldApplyBackgroundFilters(frame, quad)) {
       // Apply the background filters to R, so that it is applied in the pixels'
       // coordinate space.
       background_with_filters =
           ApplyBackgroundFilters(frame, quad, scoped_background_texture.get());
+
+      // Apply the quad's inverse transform to map the pixels in R into the
+      // quad's content space. This implicitly clips R by the content bounds of
+      // the quad since the destination texture has bounds matching the quad's
+      // content.
+      // This is not necessary if blend mode will be applied using shaders.
+      if (CanApplyBlendModeUsingBlendFunc(blend_mode)) {
+        background_texture = ApplyInverseTransformForBackgroundFilters(
+            frame,
+            quad,
+            contents_device_transform_inverse,
+            scoped_background_texture.get(),
+            background_with_filters,
+            background_rect);
+      } else {
+        background_image = background_with_filters;
+      }
+    } else {
+      // Will be used as backdrop for blending with shaders.
+      DCHECK(!CanApplyBlendModeUsingBlendFunc(blend_mode));
+      background_texture = scoped_background_texture.Pass();
     }
-    // Apply the quad's inverse transform to map the pixels in R into the
-    // quad's content space. This implicitly clips R by the content bounds of
-    // the quad since the destination texture has bounds matching the quad's
-    // content.
-    background_texture = ApplyInverseTransformForBackgroundFilters(
-        frame,
-        quad,
-        contents_device_transform_inverse,
-        scoped_background_texture.get(),
-        background_with_filters,
-        backdrop_rect);
 
     if (disable_blending)
       SetBlendEnabled(true);
   }
 
   // TODO(senorblanco): Cache this value so that we don't have to do it for both
   // the surface and its replica.  Apply filters to the contents texture.
   skia::RefPtr<SkImage> filter_bitmap;
   SkScalar color_matrix[20];
   bool use_color_matrix = false;
@@ skipping 18 matching lines @@
             ApplyImageFilter(ScopedUseGrContext::Create(this, frame),
                              resource_provider_,
                              quad->rect.origin(),
                              quad->filters_scale,
                              filter.get(),
                              contents_texture);
       }
     }
   }
 
-  if (background_texture) {
-    if (CanApplyBlendModeUsingBlendFunc(blend_mode)) {
-      // Draw the background texture if it has some filters applied.
-      DCHECK(ShouldApplyBackgroundFilters(frame, quad));
-      DCHECK(background_texture->size() == quad->rect.size());
-      ResourceProvider::ScopedReadLockGL lock(resource_provider_,
-                                              background_texture->id());
+  if (background_texture && ShouldApplyBackgroundFilters(frame, quad)) {
+    // Draw the background texture if it has some filters applied.
+    DCHECK(CanApplyBlendModeUsingBlendFunc(blend_mode));
+    DCHECK(background_texture->size() == quad->rect.size());
+    ResourceProvider::ScopedReadLockGL lock(resource_provider_,
+                                            background_texture->id());
 
-      // The background_texture is oriented the same as the frame buffer. The
-      // transform we are copying with has a vertical flip, so flip the contents
-      // in the shader to maintain orientation
-      bool flip_vertically = true;
+    // The background_texture is oriented the same as the frame buffer. The
+    // transform we are copying with has a vertical flip, so flip the contents
+    // in the shader to maintain orientation
+    bool flip_vertically = true;
 
-      CopyTextureToFramebuffer(frame,
-                               lock.texture_id(),
-                               quad->rect,
-                               quad->quadTransform(),
-                               flip_vertically);
-    } else {
-      // If blending is applied using shaders, the background texture with
-      // filters will be used as backdrop for blending operation, so we don't
-      // need to copy it to the frame buffer.
-      filter_bitmap =
-          ApplyBlendModeWithBackdrop(ScopedUseGrContext::Create(this, frame),
-                                     resource_provider_,
-                                     filter_bitmap,
-                                     contents_texture,
-                                     background_texture.get(),
-                                     quad->shared_quad_state->blend_mode);
-    }
+    CopyTextureToFramebuffer(frame,
+                             lock.texture_id(),
+                             quad->rect,
+                             quad->quadTransform(),
+                             flip_vertically);
   }
 
   bool clipped = false;
   gfx::QuadF device_quad = MathUtil::MapQuad(
       contents_device_transform, SharedGeometryQuad(), &clipped);
   LayerQuad device_layer_bounds(gfx::QuadF(device_quad.BoundingBox()));
   LayerQuad device_layer_edges(device_quad);
 
   // Use anti-aliasing programs only when necessary.
   bool use_aa =
@@ skipping 42 matching lines @@
   int shader_edge_location = -1;
   int shader_viewport_location = -1;
   int shader_mask_sampler_location = -1;
   int shader_mask_tex_coord_scale_location = -1;
   int shader_mask_tex_coord_offset_location = -1;
   int shader_matrix_location = -1;
   int shader_alpha_location = -1;
   int shader_color_matrix_location = -1;
   int shader_color_offset_location = -1;
   int shader_tex_transform_location = -1;
+  int shader_backdrop_location = -1;
+  int shader_backdrop_rect_location = -1;
+
+  SkXfermode::Mode shader_blend_mode =
+      ((background_texture || background_image) &&
+       !CanApplyBlendModeUsingBlendFunc(blend_mode))
+          ? blend_mode
+          : kDefaultBlendMode;
 
   if (use_aa && mask_texture_id && !use_color_matrix) {
     const RenderPassMaskProgramAA* program =
-        GetRenderPassMaskProgramAA(tex_coord_precision);
+        GetRenderPassMaskProgramAA(tex_coord_precision, shader_blend_mode);
     SetUseProgram(program->program());
     GLC(gl_, gl_->Uniform1i(program->fragment_shader().sampler_location(), 0));
 
     shader_quad_location = program->vertex_shader().quad_location();
     shader_edge_location = program->vertex_shader().edge_location();
     shader_viewport_location = program->vertex_shader().viewport_location();
     shader_mask_sampler_location =
         program->fragment_shader().mask_sampler_location();
     shader_mask_tex_coord_scale_location =
         program->fragment_shader().mask_tex_coord_scale_location();
     shader_mask_tex_coord_offset_location =
         program->fragment_shader().mask_tex_coord_offset_location();
     shader_matrix_location = program->vertex_shader().matrix_location();
     shader_alpha_location = program->fragment_shader().alpha_location();
     shader_tex_transform_location =
         program->vertex_shader().tex_transform_location();
+    shader_backdrop_location = program->fragment_shader().backdrop_location();
+    shader_backdrop_rect_location =
+        program->fragment_shader().backdrop_rect_location();
   } else if (!use_aa && mask_texture_id && !use_color_matrix) {
     const RenderPassMaskProgram* program =
-        GetRenderPassMaskProgram(tex_coord_precision);
+        GetRenderPassMaskProgram(tex_coord_precision, shader_blend_mode);
     SetUseProgram(program->program());
     GLC(gl_, gl_->Uniform1i(program->fragment_shader().sampler_location(), 0));
 
     shader_mask_sampler_location =
         program->fragment_shader().mask_sampler_location();
     shader_mask_tex_coord_scale_location =
         program->fragment_shader().mask_tex_coord_scale_location();
     shader_mask_tex_coord_offset_location =
         program->fragment_shader().mask_tex_coord_offset_location();
     shader_matrix_location = program->vertex_shader().matrix_location();
     shader_alpha_location = program->fragment_shader().alpha_location();
     shader_tex_transform_location =
         program->vertex_shader().tex_transform_location();
+    shader_backdrop_location = program->fragment_shader().backdrop_location();
+    shader_backdrop_rect_location =
+        program->fragment_shader().backdrop_rect_location();
   } else if (use_aa && !mask_texture_id && !use_color_matrix) {
     const RenderPassProgramAA* program =
-        GetRenderPassProgramAA(tex_coord_precision);
+        GetRenderPassProgramAA(tex_coord_precision, shader_blend_mode);
     SetUseProgram(program->program());
     GLC(gl_, gl_->Uniform1i(program->fragment_shader().sampler_location(), 0));
 
     shader_quad_location = program->vertex_shader().quad_location();
     shader_edge_location = program->vertex_shader().edge_location();
     shader_viewport_location = program->vertex_shader().viewport_location();
     shader_matrix_location = program->vertex_shader().matrix_location();
     shader_alpha_location = program->fragment_shader().alpha_location();
     shader_tex_transform_location =
         program->vertex_shader().tex_transform_location();
+    shader_backdrop_location = program->fragment_shader().backdrop_location();
+    shader_backdrop_rect_location =
+        program->fragment_shader().backdrop_rect_location();
   } else if (use_aa && mask_texture_id && use_color_matrix) {
     const RenderPassMaskColorMatrixProgramAA* program =
-        GetRenderPassMaskColorMatrixProgramAA(tex_coord_precision);
+        GetRenderPassMaskColorMatrixProgramAA(tex_coord_precision,
+                                              shader_blend_mode);
     SetUseProgram(program->program());
     GLC(gl_, gl_->Uniform1i(program->fragment_shader().sampler_location(), 0));
 
     shader_matrix_location = program->vertex_shader().matrix_location();
     shader_quad_location = program->vertex_shader().quad_location();
     shader_tex_transform_location =
         program->vertex_shader().tex_transform_location();
     shader_edge_location = program->vertex_shader().edge_location();
     shader_viewport_location = program->vertex_shader().viewport_location();
     shader_alpha_location = program->fragment_shader().alpha_location();
     shader_mask_sampler_location =
         program->fragment_shader().mask_sampler_location();
     shader_mask_tex_coord_scale_location =
         program->fragment_shader().mask_tex_coord_scale_location();
     shader_mask_tex_coord_offset_location =
         program->fragment_shader().mask_tex_coord_offset_location();
     shader_color_matrix_location =
         program->fragment_shader().color_matrix_location();
     shader_color_offset_location =
         program->fragment_shader().color_offset_location();
+    shader_backdrop_location = program->fragment_shader().backdrop_location();
+    shader_backdrop_rect_location =
+        program->fragment_shader().backdrop_rect_location();
   } else if (use_aa && !mask_texture_id && use_color_matrix) {
     const RenderPassColorMatrixProgramAA* program =
-        GetRenderPassColorMatrixProgramAA(tex_coord_precision);
+        GetRenderPassColorMatrixProgramAA(tex_coord_precision,
+                                          shader_blend_mode);
     SetUseProgram(program->program());
     GLC(gl_, gl_->Uniform1i(program->fragment_shader().sampler_location(), 0));
 
     shader_matrix_location = program->vertex_shader().matrix_location();
     shader_quad_location = program->vertex_shader().quad_location();
     shader_tex_transform_location =
         program->vertex_shader().tex_transform_location();
     shader_edge_location = program->vertex_shader().edge_location();
     shader_viewport_location = program->vertex_shader().viewport_location();
     shader_alpha_location = program->fragment_shader().alpha_location();
     shader_color_matrix_location =
         program->fragment_shader().color_matrix_location();
     shader_color_offset_location =
         program->fragment_shader().color_offset_location();
+    shader_backdrop_location = program->fragment_shader().backdrop_location();
+    shader_backdrop_rect_location =
+        program->fragment_shader().backdrop_rect_location();
   } else if (!use_aa && mask_texture_id && use_color_matrix) {
     const RenderPassMaskColorMatrixProgram* program =
-        GetRenderPassMaskColorMatrixProgram(tex_coord_precision);
+        GetRenderPassMaskColorMatrixProgram(tex_coord_precision,
+                                            shader_blend_mode);
     SetUseProgram(program->program());
     GLC(gl_, gl_->Uniform1i(program->fragment_shader().sampler_location(), 0));
 
     shader_matrix_location = program->vertex_shader().matrix_location();
     shader_tex_transform_location =
         program->vertex_shader().tex_transform_location();
     shader_mask_sampler_location =
         program->fragment_shader().mask_sampler_location();
     shader_mask_tex_coord_scale_location =
         program->fragment_shader().mask_tex_coord_scale_location();
     shader_mask_tex_coord_offset_location =
         program->fragment_shader().mask_tex_coord_offset_location();
     shader_alpha_location = program->fragment_shader().alpha_location();
     shader_color_matrix_location =
         program->fragment_shader().color_matrix_location();
     shader_color_offset_location =
         program->fragment_shader().color_offset_location();
+    shader_backdrop_location = program->fragment_shader().backdrop_location();
+    shader_backdrop_rect_location =
+        program->fragment_shader().backdrop_rect_location();
   } else if (!use_aa && !mask_texture_id && use_color_matrix) {
     const RenderPassColorMatrixProgram* program =
-        GetRenderPassColorMatrixProgram(tex_coord_precision);
+        GetRenderPassColorMatrixProgram(tex_coord_precision, shader_blend_mode);
     SetUseProgram(program->program());
     GLC(gl_, gl_->Uniform1i(program->fragment_shader().sampler_location(), 0));
 
     shader_matrix_location = program->vertex_shader().matrix_location();
     shader_tex_transform_location =
         program->vertex_shader().tex_transform_location();
     shader_alpha_location = program->fragment_shader().alpha_location();
     shader_color_matrix_location =
         program->fragment_shader().color_matrix_location();
     shader_color_offset_location =
         program->fragment_shader().color_offset_location();
+    shader_backdrop_location = program->fragment_shader().backdrop_location();
+    shader_backdrop_rect_location =
+        program->fragment_shader().backdrop_rect_location();
   } else {
     const RenderPassProgram* program =
-        GetRenderPassProgram(tex_coord_precision);
+        GetRenderPassProgram(tex_coord_precision, shader_blend_mode);
     SetUseProgram(program->program());
     GLC(gl_, gl_->Uniform1i(program->fragment_shader().sampler_location(), 0));
 
     shader_matrix_location = program->vertex_shader().matrix_location();
     shader_alpha_location = program->fragment_shader().alpha_location();
     shader_tex_transform_location =
         program->vertex_shader().tex_transform_location();
+    shader_backdrop_location = program->fragment_shader().backdrop_location();
+    shader_backdrop_rect_location =
+        program->fragment_shader().backdrop_rect_location();
   }
   float tex_scale_x =
       quad->rect.width() / static_cast<float>(contents_texture->size().width());
   float tex_scale_y = quad->rect.height() /
                       static_cast<float>(contents_texture->size().height());
   DCHECK_LE(tex_scale_x, 1.0f);
   DCHECK_LE(tex_scale_y, 1.0f);
 
   DCHECK(shader_tex_transform_location != -1 || IsContextLost());
   // Flip the content vertically in the shader, as the RenderPass input
   // texture is already oriented the same way as the framebuffer, but the
   // projection transform does a flip.
   GLC(gl_,
       gl_->Uniform4f(shader_tex_transform_location,
                      0.0f,
                      tex_scale_y,
                      tex_scale_x,
                      -tex_scale_y));
 
+  GLint last_texture_unit = 0;
   scoped_ptr<ResourceProvider::ScopedSamplerGL> shader_mask_sampler_lock;
   if (shader_mask_sampler_location != -1) {
     DCHECK_NE(shader_mask_tex_coord_scale_location, 1);
     DCHECK_NE(shader_mask_tex_coord_offset_location, 1);
     GLC(gl_, gl_->Uniform1i(shader_mask_sampler_location, 1));
 
     float mask_tex_scale_x = quad->mask_uv_rect.width() / tex_scale_x;
     float mask_tex_scale_y = quad->mask_uv_rect.height() / tex_scale_y;
 
     // Mask textures are oriented vertically flipped relative to the framebuffer
     // and the RenderPass contents texture, so we flip the tex coords from the
     // RenderPass texture to find the mask texture coords.
     GLC(gl_,
         gl_->Uniform2f(shader_mask_tex_coord_offset_location,
                        quad->mask_uv_rect.x(),
                        quad->mask_uv_rect.y() + quad->mask_uv_rect.height()));
     GLC(gl_,
         gl_->Uniform2f(shader_mask_tex_coord_scale_location,
                        mask_tex_scale_x,
                        -mask_tex_scale_y));
     shader_mask_sampler_lock = make_scoped_ptr(
         new ResourceProvider::ScopedSamplerGL(resource_provider_,
                                               quad->mask_resource_id,
                                               GL_TEXTURE1,
                                               GL_LINEAR));
     DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
               shader_mask_sampler_lock->target());
+    last_texture_unit = 1;
   }
 
   if (shader_edge_location != -1) {
     float edge[24];
     device_layer_edges.ToFloatArray(edge);
     device_layer_bounds.ToFloatArray(&edge[12]);
     GLC(gl_, gl_->Uniform3fv(shader_edge_location, 8, edge));
   }
 
   if (shader_viewport_location != -1) {
@@ skipping 15 matching lines @@
   }
   static const float kScale = 1.0f / 255.0f;
   if (shader_color_offset_location != -1) {
     float offset[4];
     for (int i = 0; i < 4; ++i)
       offset[i] = SkScalarToFloat(color_matrix[i * 5 + 4]) * kScale;
 
     GLC(gl_, gl_->Uniform4fv(shader_color_offset_location, 1, offset));
   }
 
+  scoped_ptr<ResourceProvider::ScopedSamplerGL> shader_background_sampler_lock;
+  if (shader_backdrop_location != -1) {
+    DCHECK(background_texture || background_image);
+    DCHECK_NE(shader_backdrop_location, 0);
+    DCHECK_NE(shader_backdrop_rect_location, 0);
+
+    GLC(gl_, gl_->Uniform1i(shader_backdrop_location, ++last_texture_unit));
+
+    GLC(gl_,
+        gl_->Uniform4f(shader_backdrop_rect_location,
+                       background_rect.x(),
+                       background_rect.y(),
+                       background_rect.width(),
+                       background_rect.height()));
+
+    if (background_image) {
+      GrTexture* texture = background_image->getTexture();
+      GLC(gl_, gl_->ActiveTexture(GL_TEXTURE0 + last_texture_unit));
+      gl_->BindTexture(GL_TEXTURE_2D, texture->getTextureHandle());
+      GLC(gl_, gl_->ActiveTexture(GL_TEXTURE0));
+    } else {
+      shader_background_sampler_lock = make_scoped_ptr(
+          new ResourceProvider::ScopedSamplerGL(resource_provider_,
+                                                background_texture->id(),
+                                                GL_TEXTURE0 + last_texture_unit,
+                                                GL_LINEAR));
+      DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
+                shader_background_sampler_lock->target());
+    }
+  }
+
   // Map device space quad to surface space. contents_device_transform has no 3d
   // component since it was flattened, so we don't need to project.
   gfx::QuadF surface_quad = MathUtil::MapQuad(contents_device_transform_inverse,
                                               device_layer_edges.ToQuadF(),
                                               &clipped);
 
   SetShaderOpacity(quad->opacity(), shader_alpha_location);
   SetShaderQuadF(surface_quad, shader_quad_location);
   DrawQuadGeometry(
       frame, quad->quadTransform(), quad->rect, shader_matrix_location);
@@ skipping 915 matching lines @@
 }
 
 void GLRenderer::CopyTextureToFramebuffer(const DrawingFrame* frame,
                                           int texture_id,
                                           const gfx::Rect& rect,
                                           const gfx::Transform& draw_matrix,
                                           bool flip_vertically) {
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_, &highp_threshold_cache_, highp_threshold_min_, rect.bottom_right());
 
-  const RenderPassProgram* program = GetRenderPassProgram(tex_coord_precision);
+  const RenderPassProgram* program =
+      GetRenderPassProgram(tex_coord_precision, kDefaultBlendMode);
   SetUseProgram(program->program());
 
   GLC(gl_, gl_->Uniform1i(program->fragment_shader().sampler_location(), 0));
 
   if (flip_vertically) {
     GLC(gl_,
         gl_->Uniform4f(program->vertex_shader().tex_transform_location(),
                        0.f,
                        1.f,
                        1.f,
@@ skipping 458 matching lines @@
   if (!solid_color_program_aa_.initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::solidColorProgramAA::initialize");
     solid_color_program_aa_.Initialize(output_surface_->context_provider(),
                                        TexCoordPrecisionNA,
                                        SamplerTypeNA);
   }
   return &solid_color_program_aa_;
 }
 
 const GLRenderer::RenderPassProgram* GLRenderer::GetRenderPassProgram(
-    TexCoordPrecision precision) {
+    TexCoordPrecision precision,
+    SkXfermode::Mode blend_mode) {
   DCHECK_GE(precision, 0);
   DCHECK_LT(precision, NumTexCoordPrecisions);
-  RenderPassProgram* program = &render_pass_program_[precision];
+  int bm = index_for_blend_mode(blend_mode);
+  RenderPassProgram* program = &render_pass_program_[precision][bm];
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::renderPassProgram::initialize");
-    program->Initialize(
-        output_surface_->context_provider(), precision, SamplerType2D);
+    program->Initialize(output_surface_->context_provider(),
+                        precision,
+                        SamplerType2D,
+                        blend_mode);
   }
   return program;
 }
 
 const GLRenderer::RenderPassProgramAA* GLRenderer::GetRenderPassProgramAA(
-    TexCoordPrecision precision) {
+    TexCoordPrecision precision,
+    SkXfermode::Mode blend_mode) {
   DCHECK_GE(precision, 0);
   DCHECK_LT(precision, NumTexCoordPrecisions);
-  RenderPassProgramAA* program = &render_pass_program_aa_[precision];
+  int bm = index_for_blend_mode(blend_mode);
+  RenderPassProgramAA* program = &render_pass_program_aa_[precision][bm];
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::renderPassProgramAA::initialize");
-    program->Initialize(
-        output_surface_->context_provider(), precision, SamplerType2D);
+    program->Initialize(output_surface_->context_provider(),
+                        precision,
+                        SamplerType2D,
+                        blend_mode);
   }
   return program;
 }
 
 const GLRenderer::RenderPassMaskProgram* GLRenderer::GetRenderPassMaskProgram(
-    TexCoordPrecision precision) {
+    TexCoordPrecision precision,
+    SkXfermode::Mode blend_mode) {
   DCHECK_GE(precision, 0);
   DCHECK_LT(precision, NumTexCoordPrecisions);
-  RenderPassMaskProgram* program = &render_pass_mask_program_[precision];
+  int bm = index_for_blend_mode(blend_mode);
+  RenderPassMaskProgram* program = &render_pass_mask_program_[precision][bm];
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::renderPassMaskProgram::initialize");
-    program->Initialize(
-        output_surface_->context_provider(), precision, SamplerType2D);
+    program->Initialize(output_surface_->context_provider(),
+                        precision,
+                        SamplerType2D,
+                        blend_mode);
   }
   return program;
 }
 
 const GLRenderer::RenderPassMaskProgramAA*
-GLRenderer::GetRenderPassMaskProgramAA(TexCoordPrecision precision) {
+GLRenderer::GetRenderPassMaskProgramAA(TexCoordPrecision precision,
+                                       SkXfermode::Mode blend_mode) {
   DCHECK_GE(precision, 0);
   DCHECK_LT(precision, NumTexCoordPrecisions);
-  RenderPassMaskProgramAA* program = &render_pass_mask_program_aa_[precision];
+  int bm = index_for_blend_mode(blend_mode);
+  RenderPassMaskProgramAA* program =
+      &render_pass_mask_program_aa_[precision][bm];
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::renderPassMaskProgramAA::initialize");
-    program->Initialize(
-        output_surface_->context_provider(), precision, SamplerType2D);
+    program->Initialize(output_surface_->context_provider(),
+                        precision,
+                        SamplerType2D,
+                        blend_mode);
   }
   return program;
 }
 
 const GLRenderer::RenderPassColorMatrixProgram*
-GLRenderer::GetRenderPassColorMatrixProgram(TexCoordPrecision precision) {
+GLRenderer::GetRenderPassColorMatrixProgram(TexCoordPrecision precision,
+                                            SkXfermode::Mode blend_mode) {
   DCHECK_GE(precision, 0);
   DCHECK_LT(precision, NumTexCoordPrecisions);
+  int bm = index_for_blend_mode(blend_mode);
   RenderPassColorMatrixProgram* program =
-      &render_pass_color_matrix_program_[precision];
+      &render_pass_color_matrix_program_[precision][bm];
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::renderPassColorMatrixProgram::initialize");
-    program->Initialize(
-        output_surface_->context_provider(), precision, SamplerType2D);
+    program->Initialize(output_surface_->context_provider(),
+                        precision,
+                        SamplerType2D,
+                        blend_mode);
   }
   return program;
 }
 
 const GLRenderer::RenderPassColorMatrixProgramAA*
-GLRenderer::GetRenderPassColorMatrixProgramAA(TexCoordPrecision precision) {
+GLRenderer::GetRenderPassColorMatrixProgramAA(TexCoordPrecision precision,
+                                              SkXfermode::Mode blend_mode) {
   DCHECK_GE(precision, 0);
   DCHECK_LT(precision, NumTexCoordPrecisions);
+  int bm = index_for_blend_mode(blend_mode);
   RenderPassColorMatrixProgramAA* program =
-      &render_pass_color_matrix_program_aa_[precision];
+      &render_pass_color_matrix_program_aa_[precision][bm];
   if (!program->initialized()) {
     TRACE_EVENT0("cc",
                  "GLRenderer::renderPassColorMatrixProgramAA::initialize");
-    program->Initialize(
-        output_surface_->context_provider(), precision, SamplerType2D);
+    program->Initialize(output_surface_->context_provider(),
+                        precision,
+                        SamplerType2D,
+                        blend_mode);
   }
   return program;
 }
 
 const GLRenderer::RenderPassMaskColorMatrixProgram*
-GLRenderer::GetRenderPassMaskColorMatrixProgram(TexCoordPrecision precision) {
+GLRenderer::GetRenderPassMaskColorMatrixProgram(TexCoordPrecision precision,
+                                                SkXfermode::Mode blend_mode) {
   DCHECK_GE(precision, 0);
   DCHECK_LT(precision, NumTexCoordPrecisions);
+  int bm = index_for_blend_mode(blend_mode);
   RenderPassMaskColorMatrixProgram* program =
-      &render_pass_mask_color_matrix_program_[precision];
+      &render_pass_mask_color_matrix_program_[precision][bm];
   if (!program->initialized()) {
     TRACE_EVENT0("cc",
                  "GLRenderer::renderPassMaskColorMatrixProgram::initialize");
-    program->Initialize(
-        output_surface_->context_provider(), precision, SamplerType2D);
+    program->Initialize(output_surface_->context_provider(),
+                        precision,
+                        SamplerType2D,
+                        blend_mode);
   }
   return program;
 }
 
 const GLRenderer::RenderPassMaskColorMatrixProgramAA*
-GLRenderer::GetRenderPassMaskColorMatrixProgramAA(TexCoordPrecision precision) {
+GLRenderer::GetRenderPassMaskColorMatrixProgramAA(TexCoordPrecision precision,
+                                                  SkXfermode::Mode blend_mode) {
   DCHECK_GE(precision, 0);
   DCHECK_LT(precision, NumTexCoordPrecisions);
+  int bm = index_for_blend_mode(blend_mode);
   RenderPassMaskColorMatrixProgramAA* program =
-      &render_pass_mask_color_matrix_program_aa_[precision];
+      &render_pass_mask_color_matrix_program_aa_[precision][bm];
   if (!program->initialized()) {
     TRACE_EVENT0("cc",
                  "GLRenderer::renderPassMaskColorMatrixProgramAA::initialize");
-    program->Initialize(
-        output_surface_->context_provider(), precision, SamplerType2D);
+    program->Initialize(output_surface_->context_provider(),
+                        precision,
+                        SamplerType2D,
+                        blend_mode);
   }
   return program;
 }
 
 const GLRenderer::TileProgram* GLRenderer::GetTileProgram(
     TexCoordPrecision precision,
     SamplerType sampler) {
   DCHECK_GE(precision, 0);
   DCHECK_LT(precision, NumTexCoordPrecisions);
   DCHECK_GE(sampler, 0);
@@ skipping 205 matching lines @@
 
   for (int i = 0; i < NumTexCoordPrecisions; ++i) {
     for (int j = 0; j < NumSamplerTypes; ++j) {
       tile_program_[i][j].Cleanup(gl_);
       tile_program_opaque_[i][j].Cleanup(gl_);
       tile_program_swizzle_[i][j].Cleanup(gl_);
       tile_program_swizzle_opaque_[i][j].Cleanup(gl_);
       tile_program_aa_[i][j].Cleanup(gl_);
       tile_program_swizzle_aa_[i][j].Cleanup(gl_);
     }
-
-    render_pass_mask_program_[i].Cleanup(gl_);
-    render_pass_program_[i].Cleanup(gl_);
-    render_pass_mask_program_aa_[i].Cleanup(gl_);
-    render_pass_program_aa_[i].Cleanup(gl_);
-    render_pass_color_matrix_program_[i].Cleanup(gl_);
-    render_pass_mask_color_matrix_program_aa_[i].Cleanup(gl_);
-    render_pass_color_matrix_program_aa_[i].Cleanup(gl_);
-    render_pass_mask_color_matrix_program_[i].Cleanup(gl_);
+    for (int j = 0; j < kNumBlendModes; j++) {
+      render_pass_mask_program_[i][j].Cleanup(gl_);
+      render_pass_program_[i][j].Cleanup(gl_);
+      render_pass_mask_program_aa_[i][j].Cleanup(gl_);
+      render_pass_program_aa_[i][j].Cleanup(gl_);
+      render_pass_color_matrix_program_[i][j].Cleanup(gl_);
+      render_pass_mask_color_matrix_program_aa_[i][j].Cleanup(gl_);
+      render_pass_color_matrix_program_aa_[i][j].Cleanup(gl_);
+      render_pass_mask_color_matrix_program_[i][j].Cleanup(gl_);
+    }
 
     texture_program_[i].Cleanup(gl_);
     nonpremultiplied_texture_program_[i].Cleanup(gl_);
     texture_background_program_[i].Cleanup(gl_);
     nonpremultiplied_texture_background_program_[i].Cleanup(gl_);
     texture_io_surface_program_[i].Cleanup(gl_);
 
     video_yuv_program_[i].Cleanup(gl_);
     video_yuva_program_[i].Cleanup(gl_);
     video_stream_texture_program_[i].Cleanup(gl_);
@@ skipping 88 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