Refactor CALayerOverlay to pull out CALayerOverlaySharedState.

cc/output/ca_layer_overlay.cc

Index: cc/output/ca_layer_overlay.cc
diff --git a/cc/output/ca_layer_overlay.cc b/cc/output/ca_layer_overlay.cc
index 998cf882d158b35a2d2a108910827dccb83eadb1..ac61db0ac9dbaf9f216124193ab6c703767c6aef 100644
--- a/cc/output/ca_layer_overlay.cc
+++ b/cc/output/ca_layer_overlay.cc
@@ -78,9 +78,9 @@ CALayerResult FromTextureQuad(ResourceProvider* resource_provider,
     // transformation that flips the contents of the layer without changing its
     // frame is the composition of a vertical flip about the anchor point, and a
     // translation by the height of the layer.
-    ca_layer_overlay->transform.preTranslate(
+    ca_layer_overlay->shared_state->transform.preTranslate(
         0, ca_layer_overlay->bounds_rect.height(), 0);
-    ca_layer_overlay->transform.preScale(1, -1, 1);
+    ca_layer_overlay->shared_state->transform.preScale(1, -1, 1);
   }
   ca_layer_overlay->contents_resource_id = resource_id;
   ca_layer_overlay->contents_rect =
@@ -90,7 +90,7 @@ CALayerResult FromTextureQuad(ResourceProvider* resource_provider,
     if (quad->vertex_opacity[i] != quad->vertex_opacity[0])
       return CA_LAYER_FAILED_DIFFERENT_VERTEX_OPACITIES;
   }
-  ca_layer_overlay->opacity *= quad->vertex_opacity[0];
+  ca_layer_overlay->shared_state->opacity *= quad->vertex_opacity[0];
   ca_layer_overlay->filter = quad->nearest_neighbor ? GL_NEAREST : GL_LINEAR;
   return CA_LAYER_SUCCESS;
 }
@@ -108,73 +108,89 @@ CALayerResult FromTileQuad(ResourceProvider* resource_provider,
   return CA_LAYER_SUCCESS;
 }
 
