cc: Support anti-aliasing for solid color layers.

cc/draw_quad.h

 // 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.
 
 #ifndef CC_DRAW_QUAD_H_
 #define CC_DRAW_QUAD_H_
 
 #include "cc/cc_export.h"
 #include "cc/shared_quad_state.h"
 
@@ skipping 10 matching lines @@
     CHECKERBOARD,
     DEBUG_BORDER,
     IO_SURFACE_CONTENT,
     RENDER_PASS,
     TEXTURE_CONTENT,
     SOLID_COLOR,
     TILED_CONTENT,
     YUV_VIDEO_CONTENT,
     STREAM_VIDEO_CONTENT,
   };
+  struct AntiAliasing {

[danakj, 2013/01/08 22:30:46]

Should this instead be "Layer Edgeness" or something? And when it's true and the
transform is does not preserve axis-alignment, then you'd end up with
antialiasing?

Hardcoding the full "is antialiased" decision in the quad conflicts with the
browser process modifying the transforms used to draw the quad.

[reveman, 2013/01/09 14:20:05]

Yea, this is not the full anti-aliasing decision. This is "what edges are
allowed to be anti-aliased". The real decision about aa is done by the parent
compositor based on these properties and the transform.

We could rename this to LayerEdges or in that case I prefer to just store the
layer content bounds in the shared quad state and the parent compositor can
determine if it's an edge by comparing the quad rect to the layer content rect.

Separate aa properties makes sense if we want to be able to tell the parent
compositor that some edge should never be anti-aliased. Our current code
(PictureLayerImpl, TiledLayerImpl) does that but I think that's incorrect. Maybe
I should start by fixing that?

+    AntiAliasing() :
+        left_edge(false),
+        top_edge(false),
+        right_edge(false),
+        bottom_edge(false) {}
+    AntiAliasing(bool left_edge,

[danakj, 2013/01/08 22:34:16]

I'm also wondering what is the benefit of this struct instead of 4 bools on the
DrawQuad? It will appear in only one place, and forces subclasses to construct
an additional thing and pass it in, instead of passing in the bools directly.

[reveman, 2013/01/09 14:20:05]

Maybe. The default constructor is somewhat useful but if we use the layer
content bounds none of this is of course needed.

+                 bool top_edge,
+                 bool right_edge,
+                 bool bottom_edge) :
+        left_edge(left_edge),
+        top_edge(top_edge),
+        right_edge(right_edge),
+        bottom_edge(bottom_edge) {}
+
+    bool left_edge;
+    bool top_edge;
+    bool right_edge;
+    bool bottom_edge;
+  };
 
   virtual ~DrawQuad();
 
   scoped_ptr<DrawQuad> Copy(
       const SharedQuadState* copied_shared_quad_state) const;
 
   // TODO(danakj): Chromify or remove these SharedQuadState helpers.
   const gfx::Transform& quadTransform() const { return shared_quad_state->content_to_target_transform; }
   gfx::Rect visibleContentRect() const { return shared_quad_state->visible_content_rect; }
   gfx::Rect clippedRectInTarget() const { return shared_quad_state->clipped_rect_in_target; }
@@ skipping 12 matching lines @@
 
   // Allows changing the rect that gets drawn to make it smaller. This value
   // should be clipped to quadRect.
   gfx::Rect visible_rect;
 
   // By default blending is used when some part of the quad is not opaque.
   // With this setting, it is possible to force blending on regardless of the
   // opaque area.
   bool needs_blending;
 
+  // By default anti-aliasing is not used. With this setting, it is possible
+  // to enable anti-aliasing for specific edges.
+  AntiAliasing anti_aliasing;
+
   // Stores state common to a large bundle of quads; kept separate for memory
   // efficiency. There is special treatment to reconstruct these pointers
   // during serialization.
   const SharedQuadState* shared_quad_state;
 
   bool IsDebugQuad() const { return material == DEBUG_BORDER; }
   bool ShouldDrawWithBlending() const {
     return needs_blending || shared_quad_state->opacity < 1.0f ||
         !opaque_rect.Contains(visible_rect);
   }
+  bool IsAntialiased() const {
+    return
+        anti_aliasing.left_edge ||
+        anti_aliasing.top_edge ||
+        anti_aliasing.right_edge ||
+        anti_aliasing.bottom_edge;
+  }
 
  protected:
   DrawQuad();
 
   void SetAll(const SharedQuadState* shared_quad_state,
               Material material,
               gfx::Rect rect,
               gfx::Rect opaque_rect,
               gfx::Rect visible_rect,
-              bool needs_blending);
+              bool needs_blending,
+              AntiAliasing anti_aliasing);
 };
 
 }
 
 #endif  // CC_DRAW_QUAD_H_