[PE] Cleanup cc::Layer debug info

- Remove blink::GraphicsLayerDebugInfo::main_thread_scrolling_reasons_
  and its plumbing (cc::LayerClient::didUpdateMainThreadScrollingReasons()).
  Now we get it directly from cc::LayerImpl.

- Change the return value of cc::LayerClient::TakeDebugInfo() to
  std::unique_ptr<base::trace_event::TracedValue> to simplify handling
  of the debug info which is now added into the layer's traced value
  with a new name "debug_info" instead of merging into the layer's
  traced value.

- Remove the broken annotated invalidation tracking from
  blink::GraphicsLayerDebugInfo. Will fix the feature later.
  Also removed blink::FirstPaintInvalidationTracking.

The change won't break existing features because for now the debug info
data is either not used by the trace viewer or is used in a feature
that is not working properly.

--show-repaint-rects feature won't be affected because it uses data
in cc instead of GraphicsLayerDebugInfo.

See
https://cs.chromium.org/chromium/src/third_party/catapult/tracing/tracing/extras/chrome/cc/layer_impl.html?q=layer_impl.html&sq=package:chromium&g=0&l=1
and
https://cs.chromium.org/chromium/src/third_party/catapult/tracing/tracing/ui/extras/chrome/cc/layer_picker.html?rcl=03db8a6e5bb1eabfcbd88becac24c967597ed5bb&l=156
for the current usages of the debug info data in trace viewer.

