cc: Make visible rect computation aware of pixel-moving filters

cc/trees/clip_node.h

 // Copyright 2016 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_TREES_CLIP_NODE_H_
 #define CC_TREES_CLIP_NODE_H_
 
 #include "cc/base/cc_export.h"
+#include "cc/trees/clip_expander.h"
 #include "ui/gfx/geometry/rect_f.h"
 
 namespace base {
 namespace trace_event {
 class TracedValue;
 }  // namespace trace_event
 }  // namespace base
 
 namespace cc {
 
 namespace proto {
 class TreeNode;
 }  // namespace proto
 
 struct CC_EXPORT ClipNode {
   ClipNode();
   ClipNode(const ClipNode& other);
 
   int id;
   int parent_id;
   int owner_id;
 
   enum class ClipType {
     // The node doesn't contribute a new clip. It exists only for caching clips
     // or for resetting clipping state.
     NONE,
 
     // The node contributes a new clip (that is, |clip| needs to be applied).
-    APPLIES_LOCAL_CLIP
+    APPLIES_LOCAL_CLIP,
+
+    // This node represents a space expansion. When computing visible rects,
+    // the accumulated clip inherited by this node gets expanded. Similarly,
+    // when mapping a rect in descendant space to the rect in ancestor space
+    // that depends on the descendant rect's contents, this node expands the
+    // descendant rect. This is used for effects like pixel-moving filters,
+    // where clipped-out content can affect visible output.
+    EXPANDS_CLIP
   };
 
   ClipType clip_type;
 
   // The clip rect that this node contributes, expressed in the space of its
   // transform node.
   gfx::RectF clip;
 
+  // For nodes that expand, this represents the amount of expansion.
+  ClipExpander clip_expander;

[weiliangc, 2016/10/26 16:57:03]

Why not a nullable unique_ptr? We could avoid default constructor and NONE type
for the clip expander. And to transfer through protobuf we could only transfer
the effect tree id and create it on the other side?

[ajuma, 2016/10/31 17:43:07]

Done. Also added the protobuf transfer logic and a test.

+
   // Clip nodes are used for two reasons. First, they are used for determining
   // which parts of each layer are visible. Second, they are used for
   // determining whether a clip needs to be applied when drawing a layer, and if
   // so, the rect that needs to be used. These can be different since not all
   // clips need to be applied directly to each layer. For example, a layer is
   // implicitly clipped by the bounds of its target render surface and by clips
   // applied to this surface. |combined_clip_in_target_space| is used for
   // computing visible rects, and |clip_in_target_space| is used for computing
   // clips applied at draw time. Both rects are expressed in the space of the
   // target transform node, and may include clips contributed by ancestors.
@@ skipping 27 matching lines @@
   bool operator==(const ClipNode& other) const;
 
   void ToProtobuf(proto::TreeNode* proto) const;
   void FromProtobuf(const proto::TreeNode& proto);
   void AsValueInto(base::trace_event::TracedValue* value) const;
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_CLIP_NODE_H_