Add CompositingReasons to compositor layers.

This is a re-land after first version (r202580) was reverted. The problem was
that extra invalidations occurred due to a call to SetNeedsCommit(). The
solution is to avoid calling SetNeedsCommit(), and accept that this debug info
will be stale on the impl-thread until something else commits.

BUG=240946

Review URL: https://chromiumcodereview.appspot.com/16023024

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@202848 0039d316-1c4b-4281-b951-d872f2087c98

cc/cc.gyp

@@ -82,6 +82,7 @@
       'input/top_controls_manager.h',
       'input/top_controls_manager_client.h',
       'layers/append_quads_data.h',
+      'layers/compositing_reasons.h',
       'layers/content_layer.cc',
       'layers/content_layer.h',
       'layers/content_layer_client.h',

cc/layers/compositing_reasons.h

+// Copyright 2013 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_LAYERS_COMPOSITING_REASONS_H_
+#define CC_LAYERS_COMPOSITING_REASONS_H_
+
+namespace cc {
+
+// This is a clone of CompositingReasons and WebCompositingReasons from Blink.
+enum {
+  kCompositingReasonUnknown                                = 0,
+  kCompositingReason3DTransform                            = 1 << 0,
+  kCompositingReasonVideo                                  = 1 << 1,
+  kCompositingReasonCanvas                                 = 1 << 2,
+  kCompositingReasonPlugin                                 = 1 << 3,
+  kCompositingReasonIFrame                                 = 1 << 4,
+  kCompositingReasonBackfaceVisibilityHidden               = 1 << 5,
+  kCompositingReasonAnimation                              = 1 << 6,
+  kCompositingReasonFilters                                = 1 << 7,
+  kCompositingReasonPositionFixed                          = 1 << 8,
+  kCompositingReasonPositionSticky                         = 1 << 9,
+  kCompositingReasonOverflowScrollingTouch                 = 1 << 10,
+  kCompositingReasonBlending                               = 1 << 11,
+  kCompositingReasonAssumedOverlap                         = 1 << 12,
+  kCompositingReasonOverlap                                = 1 << 13,
+  kCompositingReasonNegativeZIndexChildren                 = 1 << 14,
+  kCompositingReasonTransformWithCompositedDescendants     = 1 << 15,
+  kCompositingReasonOpacityWithCompositedDescendants       = 1 << 16,
+  kCompositingReasonMaskWithCompositedDescendants          = 1 << 17,
+  kCompositingReasonReflectionWithCompositedDescendants    = 1 << 18,
+  kCompositingReasonFilterWithCompositedDescendants        = 1 << 19,
+  kCompositingReasonBlendingWithCompositedDescendants      = 1 << 20,
+  kCompositingReasonClipsCompositingDescendants            = 1 << 21,
+  kCompositingReasonPerspective                            = 1 << 22,
+  kCompositingReasonPreserve3D                             = 1 << 23,
+  kCompositingReasonReflectionOfCompositedParent           = 1 << 24,
+  kCompositingReasonRoot                                   = 1 << 25,
+  kCompositingReasonLayerForClip                           = 1 << 26,
+  kCompositingReasonLayerForScrollbar                      = 1 << 27,
+  kCompositingReasonLayerForScrollingContainer             = 1 << 28,
+  kCompositingReasonLayerForForeground                     = 1 << 29,
+  kCompositingReasonLayerForBackground                     = 1 << 30,
+  kCompositingReasonLayerForMask                           = 1 << 31,
+};
+
+typedef uint32 CompositingReasons;
+
+}  // namespace cc
+
+#endif  // CC_LAYERS_COMPOSITING_REASONS_H_

cc/layers/layer.cc

@@ -40,6 +40,7 @@ Layer::Layer()
       have_wheel_event_handlers_(false),
       anchor_point_(0.5f, 0.5f),
       background_color_(0),