Bug: 842238
Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2
Change-Id: I0bbb2c99842b0b22589a10d27d70e41eb1a6dc4a
Reviewed-on: https://chromium-review.googlesource.com/1055813
Commit-Queue: Xianzhu Wang <wangxianzhu@chromium.org>
Reviewed-by: Ian Vollick <vollick@chromium.org>
Reviewed-by: David Bokan <bokan@chromium.org>
Reviewed-by: Chris Harrelson <chrishtr@chromium.org>
Cr-Commit-Position: refs/heads/master@{#559637}

cc/BUILD.gn

@@ -33,6 +33,7 @@ cc_component("cc") {
     "input/input_handler.h",
     "input/layer_selection_bound.cc",
     "input/layer_selection_bound.h",
+    "input/main_thread_scrolling_reason.cc",
     "input/main_thread_scrolling_reason.h",
     "input/overscroll_behavior.h",
     "input/page_scale_animation.cc",
@@ -585,6 +586,7 @@ cc_test("cc_unittests") {
     "benchmarks/micro_benchmark_controller_unittest.cc",
     "debug/rendering_stats_unittest.cc",
     "input/browser_controls_offset_manager_unittest.cc",
+    "input/main_thread_scrolling_reason_unittest.cc",
     "input/scroll_snap_data_unittest.cc",
     "input/scroll_state_unittest.cc",
     "input/scrollbar_animation_controller_unittest.cc",

cc/input/main_thread_scrolling_reason.cc

@@ -0,0 +1,78 @@
+// Copyright 2018 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/input/main_thread_scrolling_reason.h"
+
+#include "base/stl_util.h"
+#include "base/trace_event/trace_event_argument.h"
+
+namespace cc {
+
+std::string MainThreadScrollingReason::AsText(uint32_t reasons) {
+  base::trace_event::TracedValue traced_value;
+  AddToTracedValue(reasons, traced_value);
+  std::string result = traced_value.ToString();
+  // Remove '{main_thread_scrolling_reasons:[', ']}', and any '"' chars.
+  size_t array_start_pos = result.find('[');
+  size_t array_end_pos = result.find(']');
+  result =
+      result.substr(array_start_pos + 1, array_end_pos - array_start_pos - 1);
+  base::Erase(result, '\"');
+  return result;
+}
+
+void MainThreadScrollingReason::AddToTracedValue(
+    uint32_t reasons,
+    base::trace_event::TracedValue& traced_value) {
+  traced_value.BeginArray("main_thread_scrolling_reasons");
+
+  if (reasons & kHasBackgroundAttachmentFixedObjects)
+    traced_value.AppendString("Has background-attachment:fixed");
+  if (reasons & kHasNonLayerViewportConstrainedObjects)
+    traced_value.AppendString("Has non-layer viewport-constrained objects");
+  if (reasons & kThreadedScrollingDisabled)
+    traced_value.AppendString("Threaded scrolling is disabled");
+  if (reasons & kScrollbarScrolling)
+    traced_value.AppendString("Scrollbar scrolling");
+  if (reasons & kPageOverlay)
+    traced_value.AppendString("Page overlay");
+  if (reasons & kHandlingScrollFromMainThread)
+    traced_value.AppendString("Handling scroll from main thread");
+  if (reasons & kCustomScrollbarScrolling)
+    traced_value.AppendString("Custom scrollbar scrolling");
+  if (reasons & kHasOpacityAndLCDText)
+    traced_value.AppendString("Has opacity and LCD text");
+  if (reasons & kHasTransformAndLCDText)
+    traced_value.AppendString("Has transform and LCD text");
+  if (reasons & kBackgroundNotOpaqueInRectAndLCDText)
+    traced_value.AppendString("Background is not opaque in rect and LCD text");
+  if (reasons & kHasBorderRadius)
+    traced_value.AppendString("Has border radius");
+  if (reasons & kHasClipRelatedProperty)
+    traced_value.AppendString("Has clip related property");
+  if (reasons & kHasBoxShadowFromNonRootLayer)
+    traced_value.AppendString("Has box shadow from non-root layer");
+  if (reasons & kIsNotStackingContextAndLCDText)
+    traced_value.AppendString("Is not stacking context and LCD text");
+
+  // Transient scrolling reasons.
+  if (reasons & kNonFastScrollableRegion)
+    traced_value.AppendString("Non fast scrollable region");
+  if (reasons & kFailedHitTest)
+    traced_value.AppendString("Failed hit test");
+  if (reasons & kNoScrollingLayer)
+    traced_value.AppendString("No scrolling layer");
+  if (reasons & kNotScrollable)
+    traced_value.AppendString("Not scrollable");
+  if (reasons & kContinuingMainThreadScroll)
+    traced_value.AppendString("Continuing main thread scroll");
+  if (reasons & kNonInvertibleTransform)
+    traced_value.AppendString("Non-invertible transform");
+  if (reasons & kPageBasedScrolling)
+    traced_value.AppendString("Page-based scrolling");
+
+  traced_value.EndArray();
+}
+
+}  // namespace cc

cc/input/main_thread_scrolling_reason.h

@@ -5,17 +5,22 @@
 #ifndef CC_INPUT_MAIN_THREAD_SCROLLING_REASON_H_
 #define CC_INPUT_MAIN_THREAD_SCROLLING_REASON_H_
 
+#include <memory>
 #include <string>
+#include "cc/cc_export.h"
 
-#include "base/stl_util.h"
-#include "base/trace_event/trace_event_argument.h"
+namespace base {
+namespace trace_event {
+class TracedValue;
+}
+}  // namespace base
 
 namespace cc {
 
 // Ensure this stays in sync with MainThreadScrollingReason in histograms.xml.
 // When adding a new MainThreadScrollingReason, make sure the corresponding
 // [MainThread/Compositor]CanSetScrollReasons function is also updated.
-struct MainThreadScrollingReason {
+struct CC_EXPORT MainThreadScrollingReason {
   enum : uint32_t {
     // Non-transient scrolling reasons.
     kNotScrollingOnMain = 0,
@@ -96,72 +101,9 @@ struct MainThreadScrollingReason {
     return (reasons & kNonCompositedReasons) != 0;
   }
 
-  static std::string mainThreadScrollingReasonsAsText(uint32_t reasons) {
-    base::trace_event::TracedValue tracedValue;
-    mainThreadScrollingReasonsAsTracedValue(reasons, &tracedValue);
-    std::string result_in_array_foramt = tracedValue.ToString();
-    // Remove '{main_thread_scrolling_reasons:[', ']}', and any '"' chars.
-    std::string result =
-        result_in_array_foramt.substr(34, result_in_array_foramt.length() - 36);
-    base::Erase(result, '\"');
-    return result;
-  }
-
-  static void mainThreadScrollingReasonsAsTracedValue(
-      uint32_t reasons,
-      base::trace_event::TracedValue* tracedValue) {
-    tracedValue->BeginArray("main_thread_scrolling_reasons");
-    if (reasons &
-        MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects)
-      tracedValue->AppendString("Has background-attachment:fixed");
-    if (reasons &
-        MainThreadScrollingReason::kHasNonLayerViewportConstrainedObjects)
-      tracedValue->AppendString("Has non-layer viewport-constrained objects");
-    if (reasons & MainThreadScrollingReason::kThreadedScrollingDisabled)
-      tracedValue->AppendString("Threaded scrolling is disabled");
-    if (reasons & MainThreadScrollingReason::kScrollbarScrolling)
-      tracedValue->AppendString("Scrollbar scrolling");
-    if (reasons & MainThreadScrollingReason::kPageOverlay)
-      tracedValue->AppendString("Page overlay");
-    if (reasons & MainThreadScrollingReason::kHandlingScrollFromMainThread)
-      tracedValue->AppendString("Handling scroll from main thread");
-    if (reasons & MainThreadScrollingReason::kCustomScrollbarScrolling)
-      tracedValue->AppendString("Custom scrollbar scrolling");
-    if (reasons & MainThreadScrollingReason::kHasOpacityAndLCDText)
-      tracedValue->AppendString("Has opacity and LCD text");
-    if (reasons & MainThreadScrollingReason::kHasTransformAndLCDText)
-      tracedValue->AppendString("Has transform and LCD text");
-    if (reasons &
-        MainThreadScrollingReason::kBackgroundNotOpaqueInRectAndLCDText) {
-      tracedValue->AppendString(
-          "Background is not opaque in rect and LCD text");
-    }
-    if (reasons & MainThreadScrollingReason::kHasBorderRadius)
-      tracedValue->AppendString("Has border radius");
-    if (reasons & MainThreadScrollingReason::kHasClipRelatedProperty)
-      tracedValue->AppendString("Has clip related property");
-    if (reasons & MainThreadScrollingReason::kHasBoxShadowFromNonRootLayer)
-      tracedValue->AppendString("Has box shadow from non-root layer");
-    if (reasons & MainThreadScrollingReason::kIsNotStackingContextAndLCDText)
-      tracedValue->AppendString("Is not stacking context and LCD text");
-
-    // Transient scrolling reasons.
-    if (reasons & MainThreadScrollingReason::kNonFastScrollableRegion)
-      tracedValue->AppendString("Non fast scrollable region");
-    if (reasons & MainThreadScrollingReason::kFailedHitTest)
-      tracedValue->AppendString("Failed hit test");
-    if (reasons & MainThreadScrollingReason::kNoScrollingLayer)
-      tracedValue->AppendString("No scrolling layer");
-    if (reasons & MainThreadScrollingReason::kNotScrollable)
-      tracedValue->AppendString("Not scrollable");
-    if (reasons & MainThreadScrollingReason::kContinuingMainThreadScroll)
-      tracedValue->AppendString("Continuing main thread scroll");
-    if (reasons & MainThreadScrollingReason::kNonInvertibleTransform)
-      tracedValue->AppendString("Non-invertible transform");
-    if (reasons & MainThreadScrollingReason::kPageBasedScrolling)
-      tracedValue->AppendString("Page-based scrolling");
-    tracedValue->EndArray();
-  }
+  static std::string AsText(uint32_t reasons);
+  static void AddToTracedValue(uint32_t reasons,
+                               base::trace_event::TracedValue&);
 };
 
 }  // namespace cc

cc/input/main_thread_scrolling_reason_unittest.cc

@@ -0,0 +1,38 @@
+// Copyright 2018 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/input/main_thread_scrolling_reason.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace cc {
+
+using MainThreadScrollingReasonTest = testing::Test;
+
+TEST_F(MainThreadScrollingReasonTest, AsText) {
+  EXPECT_EQ("", MainThreadScrollingReason::AsText(0));
+  EXPECT_EQ(
+      "Has background-attachment:fixed,"
+      "Has non-layer viewport-constrained objects,"
+      "Threaded scrolling is disabled,"
+      "Scrollbar scrolling,Page overlay,"
+      "Handling scroll from main thread,"
+      "Custom scrollbar scrolling,"
+      "Has opacity and LCD text,"
+      "Has transform and LCD text,"
+      "Background is not opaque in rect and LCD text,"
+      "Has border radius,Has clip related property,"
+      "Has box shadow from non-root layer,"
+      "Is not stacking context and LCD text,"
+      "Non fast scrollable region,"
+      "Failed hit test,"
+      "No scrolling layer,"
+      "Not scrollable,"
+      "Continuing main thread scroll,"
+      "Non-invertible transform,"
+      "Page-based scrolling",
+      MainThreadScrollingReason::AsText(0xffffffffu));
+}
+
+}  // namespace cc

cc/layers/layer.cc

@@ -896,7 +896,6 @@ void Layer::AddMainThreadScrollingReasons(
   if (inputs_.main_thread_scrolling_reasons == new_reasons)
     return;
   inputs_.main_thread_scrolling_reasons = new_reasons;
-  didUpdateMainThreadScrollingReasons();
   SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
@@ -910,7 +909,6 @@ void Layer::ClearMainThreadScrollingReasons(
   if (new_reasons == inputs_.main_thread_scrolling_reasons)
     return;
   inputs_.main_thread_scrolling_reasons = new_reasons;
-  didUpdateMainThreadScrollingReasons();
   SetPropertyTreesNeedRebuild();
   SetNeedsCommit();
 }
@@ -1167,10 +1165,10 @@ void Layer::SetStickyPositionConstraint(
 }
 
 void Layer::SetLayerClient(base::WeakPtr<LayerClient> client) {
-  inputs_.client = std::move(client);
   // Both binds the weak_ptr to the main thread and stores a rawptr for access
   // during commit.
   inputs_.client_rawptr = client.get();
+  inputs_.client = std::move(client);
 }
 
 bool Layer::IsSnapped() {
@@ -1325,8 +1323,7 @@ bool Layer::HasNonAAPaint() const {
   return false;
 }
 
-std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
-Layer::TakeDebugInfo() {
+std::unique_ptr<base::trace_event::TracedValue> Layer::TakeDebugInfo() {
   // TakeDebugInfo is called from the compositor thread while the main thread is
   // blocked so we use the raw client pointer as we can't check whether the
   // reference is safe on the weak pointer.
@@ -1336,13 +1333,7 @@ Layer::TakeDebugInfo() {
   // the compositor thread. https://crbug.com/826455
   if (inputs_.client_rawptr)
     return inputs_.client_rawptr->TakeDebugInfo(this);
-  else
-    return nullptr;
-}
-
-void Layer::didUpdateMainThreadScrollingReasons() {
-  if (inputs_.client)
-    inputs_.client->didUpdateMainThreadScrollingReasons();
+  return nullptr;
 }
 
 void Layer::SetSubtreePropertyChanged() {
@@ -1361,7 +1352,7 @@ void Layer::SetMayContainVideo(bool yes) {
 
 void Layer::SetScrollbarsHiddenFromImplSide(bool hidden) {
   if (inputs_.client)
-    inputs_.client->didChangeScrollbarsHiddenIfOverlay(hidden);
+    inputs_.client->DidChangeScrollbarsHiddenIfOverlay(hidden);
 }
 
 // On<Property>Animated is called due to an ongoing accelerated animation.

cc/layers/layer.h

@@ -41,7 +41,7 @@
 
 namespace base {
 namespace trace_event {
-class ConvertableToTraceFormat;
+class TracedValue;
 }
 }
 
@@ -351,9 +351,7 @@ class CC_EXPORT Layer : public base::RefCounted<Layer> {
   virtual bool HasSlowPaths() const;
   virtual bool HasNonAAPaint() const;
 
-  virtual std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
-  TakeDebugInfo();
-  virtual void didUpdateMainThreadScrollingReasons();
+  std::unique_ptr<base::trace_event::TracedValue> TakeDebugInfo();
 
   void SetLayerClient(base::WeakPtr<LayerClient> client);
 

cc/layers/layer_client.h

@@ -11,7 +11,7 @@
 
 namespace base {
 namespace trace_event {
-class ConvertableToTraceFormat;
+class TracedValue;
 }
 }
 
@@ -28,10 +28,10 @@ class CC_EXPORT LayerClient {
   //
   // A pointer to the layer is provided for the convenience of layer clients
   // which service multiple layers.
-  virtual std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
-  TakeDebugInfo(Layer* layer) = 0;
-  virtual void didUpdateMainThreadScrollingReasons() = 0;
-  virtual void didChangeScrollbarsHiddenIfOverlay(bool) = 0;
+  virtual std::unique_ptr<base::trace_event::TracedValue> TakeDebugInfo(
+      Layer* layer) = 0;
+
+  virtual void DidChangeScrollbarsHiddenIfOverlay(bool) = 0;
 
  protected:
   virtual ~LayerClient() {}

cc/layers/layer_impl.cc

@@ -114,7 +114,7 @@ ElementListType LayerImpl::GetElementTypeForAnimation() const {
 }
 
 void LayerImpl::SetDebugInfo(
-    std::unique_ptr<base::trace_event::ConvertableToTraceFormat> debug_info) {
+    std::unique_ptr<base::trace_event::TracedValue> debug_info) {
   owned_debug_info_ = std::move(debug_info);
   debug_info_ = owned_debug_info_.get();
   SetNeedsPushProperties();
@@ -408,6 +408,9 @@ std::unique_ptr<base::DictionaryValue> LayerImpl::LayerAsJson() {
   result->SetBoolean("Is3dSorted", Is3dSorted());
   result->SetDouble("OPACITY", Opacity());
   result->SetBoolean("ContentsOpaque", contents_opaque_);
+  result->SetString(
+      "mainThreadScrollingReasons",
+      MainThreadScrollingReason::AsText(main_thread_scrolling_reasons_));
 
   if (scrollable())
     result->SetBoolean("Scrollable", true);
@@ -764,25 +767,11 @@ void LayerImpl::AsValueInto(base::trace_event::TracedValue* state) const {
 
   state->SetBoolean("trilinear_filtering", trilinear_filtering());
 
-  if (debug_info_) {
-    std::string str;
-    debug_info_->AppendAsTraceFormat(&str);
-    base::JSONReader json_reader;
-    std::unique_ptr<base::Value> debug_info_value(json_reader.ReadToValue(str));
-
-    if (debug_info_value->is_dict()) {
-      base::DictionaryValue* dictionary_value = nullptr;
-      bool converted_to_dictionary =
-          debug_info_value->GetAsDictionary(&dictionary_value);
-      DCHECK(converted_to_dictionary);
-      for (base::DictionaryValue::Iterator it(*dictionary_value); !it.IsAtEnd();
-           it.Advance()) {
-        state->SetValue(it.key().data(), it.value().CreateDeepCopy());
-      }
-    } else {
-      NOTREACHED();
-    }
-  }
+  MainThreadScrollingReason::AddToTracedValue(main_thread_scrolling_reasons_,
+                                              *state);
+
+  if (debug_info_)
+    state->SetValue("debug_info", *debug_info_);
 }
 
 size_t LayerImpl::GPUMemoryUsageInBytes() const { return 0; }