cc: Move filters from RenderPassDrawQuad to RenderPass

cc/output/direct_renderer.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/output/direct_renderer.h"
 
 #include <stddef.h>
 
 #include <unordered_map>
 #include <utility>
@@ skipping 236 matching lines @@
     reshape_device_scale_factor_ = device_scale_factor;
     reshape_device_color_space_ = device_color_space;
     reshape_has_alpha_ = frame.root_render_pass->has_transparent_background;
     output_surface_->Reshape(reshape_surface_size_,
                              reshape_device_scale_factor_,
                              reshape_device_color_space_, reshape_has_alpha_);
   }
 
   BeginDrawingFrame(&frame);
 
+  for (const auto& pass : *render_passes_in_draw_order) {
+    if (!pass->filters.IsEmpty())
+      render_pass_filters_.push_back(std::make_pair(pass->id, &pass->filters));
+    if (!pass->background_filters.IsEmpty()) {
+      render_pass_background_filters_.push_back(
+          std::make_pair(pass->id, &pass->background_filters));
+    }
+    std::sort(render_pass_filters_.begin(), render_pass_filters_.end());
+    std::sort(render_pass_background_filters_.begin(),
+              render_pass_background_filters_.end());
+  }
+
   // Draw all non-root render passes except for the root render pass.
   for (const auto& pass : *render_passes_in_draw_order) {
     if (pass.get() == root_render_pass)
       break;
     DrawRenderPassAndExecuteCopyRequests(&frame, pass.get());
   }
 
   // Create the overlay candidate for the output surface, and mark it as
   // always handled.
   if (output_surface_->IsDisplayedAsOverlayPlane()) {
     OverlayCandidate output_surface_plane;
     output_surface_plane.display_rect =
         gfx::RectF(root_render_pass->output_rect);
     output_surface_plane.quad_rect_in_target_space =
         root_render_pass->output_rect;
     output_surface_plane.use_output_surface_for_resource = true;
     output_surface_plane.overlay_handled = true;
     frame.overlay_list.push_back(output_surface_plane);
   }
 
   // Attempt to replace some or all of the quads of the root render pass with
   // overlays.
   overlay_processor_->ProcessForOverlays(
-      resource_provider_, root_render_pass, &frame.overlay_list,
+      resource_provider_, root_render_pass, render_pass_filters_,
+      render_pass_background_filters_, &frame.overlay_list,
       &frame.ca_layer_overlay_list, &frame.root_damage_rect);
 
   // We can skip all drawing if the damage rect is now empty.
   bool skip_drawing_root_render_pass =
       frame.root_damage_rect.IsEmpty() && allow_empty_swap_;
 
   // If we have to draw but don't support partial swap, the whole output should
   // be considered damaged.
   if (!skip_drawing_root_render_pass && !use_partial_swap_)
     frame.root_damage_rect = root_render_pass->output_rect;
 
   if (skip_drawing_root_render_pass) {
     // If any of the overlays is the output surface, then ensure that the
     // backbuffer be allocated (allocation of the backbuffer is a side-effect
     // of BindFramebufferToOutputSurface).
     for (auto& overlay : frame.overlay_list) {
       if (overlay.use_output_surface_for_resource) {
         BindFramebufferToOutputSurface(&frame);
         break;
       }
     }
   } else {
     DrawRenderPassAndExecuteCopyRequests(&frame, root_render_pass);
   }
 
   FinishDrawingFrame(&frame);
   render_passes_in_draw_order->clear();
+  render_pass_filters_.clear();
+  render_pass_background_filters_.clear();
 }
 
 gfx::Rect DirectRenderer::ComputeScissorRectForRenderPass(
     const DrawingFrame* frame) {
   if (frame->current_render_pass == frame->root_render_pass)
     return frame->root_damage_rect;
 
   // If the root damage rect has been expanded due to overlays, all the other
   // damage rect calculations are incorrect.
   if (!frame->root_render_pass->damage_rect.Contains(frame->root_damage_rect))
@@ skipping 80 matching lines @@
     return;
   }
 
   std::vector<gfx::QuadF> quads;
   poly.ToQuads2D(&quads);
   for (size_t i = 0; i < quads.size(); ++i) {
     DoDrawQuad(frame, poly.original_ref(), &quads[i]);
   }
 }
 
+const FilterOperations* DirectRenderer::FiltersForPass(
+    const RenderPassId& id) const {
+  auto it =
+      std::lower_bound(render_pass_filters_.begin(), render_pass_filters_.end(),
+                       std::pair<RenderPassId, FilterOperations*>(id, nullptr));
+  if (it != render_pass_filters_.end() && it->first == id)
+    return it->second;
+  return nullptr;
+}
+
+const FilterOperations* DirectRenderer::BackgroundFiltersForPass(
+    const RenderPassId& id) const {
+  auto it =
+      std::lower_bound(render_pass_background_filters_.begin(),
+                       render_pass_background_filters_.end(),
+                       std::pair<RenderPassId, FilterOperations*>(id, nullptr));
+  if (it != render_pass_background_filters_.end() && it->first == id)
+    return it->second;
+  return nullptr;
+}
+
 void DirectRenderer::FlushPolygons(
     std::deque<std::unique_ptr<DrawPolygon>>* poly_list,
     DrawingFrame* frame,
     const gfx::Rect& render_pass_scissor,
     bool use_render_pass_scissor) {
   if (poly_list->empty()) {
     return;
   }
 
   BspTree bsp_tree(poly_list);
@@ skipping 154 matching lines @@
   auto iter = render_pass_textures_.find(id);
   return iter != render_pass_textures_.end() && iter->second->id();
 }
 
 // static
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 }  // namespace cc