+      compositing_reasons_(kCompositingReasonUnknown),
       opacity_(1.f),
       anchor_point_z_(0.f),
       is_container_for_fixed_position_layers_(false),
@@ -643,6 +644,7 @@ void Layer::PushPropertiesTo(LayerImpl* layer) {
   layer->SetContentBounds(content_bounds());
   layer->SetContentsScale(contents_scale_x(), contents_scale_y());
   layer->SetDebugName(debug_name_);
+  layer->SetCompositingReasons(compositing_reasons_);
   layer->SetDoubleSided(double_sided_);
   layer->SetDrawCheckerboardForMissingTiles(
       draw_checkerboard_for_missing_tiles_);
@@ -749,6 +751,10 @@ void Layer::SetDebugName(const std::string& debug_name) {
   SetNeedsCommit();
 }
 
+void Layer::SetCompositingReasons(CompositingReasons reasons) {
+  compositing_reasons_ = reasons;
+}
+
 void Layer::CreateRenderSurface() {
   DCHECK(!draw_properties_.render_surface);
   draw_properties_.render_surface = make_scoped_ptr(new RenderSurface(this));

cc/layers/layer.h

@@ -15,6 +15,7 @@
 #include "cc/base/cc_export.h"
 #include "cc/base/region.h"
 #include "cc/base/scoped_ptr_vector.h"
+#include "cc/layers/compositing_reasons.h"
 #include "cc/layers/draw_properties.h"
 #include "cc/layers/layer_lists.h"
 #include "cc/layers/layer_position_constraint.h"
@@ -284,6 +285,7 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>,
   virtual void ReduceMemoryUsage() {}
 
   void SetDebugName(const std::string& debug_name);
+  void SetCompositingReasons(CompositingReasons reasons);
 
   virtual void PushPropertiesTo(LayerImpl* layer);
 
@@ -451,6 +453,7 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>,
   gfx::PointF anchor_point_;
   SkColor background_color_;
   std::string debug_name_;
+  CompositingReasons compositing_reasons_;
   float opacity_;
   skia::RefPtr<SkImageFilter> filter_;
   WebKit::WebFilterOperations filters_;

cc/layers/layer_impl.cc

@@ -54,6 +54,7 @@ LayerImpl::LayerImpl(LayerTreeImpl* tree_impl, int id)
       force_render_surface_(false),
       is_container_for_fixed_position_layers_(false),
       draw_depth_(0.f),
+      compositing_reasons_(kCompositingReasonUnknown),
 #ifndef NDEBUG
       between_will_draw_and_did_draw_(false),
 #endif
@@ -352,6 +353,7 @@ void LayerImpl::PushPropertiesTo(LayerImpl* layer) {
   layer->SetContentBounds(content_bounds());
   layer->SetContentsScale(contents_scale_x(), contents_scale_y());
   layer->SetDebugName(debug_name_);
+  layer->SetCompositingReasons(compositing_reasons_);
   layer->SetDoubleSided(double_sided_);
   layer->SetDrawCheckerboardForMissingTiles(
       draw_checkerboard_for_missing_tiles_);
@@ -1001,12 +1003,134 @@ void LayerImpl::SetVerticalScrollbarLayer(ScrollbarLayerImpl* scrollbar_layer) {
     vertical_scrollbar_layer_->set_scroll_layer_id(id());
 }
 
+static scoped_ptr<base::Value>
+CompositingReasonsAsValue(CompositingReasons reasons) {
+  scoped_ptr<base::ListValue> reason_list(new base::ListValue());
+
+  if (reasons == kCompositingReasonUnknown) {
+    reason_list->AppendString("No reasons given");
+    return reason_list.PassAs<base::Value>();
+  }
+
+  if (reasons & kCompositingReason3DTransform)
+    reason_list->AppendString("Has a 3d Transform");
+
+  if (reasons & kCompositingReasonVideo)
+    reason_list->AppendString("Is accelerated video");
+
+  if (reasons & kCompositingReasonCanvas)
+    reason_list->AppendString("Is accelerated canvas");
+
+  if (reasons & kCompositingReasonPlugin)
+    reason_list->AppendString("Is accelerated plugin");
+
+  if (reasons & kCompositingReasonIFrame)
+    reason_list->AppendString("Is accelerated iframe");
+
+  if (reasons & kCompositingReasonBackfaceVisibilityHidden)
+    reason_list->AppendString("Has backface-visibility: hidden");
+
+  if (reasons & kCompositingReasonAnimation)
+    reason_list->AppendString("Has accelerated animation or transition");
+
+  if (reasons & kCompositingReasonFilters)
+    reason_list->AppendString("Has accelerated filters");
+
+  if (reasons & kCompositingReasonPositionFixed)
+    reason_list->AppendString("Is fixed position");
+
+  if (reasons & kCompositingReasonPositionSticky)
+    reason_list->AppendString("Is sticky position");
+
+  if (reasons & kCompositingReasonOverflowScrollingTouch)
+    reason_list->AppendString("Is a scrollable overflow element");
+
+  if (reasons & kCompositingReasonBlending)
+    reason_list->AppendString("Has a blend mode");
+
+  if (reasons & kCompositingReasonAssumedOverlap)
+    reason_list->AppendString("Might overlap a composited animation");
+
+  if (reasons & kCompositingReasonOverlap)
+    reason_list->AppendString("Overlaps other composited content");
+
+  if (reasons & kCompositingReasonNegativeZIndexChildren) {
+    reason_list->AppendString("Might overlap negative z-index "
+                              "composited content");
+  }
+
+  if (reasons & kCompositingReasonTransformWithCompositedDescendants) {
+    reason_list->AppendString("Has transform needed by a "
+                              "composited descendant");
+  }
+
+  if (reasons & kCompositingReasonOpacityWithCompositedDescendants)
+    reason_list->AppendString("Has opacity needed by a composited descendant");
+
+  if (reasons & kCompositingReasonMaskWithCompositedDescendants)
+    reason_list->AppendString("Has a mask needed by a composited descendant");
+
+  if (reasons & kCompositingReasonReflectionWithCompositedDescendants)
+    reason_list->AppendString("Has a reflection with a composited descendant");
+
+  if (reasons & kCompositingReasonFilterWithCompositedDescendants)
+    reason_list->AppendString("Has filter effect with a composited descendant");
+
+  if (reasons & kCompositingReasonBlendingWithCompositedDescendants)
+    reason_list->AppendString("Has a blend mode with a composited descendant");
+
+  if (reasons & kCompositingReasonClipsCompositingDescendants)
+    reason_list->AppendString("Clips a composited descendant");
+
+  if (reasons & kCompositingReasonPerspective) {
+    reason_list->AppendString("Has a perspective transform needed by a "
+                              "composited 3d descendant");
+  }
+
+  if (reasons & kCompositingReasonPreserve3D) {
+    reason_list->AppendString("Has preserves-3d style with composited "
+                              "3d descendant");
+  }
+
+  if (reasons & kCompositingReasonReflectionOfCompositedParent)
+    reason_list->AppendString("Is the reflection of a composited layer");
+
+  if (reasons & kCompositingReasonRoot)
+    reason_list->AppendString("Is the root");
+
+  if (reasons & kCompositingReasonLayerForClip)
+    reason_list->AppendString("Convenience layer, to clip subtree");
+
+  if (reasons & kCompositingReasonLayerForScrollbar)
+    reason_list->AppendString("Convenience layer for rendering scrollbar");
+
+  if (reasons & kCompositingReasonLayerForScrollingContainer)
+    reason_list->AppendString("Convenience layer, the scrolling container");
+
+  if (reasons & kCompositingReasonLayerForForeground) {
+    reason_list->AppendString("Convenience layer, foreground when main layer "
+                              "has negative z-index composited content");
+  }
+
+  if (reasons & kCompositingReasonLayerForBackground) {
+    reason_list->AppendString("Convenience layer, background when main layer "
+                              "has a composited background");
+  }
+
+  if (reasons & kCompositingReasonLayerForMask)
+    reason_list->AppendString("Is a mask layer");
+
+  return reason_list.PassAs<base::Value>();
+}
+
 void LayerImpl::AsValueInto(base::DictionaryValue* state) const {
   TracedValue::MakeDictIntoImplicitSnapshot(state, LayerTypeAsString(), this);
   state->SetInteger("layer_id", id());
   state->Set("bounds", MathUtil::AsValue(bounds()).release());
   state->SetInteger("draws_content", DrawsContent());
   state->SetInteger("gpu_memory_usage", GPUMemoryUsageInBytes());
+  state->Set("compositing_reasons",
+             CompositingReasonsAsValue(compositing_reasons_).release());
 
   bool clipped;
   gfx::QuadF layer_quad = MathUtil::MapQuad(

cc/layers/layer_impl.h

@@ -16,6 +16,7 @@
 #include "cc/base/region.h"
 #include "cc/base/scoped_ptr_vector.h"
 #include "cc/input/input_handler.h"
+#include "cc/layers/compositing_reasons.h"
 #include "cc/layers/draw_properties.h"
 #include "cc/layers/layer_lists.h"
 #include "cc/layers/layer_position_constraint.h"
@@ -200,6 +201,14 @@ class CC_EXPORT LayerImpl : LayerAnimationValueObserver {
   void SetDebugName(const std::string& debug_name) { debug_name_ = debug_name; }
   std::string debug_name() const { return debug_name_; }
 
+  void SetCompositingReasons(CompositingReasons reasons) {
+      compositing_reasons_ = reasons;
+  }
+
+  CompositingReasons compositing_reasons() const {
+      return compositing_reasons_;
+  }
+
   bool ShowDebugBorders() const;
 
   // These invalidate the host's render surface layer list.  The caller
@@ -515,6 +524,7 @@ class CC_EXPORT LayerImpl : LayerAnimationValueObserver {
 
   // Debug layer name.
   std::string debug_name_;
+  CompositingReasons compositing_reasons_;
 
   WebKit::WebFilterOperations filters_;
   WebKit::WebFilterOperations background_filters_;

webkit/renderer/compositor_bindings/compositor_bindings.gyp

@@ -12,6 +12,7 @@
       'web_animation_curve_common.h',
       'web_animation_impl.cc',
       'web_animation_impl.h',
+      'web_compositing_reasons.cc',
       'web_content_layer_impl.cc',
       'web_content_layer_impl.h',
       'web_external_texture_layer_impl.cc',

webkit/renderer/compositor_bindings/web_compositing_reasons.cc

+// Copyright 2013 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 "base/basictypes.h"
+#include "cc/layers/compositing_reasons.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebCompositingReasons.h"
+
+#define COMPILE_ASSERT_MATCHING_ENUMS(cc_name, webkit_name)             \
+    COMPILE_ASSERT(                                                     \
+        static_cast<int>(cc_name) == static_cast<int>(webkit_name),     \
+        mismatching_enums)
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonUnknown,
+    WebKit::CompositingReasonUnknown);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReason3DTransform,
+    WebKit::CompositingReason3DTransform);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonVideo,
+    WebKit::CompositingReasonVideo);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonCanvas,
+    WebKit::CompositingReasonCanvas);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonPlugin,
+    WebKit::CompositingReasonPlugin);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonIFrame,
+    WebKit::CompositingReasonIFrame);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonBackfaceVisibilityHidden,
+    WebKit::CompositingReasonBackfaceVisibilityHidden);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonAnimation,
+    WebKit::CompositingReasonAnimation);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonFilters,
+    WebKit::CompositingReasonFilters);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonPositionFixed,
+    WebKit::CompositingReasonPositionFixed);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonPositionSticky,
+    WebKit::CompositingReasonPositionSticky);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonOverflowScrollingTouch,
+    WebKit::CompositingReasonOverflowScrollingTouch);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonBlending,
+    WebKit::CompositingReasonBlending);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonAssumedOverlap,
+    WebKit::CompositingReasonAssumedOverlap);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonOverlap,
+    WebKit::CompositingReasonOverlap);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonNegativeZIndexChildren,
+    WebKit::CompositingReasonNegativeZIndexChildren);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonTransformWithCompositedDescendants,
+    WebKit::CompositingReasonTransformWithCompositedDescendants);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonOpacityWithCompositedDescendants,
+    WebKit::CompositingReasonOpacityWithCompositedDescendants);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonMaskWithCompositedDescendants,
+    WebKit::CompositingReasonMaskWithCompositedDescendants);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonReflectionWithCompositedDescendants,
+    WebKit::CompositingReasonReflectionWithCompositedDescendants);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonFilterWithCompositedDescendants,
+    WebKit::CompositingReasonFilterWithCompositedDescendants);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonBlendingWithCompositedDescendants,
+    WebKit::CompositingReasonBlendingWithCompositedDescendants);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonClipsCompositingDescendants,
+    WebKit::CompositingReasonClipsCompositingDescendants);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonPerspective,
+    WebKit::CompositingReasonPerspective);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonPreserve3D,
+    WebKit::CompositingReasonPreserve3D);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonReflectionOfCompositedParent,
+    WebKit::CompositingReasonReflectionOfCompositedParent);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonRoot,
+    WebKit::CompositingReasonRoot);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonLayerForClip,
+    WebKit::CompositingReasonLayerForClip);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonLayerForScrollbar,
+    WebKit::CompositingReasonLayerForScrollbar);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonLayerForScrollingContainer,
+    WebKit::CompositingReasonLayerForScrollingContainer);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonLayerForForeground,
+    WebKit::CompositingReasonLayerForForeground);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonLayerForBackground,
+    WebKit::CompositingReasonLayerForBackground);
+
+COMPILE_ASSERT_MATCHING_ENUMS(
+    cc::kCompositingReasonLayerForMask,
+    WebKit::CompositingReasonLayerForMask);

