mix-blend-mode implementation for accelerated layers

cc/layers/delegated_renderer_layer.cc

 // Copyright 2012 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/layers/delegated_renderer_layer.h"
 
 #include "cc/layers/delegated_renderer_layer_client.h"
 #include "cc/layers/delegated_renderer_layer_impl.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/render_pass_draw_quad.h"
@@ skipping 89 matching lines @@
   SetNextCommitWaitsForActivation();
 }
 
 void DelegatedRendererLayer::SetDisplaySize(gfx::Size size) {
   if (display_size_ == size)
     return;
   display_size_ = size;
   SetNeedsCommit();
 }
 
-static bool FrameDataHasFilter(DelegatedFrameData* frame) {
+static bool FrameDataRequiresOffscreenContext(const DelegatedFrameData* frame) {

[danakj, 2013/11/13 21:02:03]

bikeshed: RequiresFilterContext()? this would match the function name on
LayerTreeHost.

[rosca, 2013/11/14 21:56:34]

It matches with the getter's name "needs_offscreen_context" in LayerTreeHost.
Setter uses "filter_context" and I'm not sure they were intended to be
different, it's probably called so because the first time it's been used for
filters only. The context provider is called "offscreen context provider" as
well.

[danakj, 2013/11/20 03:32:50]

The idea was the setter has some more context about "what you're tying to do" ie
I want to use filters. Whereas the getter is disconnected from use cases, and
just says that we need to make an offscreen context.

If there were other ways to do filters, then maybe a different getter would
return true and the needs_offscreen_context would not. That's the idea here. So
where we are dealing with filters (ie outside of the code that actually is
worrying about how we implement the filters) i would prefer that we don't tie
ourselves to "OffscreenContext".

[rosca, 2013/11/20 21:52:04]

It makes sense now, thanks! Done.

   for (size_t i = 0; i < frame->render_pass_list.size(); ++i) {
     const QuadList& quad_list = frame->render_pass_list[i]->quad_list;
     for (size_t j = 0; j < quad_list.size(); ++j) {
       if (quad_list[j]->material != DrawQuad::RENDER_PASS)
         continue;
       const RenderPassDrawQuad* render_pass_quad =
           RenderPassDrawQuad::MaterialCast(quad_list[j]);
       if (!render_pass_quad->filters.IsEmpty() ||
-          !render_pass_quad->background_filters.IsEmpty())
+          !render_pass_quad->background_filters.IsEmpty() ||
+          render_pass_quad->shared_quad_state->blend_mode !=

[danakj, 2013/11/13 21:02:03]

IIUC there is a plan to support blend mode for any quad, not just RPDQ? Is there
a reason to limit the checks here to RPDQ? Can we look at all the shared quad
states for this blend mode?

(It'd be faster to iterate the shared_quad_state_list than the quad_list, since
multiple quads can point to the same SQS.)

[rosca, 2013/11/14 21:56:34]

Yes, I should have checked blend mode for all types of draw quads. Done.
You're right, but  it will iterate through all the quads anyway to check for
filters. If we iterate SQSs separately it will bring better readability, but
more steps to iterate.

+              SkXfermode::kSrcOver_Mode)
         return true;
     }
   }
   return false;
 }
 
 bool DelegatedRendererLayer::Update(ResourceUpdateQueue* queue,
                                     const OcclusionTracker* occlusion) {
   bool updated = Layer::Update(queue, occlusion);
   if (!should_collect_new_frame_)
     return updated;
 
   frame_data_ =
       frame_provider_->GetFrameDataAndRefResources(this, &frame_damage_);
   should_collect_new_frame_ = false;
 
   // If any quad has a filter operation, then we need a filter context to draw
   // this layer's content.
-  if (FrameDataHasFilter(frame_data_) && layer_tree_host())
+  if (layer_tree_host() && !layer_tree_host()->needs_offscreen_context() &&

[danakj, 2013/11/13 21:02:03]

nit: no real need to check needs_offscreen_context() here, it's just calling a
setter.

[rosca, 2013/11/14 21:56:34]

I checked this to limit the number of FrameDataRequiresOffscreenContext calls,
which seems to be expensive enough to be called so often.

[danakj, 2013/11/20 03:32:50]

This will only avoid the call when we've already seen a filter, which is by far
the minority of cases, so generally we'll be doing this call every time we get a
new frame anyways. If the check is a bottleneck we should make it faster. I'd
prefer to avoid the if(needs_offscreen_context) here for that reason.

By the way, this code moved to Update() and I should have removed the
layer_tree_host() null check. There's no way LTH can be null inside Update(), we
shouldn't be checking for it here.

[rosca, 2013/11/20 21:52:04]

Done.

+      FrameDataRequiresOffscreenContext(frame_data_))
     layer_tree_host()->set_needs_filter_context();
 
   return true;
 }
 
 }  // namespace cc