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 148 matching lines @@
   DCHECK(initialized_);
   if (visible_ == visible)
     return;
   visible_ = visible;
   DidChangeVisibility();
 }
 
 void DirectRenderer::DecideRenderPassAllocationsForFrame(
     const RenderPassList& render_passes_in_draw_order) {
   render_pass_bypass_quads_.clear();
+  render_pass_filters_.clear();

[danakj, 2016/12/01 01:50:46]

This isn't part of allocating.. while I appreciate sharing the same walk thru
the render pass list, I think it'd be better clarity to do this in DrawFrame
instead since the # of passes is really small.

[ajuma, 2016/12/13 15:08:11]

Done.

+  render_pass_background_filters_.clear();
 
   std::unordered_map<RenderPassId, gfx::Size, RenderPassIdHash>
       render_passes_in_frame;
   RenderPass* root_render_pass = render_passes_in_draw_order.back().get();
   for (size_t i = 0; i < render_passes_in_draw_order.size(); ++i) {
     RenderPass* pass = render_passes_in_draw_order[i].get();
     if (pass != root_render_pass) {
+      if (!pass->filters.IsEmpty())
+        render_pass_filters_.push_back(std::make_pair(pass->id, pass->filters));

[danakj, 2016/12/01 01:50:46]

why copy the filters, you could store a pointer to them instead?

[weiliangc, 2016/12/01 21:20:54]

I mean we store the filters pointers here, and when search RenderPass's filters,
return nullptr?

[danakj, 2016/12/01 21:26:02]

i'm not totally sure what you mean, but what i mean is render_pass_filters_ is a
RenderPassFilterList which is a std::vector<std::pair<RenderPassId,
FilterOperations>>. I'm suggesting  std::vector<std::pair<RenderPassId,
FilterOperations*>> with a pointer to the RenderPass's |filters|.

Alternatively we used to have a map of RenderPassId to RenderPass* for
DrawLayers but it went unused. We could have that and then we only need one
std::vector<std::pair<RenderPassId, RenderPass*>> thing to find both types of
filters.

[ajuma, 2016/12/13 15:08:11]

Changed to storing a pointer to the RenderPass's filters. 

+      if (!pass->background_filters.IsEmpty()) {
+        render_pass_background_filters_.push_back(
+            std::make_pair(pass->id, pass->background_filters));
+      }
       if (const TileDrawQuad* tile_quad = CanPassBeDrawnDirectly(pass)) {
         render_pass_bypass_quads_[pass->id] = *tile_quad;
         continue;
       }
+    } else {
+      DCHECK(pass->filters.IsEmpty());
+      DCHECK(pass->background_filters.IsEmpty());
     }
     render_passes_in_frame.insert(std::pair<RenderPassId, gfx::Size>(
         pass->id, RenderPassTextureSize(pass)));
   }
 
   std::vector<RenderPassId> passes_to_delete;
   for (auto pass_iter = render_pass_textures_.begin();
        pass_iter != render_pass_textures_.end(); ++pass_iter) {
     auto it = render_passes_in_frame.find(pass_iter->first);
     if (it == render_passes_in_frame.end()) {
@@ skipping 80 matching lines @@
     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;
@@ skipping 107 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(RenderPassId id) const {

[danakj, 2016/12/01 01:50:46]

const&?

[weiliangc, 2016/12/01 21:20:54]

like mentioned in line 179, if we store pointers, we should return pointers
here?

[danakj, 2016/12/01 21:26:02]

here I'm talking about the |id|

[ajuma, 2016/12/13 15:08:11]

Changed |id| to const&, but then changed back to pass-by-value when rebasing
since render pass ids are now ints.

+  auto it =
+      std::find_if(render_pass_filters_.begin(), render_pass_filters_.end(),
+                   [id](const std::pair<RenderPassId, FilterOperations>& p) {
+                     return p.first == id;
+                   });
+  return it == render_pass_filters_.end() ? nullptr : &it->second;
+}
+
+const FilterOperations* DirectRenderer::BackgroundFiltersForPass(
+    RenderPassId id) const {

[danakj, 2016/12/01 01:50:46]

const&

[ajuma, 2016/12/13 15:08:11]

Done.

+  auto it =
+      std::find_if(render_pass_background_filters_.begin(),
+                   render_pass_background_filters_.end(),
+                   [id](const std::pair<RenderPassId, FilterOperations>& p) {
+                     return p.first == id;
+                   });
+  return it == render_pass_background_filters_.end() ? nullptr : &it->second;
+}
+
 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