webkit/renderer/compositor_bindings/web_layer_impl.cc

@@ -9,6 +9,7 @@
 #include "cc/base/region.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_position_constraint.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebCompositingReasons.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebFloatPoint.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebFloatRect.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebLayerPositionConstraint.h"
@@ -169,6 +170,11 @@ void WebLayerImpl::setDebugName(WebKit::WebString name) {
   layer_->SetDebugName(UTF16ToASCII(name));
 }
 
+void WebLayerImpl::setCompositingReasons(
+    WebKit::WebCompositingReasons reasons) {
+  layer_->SetCompositingReasons(reasons);
+}
+
 void WebLayerImpl::setAnimationDelegate(
       WebKit::WebAnimationDelegate* delegate) {
   layer_->set_layer_animation_delegate(delegate);

webkit/renderer/compositor_bindings/web_layer_impl.h

@@ -8,6 +8,7 @@
 #include "base/memory/ref_counted.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebAnimation.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebColor.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebCompositingReasons.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebFloatPoint.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebLayer.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebPoint.h"
@@ -81,6 +82,7 @@ class WebLayerImpl : public WebKit::WebLayer {
   virtual void setFilters(const WebKit::WebFilterOperations& filters);
   virtual void setBackgroundFilters(const WebKit::WebFilterOperations& filters);
   virtual void setDebugName(WebKit::WebString name);
+  virtual void setCompositingReasons(WebKit::WebCompositingReasons);
   virtual void setAnimationDelegate(WebKit::WebAnimationDelegate* delegate);
   virtual bool addAnimation(WebKit::WebAnimation* animation);
   virtual void removeAnimation(int animation_id);