cc: Add frame data to LTHI tracing

cc/quads/render_pass.cc

 // Copyright 2011 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/quads/render_pass.h"
 
+#include "base/values.h"
+#include "cc/base/math_util.h"
+#include "cc/debug/traced_value.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 
 namespace cc {
 
+template <class Type1, class Type2> size_t hash(Type1 value1, Type2 value2) {
+  BASE_HASH_NAMESPACE::hash<std::pair<Type1, Type2> > hash_functor;

[piman, 2013/07/31 00:49:40]

Ah, hold on, this doesn't work on MSVC, I'll have to extract the hash function
more properly.

+  return hash_functor(std::make_pair(value1, value2));
+}
+
+void* RenderPass::Id::AsTracingId() const {
+  return reinterpret_cast<void*>(hash(layer_id, index));

[piman, 2013/07/31 00:36:43]

Note: nothing ensures that this won't collide with pointers (that other classes
use as an ID), but when I need to refer to the RenderPass in the quad, the
RenderPass::Id is all I have, I don't have the RenderPass pointer itself. I
don't know if there's a better solution?

[vmpstr, 2013/07/31 16:23:25]

I think that's fine, but Nat might say otherwise? :) As an aside, I think we
should support any numeric type as a tracing id, not just a void*, but that's
unrelated to this patch.

+}
+
 scoped_ptr<RenderPass> RenderPass::Create() {
   return make_scoped_ptr(new RenderPass);
 }
 
 RenderPass::RenderPass()
     : id(Id(-1, -1)),
       has_transparent_background(true),
       has_occlusion_from_outside_target_surface(false) {}
 
-RenderPass::~RenderPass() {}
+RenderPass::~RenderPass() {
+  // Snapshot was created in cc.debug category, but only if cc.debug.quads is on
+  // as well.
+  bool enabled;
+  TRACE_EVENT_CATEGORY_GROUP_ENABLED(
+      TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"), &enabled);
+  if (enabled) {
+    TRACE_EVENT_OBJECT_DELETED_WITH_ID(TRACE_DISABLED_BY_DEFAULT("cc.debug"),

[piman, 2013/07/31 00:36:43]

I find this a bit awkward... The snapshot is associated with the category where
it is first taken, and the UI complains if we don't delete it from the same
category. But it means that the FrameData can't be dumped from another category
at the same time if we wanted to do that...

+                                       "cc::RenderPass",
+                                       id.AsTracingId());
+  }
+}
 
 scoped_ptr<RenderPass> RenderPass::Copy(Id new_id) const {
   scoped_ptr<RenderPass> copy_pass(Create());
   copy_pass->SetAll(new_id,
                     output_rect,
                     damage_rect,
                     transform_to_root_target,
                     has_transparent_background,
                     has_occlusion_from_outside_target_surface);
   return copy_pass.Pass();
@@ skipping 29 matching lines @@
   this->damage_rect = damage_rect;
   this->transform_to_root_target = transform_to_root_target;
   this->has_transparent_background = has_transparent_background;
   this->has_occlusion_from_outside_target_surface =
       has_occlusion_from_outside_target_surface;
 
   DCHECK(quad_list.empty());
   DCHECK(shared_quad_state_list.empty());
 }
 
+scoped_ptr<base::Value> RenderPass::AsValue() const {
+  scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
+  value->Set("output_rect", MathUtil::AsValue(output_rect).release());
+  value->Set("damage_rect", MathUtil::AsValue(damage_rect).release());
+  value->SetBoolean("has_transparent_background", has_transparent_background);
+  value->SetBoolean("has_occlusion_from_outside_target_surface",
+                    has_occlusion_from_outside_target_surface);
+  value->SetInteger("copy_requests", copy_requests.size());
+  scoped_ptr<base::ListValue> shared_states_value(new base::ListValue());
+  for (size_t i = 0; i < shared_quad_state_list.size(); ++i) {
+    shared_states_value->Append(shared_quad_state_list[i]->AsValue().release());
+  }
+  value->Set("shared_quad_state_list", shared_states_value.release());
+  scoped_ptr<base::ListValue> quad_list_value(new base::ListValue());
+  for (size_t i = 0; i < quad_list.size(); ++i) {
+    quad_list_value->Append(quad_list[i]->AsValue().release());
+  }
+  value->Set("quad_list", quad_list_value.release());
+
+  TracedValue::MakeDictIntoImplicitSnapshot(
+      value.get(), "cc::RenderPass", id.AsTracingId());
+  return value.PassAs<base::Value>();
+}
+
 }  // namespace cc