-CALayerResult FromDrawQuad(ResourceProvider* resource_provider,
-                           const gfx::RectF& display_rect,
-                           const DrawQuad* quad,
-                           CALayerOverlay* ca_layer_overlay,
-                           bool* skip) {
-  if (quad->shared_quad_state->blend_mode != SkXfermode::kSrcOver_Mode)
-    return CA_LAYER_FAILED_QUAD_BLEND_MODE;
+class CALayerOverlayProcessor {
+ public:
+  CALayerResult FromDrawQuad(ResourceProvider* resource_provider,
+                             const gfx::RectF& display_rect,
+                             const DrawQuad* quad,
+                             CALayerOverlay* ca_layer_overlay,
+                             bool* skip) {
+    if (quad->shared_quad_state->blend_mode != SkXfermode::kSrcOver_Mode)
+      return CA_LAYER_FAILED_QUAD_BLEND_MODE;
+
+    // Early-out for invisible quads.
+    if (quad->shared_quad_state->opacity == 0.f) {
+      *skip = true;
+      return CA_LAYER_SUCCESS;
+    }
 
-  // Early-out for invisible quads.
-  if (quad->shared_quad_state->opacity == 0.f) {
-    *skip = true;
-    return CA_LAYER_SUCCESS;
-  }
+    // Enable edge anti-aliasing only on layer boundaries.
+    ca_layer_overlay->edge_aa_mask = 0;
+    if (quad->IsLeftEdge())
+      ca_layer_overlay->edge_aa_mask |= GL_CA_LAYER_EDGE_LEFT_CHROMIUM;
+    if (quad->IsRightEdge())
+      ca_layer_overlay->edge_aa_mask |= GL_CA_LAYER_EDGE_RIGHT_CHROMIUM;
+    if (quad->IsBottomEdge())
+      ca_layer_overlay->edge_aa_mask |= GL_CA_LAYER_EDGE_BOTTOM_CHROMIUM;
+    if (quad->IsTopEdge())
+      ca_layer_overlay->edge_aa_mask |= GL_CA_LAYER_EDGE_TOP_CHROMIUM;
+
+    if (most_recent_shared_quad_state_ != quad->shared_quad_state) {
+      most_recent_shared_quad_state_ = quad->shared_quad_state;
+      most_recent_overlay_shared_state_ = new CALayerOverlaySharedState;
+      // Set rect clipping and sorting context ID.
+      most_recent_overlay_shared_state_->sorting_context_id =
+          quad->shared_quad_state->sorting_context_id;
+      most_recent_overlay_shared_state_->is_clipped =
+          quad->shared_quad_state->is_clipped;
+      most_recent_overlay_shared_state_->clip_rect =
+          gfx::RectF(quad->shared_quad_state->clip_rect);
+
+      most_recent_overlay_shared_state_->opacity =
+          quad->shared_quad_state->opacity;
+      most_recent_overlay_shared_state_->transform =
+          quad->shared_quad_state->quad_to_target_transform.matrix();
+    }
+    ca_layer_overlay->shared_state = most_recent_overlay_shared_state_;
+
+    ca_layer_overlay->bounds_rect = gfx::RectF(quad->rect);
+
+    switch (quad->material) {
+      case DrawQuad::TEXTURE_CONTENT:
+        return FromTextureQuad(resource_provider,
+                               TextureDrawQuad::MaterialCast(quad),
+                               ca_layer_overlay);
+      case DrawQuad::TILED_CONTENT:
+        return FromTileQuad(resource_provider, TileDrawQuad::MaterialCast(quad),
+                            ca_layer_overlay);
+      case DrawQuad::SOLID_COLOR:
+        return FromSolidColorDrawQuad(SolidColorDrawQuad::MaterialCast(quad),
+                                      ca_layer_overlay, skip);
+      case DrawQuad::STREAM_VIDEO_CONTENT:
+        return FromStreamVideoQuad(resource_provider,
+                                   StreamVideoDrawQuad::MaterialCast(quad),
+                                   ca_layer_overlay);
+      case DrawQuad::DEBUG_BORDER:
+        return CA_LAYER_FAILED_DEBUG_BORDER;
+      case DrawQuad::PICTURE_CONTENT:
+        return CA_LAYER_FAILED_PICTURE_CONTENT;
+      case DrawQuad::RENDER_PASS:
+        return CA_LAYER_FAILED_RENDER_PASS;
+      case DrawQuad::SURFACE_CONTENT:
+        return CA_LAYER_FAILED_SURFACE_CONTENT;
+      case DrawQuad::YUV_VIDEO_CONTENT:
+        return CA_LAYER_FAILED_YUV_VIDEO_CONTENT;
+      default:
+        break;
+    }
 
-  // Enable edge anti-aliasing only on layer boundaries.
-  ca_layer_overlay->edge_aa_mask = 0;
-  if (quad->IsLeftEdge())
-    ca_layer_overlay->edge_aa_mask |= GL_CA_LAYER_EDGE_LEFT_CHROMIUM;
-  if (quad->IsRightEdge())
-    ca_layer_overlay->edge_aa_mask |= GL_CA_LAYER_EDGE_RIGHT_CHROMIUM;
-  if (quad->IsBottomEdge())
-    ca_layer_overlay->edge_aa_mask |= GL_CA_LAYER_EDGE_BOTTOM_CHROMIUM;
-  if (quad->IsTopEdge())
-    ca_layer_overlay->edge_aa_mask |= GL_CA_LAYER_EDGE_TOP_CHROMIUM;
-
-  // Set rect clipping and sorting context ID.
-  ca_layer_overlay->sorting_context_id =
-      quad->shared_quad_state->sorting_context_id;
-  ca_layer_overlay->is_clipped = quad->shared_quad_state->is_clipped;
-  ca_layer_overlay->clip_rect = gfx::RectF(quad->shared_quad_state->clip_rect);
-
-  ca_layer_overlay->opacity = quad->shared_quad_state->opacity;
-  ca_layer_overlay->bounds_rect = gfx::RectF(quad->rect);
-  ca_layer_overlay->transform =
-      quad->shared_quad_state->quad_to_target_transform.matrix();
-
-  switch (quad->material) {
-    case DrawQuad::TEXTURE_CONTENT:
-      return FromTextureQuad(resource_provider,
-                             TextureDrawQuad::MaterialCast(quad),
-                             ca_layer_overlay);
-    case DrawQuad::TILED_CONTENT:
-      return FromTileQuad(resource_provider, TileDrawQuad::MaterialCast(quad),
-                          ca_layer_overlay);
-    case DrawQuad::SOLID_COLOR:
-      return FromSolidColorDrawQuad(SolidColorDrawQuad::MaterialCast(quad),
-                                    ca_layer_overlay, skip);
-    case DrawQuad::STREAM_VIDEO_CONTENT:
-      return FromStreamVideoQuad(resource_provider,
-                                 StreamVideoDrawQuad::MaterialCast(quad),
-                                 ca_layer_overlay);
-    case DrawQuad::DEBUG_BORDER:
-      return CA_LAYER_FAILED_DEBUG_BORDER;
-    case DrawQuad::PICTURE_CONTENT:
-      return CA_LAYER_FAILED_PICTURE_CONTENT;
-    case DrawQuad::RENDER_PASS:
-      return CA_LAYER_FAILED_RENDER_PASS;
-    case DrawQuad::SURFACE_CONTENT:
-      return CA_LAYER_FAILED_SURFACE_CONTENT;
-    case DrawQuad::YUV_VIDEO_CONTENT:
-      return CA_LAYER_FAILED_YUV_VIDEO_CONTENT;
-    default:
-      break;
+    return CA_LAYER_FAILED_UNKNOWN;
   }
 
-  return CA_LAYER_FAILED_UNKNOWN;
-}
+ private:
+  const SharedQuadState* most_recent_shared_quad_state_ = nullptr;
+  scoped_refptr<CALayerOverlaySharedState> most_recent_overlay_shared_state_;
+};
 
 }  // namespace
 
