tracing: Make ConvertableToTraceFormat move-only scoped_ptr

cc/layers/layer_impl.cc

 // Copyright 2012 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/layers/layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 76 matching lines @@
       effect_tree_index_(-1),
       clip_tree_index_(-1),
       scroll_tree_index_(-1),
       draw_depth_(0.f),
       needs_push_properties_(false),
       num_dependents_need_push_properties_(0),
       sorting_context_id_(0),
       current_draw_mode_(DRAW_MODE_NONE),
       element_id_(0),
       mutable_properties_(MutableProperty::kNone),
+      debug_info_(nullptr),
       force_render_surface_(false),
       frame_timing_requests_dirty_(false),
       visited_(false),
       layer_or_descendant_is_drawn_(false),
       layer_or_descendant_has_touch_handler_(false),
       sorted_for_recursion_(false) {
   DCHECK_GT(layer_id_, 0);
   DCHECK(layer_tree_impl_);
   layer_tree_impl_->RegisterLayer(this);
 
@@ skipping 89 matching lines @@
     return;
 
   if (parent)
     DCHECK_EQ(layer_tree_impl()->LayerById(parent->id()), parent);
 
   scroll_parent_ = parent;
   SetNeedsPushProperties();
 }
 
 void LayerImpl::SetDebugInfo(
-    scoped_refptr<base::trace_event::ConvertableToTraceFormat> other) {
-  debug_info_ = other;
+    scoped_ptr<base::trace_event::ConvertableToTraceFormat> debug_info) {
+  owned_debug_info_ = std::move(debug_info);
+  debug_info_ = owned_debug_info_.get();
   SetNeedsPushProperties();
 }
 
 void LayerImpl::SetScrollChildren(std::set<LayerImpl*>* children) {
   if (scroll_children_.get() == children)
     return;
   scroll_children_.reset(children);
   SetNeedsPushProperties();
 }
 
@@ skipping 384 matching lines @@
 
   layer->PassCopyRequests(&copy_requests_);
 
   // If the main thread commits multiple times before the impl thread actually
   // draws, then damage tracking will become incorrect if we simply clobber the
   // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e.
   // union) any update changes that have occurred on the main thread.
   update_rect_.Union(layer->update_rect());
   layer->SetUpdateRect(update_rect_);
 
-  layer->SetDebugInfo(debug_info_);
+  if (owned_debug_info_)

[danakj, 2016/02/29 18:19:18]

For my own understand, was it failing without this if? I guess that'd mean
sometimes the layer is pushing without being pushed to from the main thread.

[Primiano Tucci (use gerrit), 2016/02/29 18:32:38]

Yes precisely. It was not crashing but failing the layouttest.
No ide. Could it happen that:
- layer A owns the debug info.
- layer A pushes to B (now B becomes owner, A just keeps a ptr)
- Later B pushes to C (now C is owner, A and B just raw ptr)
- Later A pushes to C.
At this point, without this if, it would invalidate C's debug info.
 ?

[danakj, 2016/02/29 19:19:07]

There's only A & B. But I guess it means that we SetNeedsPushProps on the
pending tree sometimes other than a main thread push. I wasn't sure, it's good
to know that happens.

+    layer->SetDebugInfo(std::move(owned_debug_info_));
 
   if (frame_timing_requests_dirty_) {
     layer->SetFrameTimingRequests(frame_timing_requests_);
     frame_timing_requests_dirty_ = false;
   }
 
   // Reset any state that should be cleared for the next update.
   layer_property_changed_ = false;
   update_rect_ = gfx::Rect();
   needs_push_properties_ = false;
@@ skipping 1014 matching lines @@
   state->SetBoolean(
       "has_animation_bounds",
       layer_animation_controller_
           ? layer_animation_controller_->HasAnimationThatInflatesBounds()
           : layer_tree_impl_->HasAnimationThatInflatesBounds(this));
 
   gfx::BoxF box;
   if (LayerUtils::GetAnimationBounds(*this, &box))
     MathUtil::AddToTracedValue("animation_bounds", box, state);
 
-  if (debug_info_.get()) {
+  if (debug_info_) {
     std::string str;
     debug_info_->AppendAsTraceFormat(&str);
     base::JSONReader json_reader;
     scoped_ptr<base::Value> debug_info_value(json_reader.ReadToValue(str));
 
     if (debug_info_value->IsType(base::Value::TYPE_DICTIONARY)) {
       base::DictionaryValue* dictionary_value = nullptr;
       bool converted_to_dictionary =
           debug_info_value->GetAsDictionary(&dictionary_value);
       DCHECK(converted_to_dictionary);
@@ skipping 120 matching lines @@
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       DrawTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc