Disable CA compositor if there are too many quads.

cc/output/ca_layer_overlay.cc

 // Copyright 2015 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/ca_layer_overlay.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/resources/resource_provider.h"
 #include "gpu/GLES2/gl2extchromium.h"
 
 namespace cc {
 
 namespace {
 
+// If there are too many RenderPassDrawQuads, we shouldn't use Core Animation to
+// present them as individual layers, since that potentially doubles the amount
+// of work needed to present them. cc has to blit them into an IOSurface, and
+// then Core Animation has to blit them to the final surface.
+// https://crbug.com/636884.
+const int kTooManyRenderPassDrawQuads = 30;
+
 // This enum is used for histogram states and should only have new values added
 // to the end before COUNT.
 enum CALayerResult {
   CA_LAYER_SUCCESS = 0,
   CA_LAYER_FAILED_UNKNOWN,
   CA_LAYER_FAILED_IO_SURFACE_NOT_CANDIDATE,
   CA_LAYER_FAILED_STREAM_VIDEO_NOT_CANDIDATE,
   CA_LAYER_FAILED_STREAM_VIDEO_TRANSFORM,
   CA_LAYER_FAILED_TEXTURE_NOT_CANDIDATE,
   CA_LAYER_FAILED_TEXTURE_Y_FLIPPED,
   CA_LAYER_FAILED_TILE_NOT_CANDIDATE,
   CA_LAYER_FAILED_QUAD_BLEND_MODE,
   CA_LAYER_FAILED_QUAD_TRANSFORM,
   CA_LAYER_FAILED_QUAD_CLIPPING,
   CA_LAYER_FAILED_DEBUG_BORDER,
   CA_LAYER_FAILED_PICTURE_CONTENT,
   CA_LAYER_FAILED_RENDER_PASS,
   CA_LAYER_FAILED_SURFACE_CONTENT,
   CA_LAYER_FAILED_YUV_VIDEO_CONTENT,
   CA_LAYER_FAILED_DIFFERENT_CLIP_SETTINGS,
   CA_LAYER_FAILED_DIFFERENT_VERTEX_OPACITIES,
   CA_LAYER_FAILED_RENDER_PASS_FILTER_SCALE,
   CA_LAYER_FAILED_RENDER_PASS_BACKGROUND_FILTERS,
   CA_LAYER_FAILED_RENDER_PASS_MASK,
   CA_LAYER_FAILED_RENDER_PASS_FILTER_OPERATION,
   CA_LAYER_FAILED_RENDER_PASS_SORTING_CONTEXT_ID,
+  CA_LAYER_FAILED_TOO_MANY_RENDER_PASS_DRAW_QUADS,
   CA_LAYER_FAILED_COUNT,
 };
 
 bool FilterOperationSupported(const FilterOperation& operation) {
   switch (operation.type()) {
     case FilterOperation::GRAYSCALE:
     case FilterOperation::SEPIA:
     case FilterOperation::SATURATE:
     case FilterOperation::HUE_ROTATE:
     case FilterOperation::INVERT:
@@ skipping 96 matching lines @@
                                         1.f / quad->texture_size.height());
   return CA_LAYER_SUCCESS;
 }
 
 class CALayerOverlayProcessor {
  public:
   CALayerResult FromDrawQuad(ResourceProvider* resource_provider,
                              const gfx::RectF& display_rect,
                              const DrawQuad* quad,
                              CALayerOverlay* ca_layer_overlay,
-                             bool* skip) {
+                             bool* skip,
+                             bool* render_pass_draw_quad) {
     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;
     }
 
     // Enable edge anti-aliasing only on layer boundaries.
@@ skipping 20 matching lines @@
 
       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);
 
+    *render_pass_draw_quad = quad->material == DrawQuad::RENDER_PASS;
     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),
@@ skipping 34 matching lines @@
 
 CALayerOverlay::~CALayerOverlay() {}
 
 bool ProcessForCALayerOverlays(ResourceProvider* resource_provider,
                                const gfx::RectF& display_rect,
                                const QuadList& quad_list,
                                CALayerOverlayList* ca_layer_overlays) {
   CALayerResult result = CA_LAYER_SUCCESS;
   ca_layer_overlays->reserve(quad_list.size());
 
+  int render_pass_draw_quad_count = 0;
   CALayerOverlayProcessor processor;
   for (auto it = quad_list.BackToFrontBegin(); it != quad_list.BackToFrontEnd();
        ++it) {
     const DrawQuad* quad = *it;
     CALayerOverlay ca_layer;
     bool skip = false;
+    bool render_pass_draw_quad = false;
     result = processor.FromDrawQuad(resource_provider, display_rect, quad,
-                                    &ca_layer, &skip);
+                                    &ca_layer, &skip, &render_pass_draw_quad);
     if (result != CA_LAYER_SUCCESS)
       break;
 
+    if (render_pass_draw_quad) {
+      ++render_pass_draw_quad_count;
+      if (render_pass_draw_quad_count > kTooManyRenderPassDrawQuads) {
+        result = CA_LAYER_FAILED_TOO_MANY_RENDER_PASS_DRAW_QUADS;
+        break;
+      }
+    }
+
     if (skip)
       continue;
 
     // It is not possible to correctly represent two different clipping settings
     // within one sorting context.
     if (!ca_layer_overlays->empty()) {
       const CALayerOverlay& previous_ca_layer = ca_layer_overlays->back();
       if (ca_layer.shared_state->sorting_context_id &&
           previous_ca_layer.shared_state->sorting_context_id ==
               ca_layer.shared_state->sorting_context_id) {
@@ skipping 14 matching lines @@
                             CA_LAYER_FAILED_COUNT);
 
   if (result != CA_LAYER_SUCCESS) {
     ca_layer_overlays->clear();
     return false;
   }
   return true;
 }
 
 }  // namespace cc