@@ -191,13 +207,14 @@ bool ProcessForCALayerOverlays(ResourceProvider* resource_provider,
   CALayerResult result = CA_LAYER_SUCCESS;
   ca_layer_overlays->reserve(quad_list.size());
 
+  CALayerOverlayProcessor processor;

[ccameron, 2016/07/18 22:56:57]

Maybe roll resource provider and display rect into CALayerOverlayProcessor, too?
And have the handful of functions that take the resource_provider be members,
instead of passing the same arguments around.

Maybe for later, if you'd prefer the smaller patch.

[erikchen, 2016/07/19 00:15:27]

Good suggestion, maybe in a future CL? 

   for (auto it = quad_list.BackToFrontBegin(); it != quad_list.BackToFrontEnd();
        ++it) {
     const DrawQuad* quad = *it;
     CALayerOverlay ca_layer;
     bool skip = false;
-    result =
-        FromDrawQuad(resource_provider, display_rect, quad, &ca_layer, &skip);
+    result = processor.FromDrawQuad(resource_provider, display_rect, quad,
+                                    &ca_layer, &skip);
     if (result != CA_LAYER_SUCCESS)
       break;
 
@@ -208,10 +225,13 @@ bool ProcessForCALayerOverlays(ResourceProvider* resource_provider,
     // within one sorting context.
     if (!ca_layer_overlays->empty()) {
       const CALayerOverlay& previous_ca_layer = ca_layer_overlays->back();
-      if (ca_layer.sorting_context_id &&
-          previous_ca_layer.sorting_context_id == ca_layer.sorting_context_id) {
-        if (previous_ca_layer.is_clipped != ca_layer.is_clipped ||
-            previous_ca_layer.clip_rect != ca_layer.clip_rect) {
+      if (ca_layer.shared_state->sorting_context_id &&
+          previous_ca_layer.shared_state->sorting_context_id ==
+              ca_layer.shared_state->sorting_context_id) {
+        if (previous_ca_layer.shared_state->is_clipped !=
+                ca_layer.shared_state->is_clipped ||
+            previous_ca_layer.shared_state->clip_rect !=
+                ca_layer.shared_state->clip_rect) {
           result = CA_LAYER_FAILED_DIFFERENT_CLIP_SETTINGS;
           break;
         }