cc: Move filters from RenderPassDrawQuad to RenderPass

cc/quads/render_pass.h

 // Copyright 2011 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.
 
 #ifndef CC_QUADS_RENDER_PASS_H_
 #define CC_QUADS_RENDER_PASS_H_
 
 #include <stddef.h>
 
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/hash.h"
 #include "base/macros.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/list_container.h"
+#include "cc/output/filter_operations.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/largest_draw_quad.h"
 #include "cc/quads/render_pass_id.h"
 #include "cc/surfaces/surface_id.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/transform.h"
 
 namespace base {
 namespace trace_event {
@@ skipping 47 matching lines @@
 
   void SetNew(RenderPassId id,
               const gfx::Rect& output_rect,
               const gfx::Rect& damage_rect,
               const gfx::Transform& transform_to_root_target);
 
   void SetAll(RenderPassId id,
               const gfx::Rect& output_rect,
               const gfx::Rect& damage_rect,
               const gfx::Transform& transform_to_root_target,
+              const FilterOperations& filters,
+              const FilterOperations& background_filters,
               bool has_transparent_background);
 
   void AsValueInto(base::trace_event::TracedValue* dict) const;
 
   SharedQuadState* CreateAndAppendSharedQuadState();
 
   template <typename DrawQuadType>
   DrawQuadType* CreateAndAppendDrawQuad() {
     return quad_list.AllocateAndConstruct<DrawQuadType>();
   }
 
   RenderPassDrawQuad* CopyFromAndAppendRenderPassDrawQuad(
       const RenderPassDrawQuad* quad,
       const SharedQuadState* shared_quad_state,
       RenderPassId render_pass_id);
   DrawQuad* CopyFromAndAppendDrawQuad(const DrawQuad* quad,
                                       const SharedQuadState* shared_quad_state);
 
   // Uniquely identifies the render pass in the compositor's current frame.
   RenderPassId id;
 
   // These are in the space of the render pass' physical pixels.
   gfx::Rect output_rect;
   gfx::Rect damage_rect;
 
   // Transforms from the origin of the |output_rect| to the origin of the root
   // render pass' |output_rect|.
   gfx::Transform transform_to_root_target;
 
+  // Post-processing filters, applied to the pixels in the render pass' texture.
+  FilterOperations filters;
+
+  // Post-processing filters, applied to the pixels showing through the
+  // background of the render pass, from behind it.
+  FilterOperations background_filters;
+
   // If false, the pixels in the render pass' texture are all opaque.
   bool has_transparent_background;
 
   // If non-empty, the renderer should produce a copy of the render pass'
   // contents as a bitmap, and give a copy of the bitmap to each callback in
   // this list. This property should not be serialized between compositors, as
   // it only makes sense in the root compositor.
   std::vector<std::unique_ptr<CopyOutputRequest>> copy_requests;
 
   QuadList quad_list;
   SharedQuadStateList shared_quad_state_list;
 
  protected:
   explicit RenderPass(size_t num_layers);
   RenderPass();
   RenderPass(size_t shared_quad_state_list_size, size_t quad_list_size);
 
  private:
   template <typename DrawQuadType>
   DrawQuadType* CopyFromAndAppendTypedDrawQuad(const DrawQuad* quad) {
     return quad_list.AllocateAndCopyFrom(DrawQuadType::MaterialCast(quad));
   }
 
   DISALLOW_COPY_AND_ASSIGN(RenderPass);
 };
 
 using RenderPassList = std::vector<std::unique_ptr<RenderPass>>;
 using RenderPassIdHashMap =
     std::unordered_map<RenderPassId, RenderPass*, RenderPassIdHash>;
+using RenderPassFilterList =

[danakj, 2016/12/14 23:23:57]

I think we need to either mention here that this is sorted so you can find
things with std::lower_bound, and then it should be true for all uses.. or
mention it everywhere that can make sense in DirectRenderer and maybe the
overlay code. Because thats an invisible thing about this vector until we can
use some nicer flat_map type structure that encapsulates it.

[ajuma, 2016/12/15 16:49:20]

Added a comment here.

+    std::vector<std::pair<RenderPassId, FilterOperations*>>;
+class RenderPassFilterListComparator {
+ public:
+  bool operator()(const std::pair<RenderPassId, FilterOperations*>& a,
+                  const std::pair<RenderPassId, FilterOperations*>& b) {
+    return a.first < b.first;
+  }
+};
 
 }  // namespace cc
 
 #endif  // CC_QUADS_RENDER_PASS_H_