Disable DirectComposition underlays and complex transforms by default.

cc/output/dc_layer_overlay.cc

 // Copyright 2017 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/dc_layer_overlay.h"
 
 #include "cc/base/math_util.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"
 #include "cc/resources/resource_provider.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "ui/gfx/geometry/rect_conversions.h"
+#include "ui/gl/gl_switches.h"
 
 namespace cc {
 
 namespace {
 
 DCLayerOverlayProcessor::DCLayerResult FromYUVQuad(
     ResourceProvider* resource_provider,
     const YUVVideoDrawQuad* quad,
     DCLayerOverlay* ca_layer_overlay) {
   unsigned resource_id = quad->y_plane_resource_id();
@@ skipping 90 matching lines @@
                                       gfx::Rect* damage_rect,
                                       DCLayerOverlayList* ca_layer_overlays) {
   gfx::Rect this_frame_underlay_rect;
   bool display_rect_changed = (display_rect != previous_display_rect_);
   for (auto it = quad_list->begin(); it != quad_list->end(); ++it) {
     DCLayerOverlay ca_layer;
     DCLayerResult result = FromDrawQuad(resource_provider, display_rect,
                                         quad_list->begin(), it, &ca_layer);
     if (result != DC_LAYER_SUCCESS)
       continue;
+
+    if (!it->shared_quad_state->quad_to_target_transform
+             .Preserves2dAxisAlignment() &&
+        !base::FeatureList::IsEnabled(
+            features::kDirectCompositionComplexOverlays)) {
+      continue;
+    }
+
     gfx::Rect quad_rectangle = MathUtil::MapEnclosingClippedRect(
         it->shared_quad_state->quad_to_target_transform, it->rect);
     gfx::RectF occlusion_bounding_box =
         GetOcclusionBounds(gfx::RectF(quad_rectangle), quad_list->begin(), it);
-    overlay_damage_rect->Union(quad_rectangle);
-
     if (occlusion_bounding_box.IsEmpty()) {
       // The quad is on top, so promote it to an overlay and remove all damage
       // underneath it.
       if (it->shared_quad_state->quad_to_target_transform
               .Preserves2dAxisAlignment() &&
           !display_rect_changed) {
         damage_rect->Subtract(quad_rectangle);
       }
       quad_list->EraseAndInvalidateAllPointers(it);
+    } else if (!base::FeatureList::IsEnabled(
+                   features::kDirectCompositionUnderlays)) {
+      continue;
     } else {
       // The quad is occluded, so replace it with a black solid color quad and
       // place the overlay itself under the quad.
       if (it->shared_quad_state->quad_to_target_transform
               .IsIdentityOrIntegerTranslation()) {
         this_frame_underlay_rect = quad_rectangle;
       }
       ca_layer.shared_state->z_order = -1;
       const SharedQuadState* shared_quad_state = it->shared_quad_state;
       gfx::Rect rect = it->visible_rect;
@@ skipping 20 matching lines @@
 
           damage_rect->Union(occluding_damage_rect);
         }
       } else {
         // Entire replacement quad must be redrawn.
         damage_rect->Union(quad_rectangle);
       }
       previous_occlusion_bounding_box_ =
           gfx::ToEnclosingRect(occlusion_bounding_box);
     }
+    overlay_damage_rect->Union(quad_rectangle);
 
     ca_layer_overlays->push_back(ca_layer);
     // Only allow one overlay for now.
     break;
   }
   damage_rect->Intersect(gfx::ToEnclosingRect(display_rect));
   previous_frame_underlay_rect_ = this_frame_underlay_rect;
   previous_display_rect_ = display_rect;
 }
 
 }  // namespace cc