Added serialization to protobufs for property trees.

cc/trees/property_tree.cc

 // Copyright 2014 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 <set>
 #include <vector>
 
 #include "base/logging.h"
 #include "cc/base/math_util.h"
+#include "cc/proto/gfx_conversions.h"
+#include "cc/proto/property_tree.pb.h"
+#include "cc/proto/scroll_offset.pb.h"
+#include "cc/proto/transform.pb.h"
+#include "cc/proto/vector2df.pb.h"
 #include "cc/trees/property_tree.h"
 
 namespace cc {
 
+namespace {
+
+void CheckIsValidTreeNodeProto(

[David Trainor- moved to gerrit, 2015/11/12 22:46:11]

Can we just DCHECK(proto.has_***_node_data()) instead of calling this?

[Khushal, 2015/11/13 10:33:12]

The function is to make sure that the proto has only one of the *NodeData set. I
guess that's probably unnecesssary. Removed it.

+    const proto::TreeNode& proto,
+    const proto::PropertyTree::PropertyType expected_type) {
+  switch (expected_type) {
+    case proto::PropertyTree::Transform:
+      DCHECK(proto.has_transform_node_data());
+      DCHECK(!proto.has_clip_node_data());
+      DCHECK(!proto.has_effect_node_data());
+      return;
+    case proto::PropertyTree::Clip:
+      DCHECK(!proto.has_transform_node_data());
+      DCHECK(proto.has_clip_node_data());
+      DCHECK(!proto.has_effect_node_data());
+      return;
+    case proto::PropertyTree::Effect:
+      DCHECK(!proto.has_transform_node_data());
+      DCHECK(!proto.has_clip_node_data());
+      DCHECK(proto.has_effect_node_data());
+      return;
+    default:
+      NOTREACHED();
+  }
+}
+
+}  // namespace
+
+template <typename T>
+void TreeNode<T>::ToProtobuf(proto::TreeNode* proto) const {
+  proto->set_id(id);
+  proto->set_parent_id(parent_id);
+  proto->set_owner_id(owner_id);
+  data.ToProtobuf(proto);
+}
+
+template <typename T>
+void TreeNode<T>::FromProtobuf(const proto::TreeNode& proto) {
+  id = proto.id();
+  parent_id = proto.parent_id();
+  owner_id = proto.owner_id();
+  data.FromProtobuf(proto);
+}
+
 template <typename T>
 PropertyTree<T>::PropertyTree()
     : needs_update_(false) {
   nodes_.push_back(T());
   back()->id = 0;
   back()->parent_id = -1;
 }
 
 template <typename T>
 PropertyTree<T>::~PropertyTree() {
@@ skipping 19 matching lines @@
 }
 
 template <typename T>
 void PropertyTree<T>::clear() {
   nodes_.clear();
   nodes_.push_back(T());
   back()->id = 0;
   back()->parent_id = -1;
 }
 
+template <typename T>
+void PropertyTree<T>::ToProtobuf(proto::PropertyTree* proto) const {
+  DCHECK_EQ(0, proto->nodes_size());
+  for (size_t i = 0; i < nodes_.size(); i++)

[David Trainor- moved to gerrit, 2015/11/12 22:46:11]

for (const auto& node : nodes_)
...

Maybe remove const if we start having this be a bit smarter about sending deltas
in the future :).

[Khushal, 2015/11/13 10:33:13]

Done. Let's let the const stay for now. That's a TODO to get to. :)

+    nodes_[i].ToProtobuf(proto->add_nodes());
+  proto->set_needs_update(needs_update_);
+}
+
+template <typename T>
+void PropertyTree<T>::FromProtobuf(const proto::PropertyTree& proto) {
+  // Verify that the property tree is empty.
+  DCHECK_EQ(static_cast<int>(nodes_.size()), 1);
+  DCHECK_EQ(back()->id, 0);
+  DCHECK_EQ(back()->parent_id, -1);
+
+  // Add the first node.
+  DCHECK_GT(proto.nodes_size(), 0);
+  nodes_[0].FromProtobuf(proto.nodes(0));
+
+  for (int i = 1; i < proto.nodes_size(); i++) {
+    nodes_.push_back(T());
+    nodes_[i].FromProtobuf(proto.nodes(i));

[David Trainor- moved to gerrit, 2015/11/12 22:46:10]

Maybe just nodes_.back().FromProtobuf(proto.nodes(i))?

[Khushal, 2015/11/13 10:33:12]

Done.

+  }
+}
+
 template class PropertyTree<TransformNode>;
 template class PropertyTree<ClipNode>;
 template class PropertyTree<EffectNode>;
 
 TransformNodeData::TransformNodeData()
     : target_id(-1),
       content_target_id(-1),
       source_node_id(-1),
       needs_local_transform_update(true),
       is_invertible(true),
@@ skipping 32 matching lines @@
     const gfx::PointF& position,
     const gfx::Point3F& transform_origin) {
   post_local.MakeIdentity();
   post_local.Scale(post_local_scale_factor, post_local_scale_factor);
   post_local.Translate3d(
       position.x() + source_offset.x() + transform_origin.x(),
       position.y() + source_offset.y() + transform_origin.y(),
       transform_origin.z());
 }
 
+void TransformNodeData::ToProtobuf(proto::TreeNode* proto) const {
+  DCHECK(!proto->has_transform_node_data());
+  proto::TranformNodeData* data = proto->mutable_transform_node_data();
+
+  TransformToProto(pre_local, data->mutable_pre_local());
+  TransformToProto(local, data->mutable_local());
+  TransformToProto(post_local, data->mutable_post_local());
+
+  TransformToProto(to_parent, data->mutable_to_parent());
+
+  TransformToProto(to_target, data->mutable_to_target());
+  TransformToProto(from_target, data->mutable_from_target());
+
+  TransformToProto(to_screen, data->mutable_to_screen());
+  TransformToProto(from_screen, data->mutable_from_screen());
+
+  data->set_target_id(target_id);
+  data->set_content_target_id(content_target_id);
+  data->set_source_node_id(source_node_id);
+
+  data->set_needs_local_transform_update(needs_local_transform_update);
+
+  data->set_is_invertible(is_invertible);
+  data->set_ancestors_are_invertible(ancestors_are_invertible);
+
+  data->set_is_animated(is_animated);
+  data->set_to_screen_is_animated(to_screen_is_animated);
+  data->set_has_only_translation_animations(has_only_translation_animations);
+  data->set_to_screen_has_scale_animation(to_screen_has_scale_animation);
+
+  data->set_flattens_inherited_transform(flattens_inherited_transform);
+  data->set_node_and_ancestors_are_flat(node_and_ancestors_are_flat);
+
+  data->set_node_and_ancestors_have_only_integer_translation(
+      node_and_ancestors_have_only_integer_translation);
+  data->set_scrolls(scrolls);
+  data->set_needs_sublayer_scale(needs_sublayer_scale);
+
+  data->set_affected_by_inner_viewport_bounds_delta_x(
+      affected_by_inner_viewport_bounds_delta_x);
+  data->set_affected_by_inner_viewport_bounds_delta_y(
+      affected_by_inner_viewport_bounds_delta_y);
+  data->set_affected_by_outer_viewport_bounds_delta_x(
+      affected_by_outer_viewport_bounds_delta_x);
+  data->set_affected_by_outer_viewport_bounds_delta_y(
+      affected_by_outer_viewport_bounds_delta_y);
+
+  data->set_in_subtree_of_page_scale_layer(in_subtree_of_page_scale_layer);
+  data->set_post_local_scale_factor(post_local_scale_factor);
+  data->set_local_maximum_animation_target_scale(
+      local_maximum_animation_target_scale);
+  data->set_local_starting_animation_scale(local_starting_animation_scale);
+  data->set_combined_maximum_animation_target_scale(
+      combined_maximum_animation_target_scale);
+  data->set_combined_starting_animation_scale(
+      combined_starting_animation_scale);
+
+  Vector2dFToProto(sublayer_scale, data->mutable_sublayer_scale());
+  ScrollOffsetToProto(scroll_offset, data->mutable_scroll_offset());
+  Vector2dFToProto(scroll_snap, data->mutable_scroll_snap());
+  Vector2dFToProto(source_offset, data->mutable_source_offset());
+  Vector2dFToProto(source_to_parent, data->mutable_source_to_parent());
+}
+
+void TransformNodeData::FromProtobuf(const proto::TreeNode& proto) {
+  CheckIsValidTreeNodeProto(proto, proto::PropertyTree::Transform);
+
+  proto::TranformNodeData data = proto.transform_node_data();

[David Trainor- moved to gerrit, 2015/11/12 22:46:11]

const proto::TransformNodeData& data = ...;?  Same for others?

[Khushal, 2015/11/13 10:33:12]

Done.

+
+  pre_local = ProtoToTransform(data.pre_local());
+  local = ProtoToTransform(data.local());
+  post_local = ProtoToTransform(data.post_local());
+
+  to_parent = ProtoToTransform(data.to_parent());
+
+  to_target = ProtoToTransform(data.to_target());
+  from_target = ProtoToTransform(data.from_target());
+
+  to_screen = ProtoToTransform(data.to_screen());
+  from_screen = ProtoToTransform(data.from_screen());
+
+  target_id = data.target_id();
+  content_target_id = data.content_target_id();
+  source_node_id = data.source_node_id();
+
+  needs_local_transform_update = data.needs_local_transform_update();
+
+  is_invertible = data.is_invertible();
+  ancestors_are_invertible = data.ancestors_are_invertible();
+
+  is_animated = data.is_animated();
+  to_screen_is_animated = data.to_screen_is_animated();
+  has_only_translation_animations = data.has_only_translation_animations();
+  to_screen_has_scale_animation = data.to_screen_has_scale_animation();
+
+  flattens_inherited_transform = data.flattens_inherited_transform();
+  node_and_ancestors_are_flat = data.node_and_ancestors_are_flat();
+
+  node_and_ancestors_have_only_integer_translation =
+      data.node_and_ancestors_have_only_integer_translation();
+  scrolls = data.scrolls();
+  needs_sublayer_scale = data.needs_sublayer_scale();
+
+  affected_by_inner_viewport_bounds_delta_x =
+      data.affected_by_inner_viewport_bounds_delta_x();
+  affected_by_inner_viewport_bounds_delta_y =
+      data.affected_by_inner_viewport_bounds_delta_y();
+  affected_by_outer_viewport_bounds_delta_x =
+      data.affected_by_outer_viewport_bounds_delta_x();
+  affected_by_outer_viewport_bounds_delta_y =
+      data.affected_by_outer_viewport_bounds_delta_y();
+
+  in_subtree_of_page_scale_layer = data.in_subtree_of_page_scale_layer();
+  post_local_scale_factor = data.post_local_scale_factor();
+  local_maximum_animation_target_scale =
+      data.local_maximum_animation_target_scale();
+  local_starting_animation_scale = data.local_starting_animation_scale();
+  combined_maximum_animation_target_scale =
+      data.combined_maximum_animation_target_scale();
+  combined_starting_animation_scale = data.combined_starting_animation_scale();
+
+  sublayer_scale = ProtoToVector2dF(data.sublayer_scale());
+  scroll_offset = ProtoToScrollOffset(data.scroll_offset());
+  scroll_snap = ProtoToVector2dF(data.scroll_snap());
+  source_offset = ProtoToVector2dF(data.source_offset());
+  source_to_parent = ProtoToVector2dF(data.source_to_parent());
+}
+
 ClipNodeData::ClipNodeData()
     : transform_id(-1),
       target_id(-1),
       applies_local_clip(true),
       layer_clipping_uses_only_local_clip(false),
       target_is_clipped(false),
       layers_are_clipped(false),
       layers_are_clipped_when_surfaces_disabled(false),
       resets_clip(false) {}
 
+bool ClipNodeData::operator==(const ClipNodeData& other) const {
+  return clip == other.clip &&
+         combined_clip_in_target_space == other.combined_clip_in_target_space &&
+         clip_in_target_space == other.clip_in_target_space &&
+         transform_id == other.transform_id && target_id == other.target_id &&

[David Trainor- moved to gerrit, 2015/11/12 22:46:11]

one per line looks a lot cleaner imo.  does the presubmit styleguide prefer
this?

[Khushal, 2015/11/13 10:33:13]

The presubmit asks me to run git cl format for cc. It prefers it this way. :/

[David Trainor- moved to gerrit, 2015/11/13 16:28:21]

K no worries then!

+         applies_local_clip == other.applies_local_clip &&
+         layer_clipping_uses_only_local_clip ==
+             other.layer_clipping_uses_only_local_clip &&
+         target_is_clipped == other.target_is_clipped &&
+         layers_are_clipped == other.layers_are_clipped &&
+         layers_are_clipped_when_surfaces_disabled ==
+             other.layers_are_clipped_when_surfaces_disabled &&
+         resets_clip == other.resets_clip;
+}
+
+void ClipNodeData::ToProtobuf(proto::TreeNode* proto) const {
+  DCHECK(!proto->has_clip_node_data());
+  proto::ClipNodeData* data = proto->mutable_clip_node_data();
+
+  RectFToProto(clip, data->mutable_clip());
+  RectFToProto(combined_clip_in_target_space,
+               data->mutable_combined_clip_in_target_space());
+  RectFToProto(clip_in_target_space, data->mutable_clip_in_target_space());
+
+  data->set_transform_id(transform_id);
+  data->set_target_id(target_id);
+  data->set_applies_local_clip(applies_local_clip);
+  data->set_layer_clipping_uses_only_local_clip(
+      layer_clipping_uses_only_local_clip);
+  data->set_target_is_clipped(target_is_clipped);
+  data->set_layers_are_clipped(layers_are_clipped);
+  data->set_layers_are_clipped_when_surfaces_disabled(
+      layers_are_clipped_when_surfaces_disabled);
+  data->set_resets_clip(resets_clip);
+}
+
+void ClipNodeData::FromProtobuf(const proto::TreeNode& proto) {
+  CheckIsValidTreeNodeProto(proto, proto::PropertyTree::Clip);
+
+  proto::ClipNodeData data = proto.clip_node_data();
+
+  clip = ProtoToRectF(data.clip());

[David Trainor- moved to gerrit, 2015/11/12 22:46:11]

const &

[Khushal, 2015/11/13 10:33:13]

Done.

+  combined_clip_in_target_space =
+      ProtoToRectF(data.combined_clip_in_target_space());
+  clip_in_target_space = ProtoToRectF(data.clip_in_target_space());
+
+  transform_id = data.transform_id();
+  target_id = data.target_id();
+  applies_local_clip = data.applies_local_clip();
+  layer_clipping_uses_only_local_clip =
+      data.layer_clipping_uses_only_local_clip();
+  target_is_clipped = data.target_is_clipped();
+  layers_are_clipped = data.layers_are_clipped();
+  layers_are_clipped_when_surfaces_disabled =
+      data.layers_are_clipped_when_surfaces_disabled();
+  resets_clip = data.resets_clip();
+}
+
 EffectNodeData::EffectNodeData()
     : opacity(1.f),
       screen_space_opacity(1.f),
       has_render_surface(false),
       transform_id(0),
       clip_id(0) {}
 
+bool EffectNodeData::operator==(const EffectNodeData& other) const {

[David Trainor- moved to gerrit, 2015/11/12 22:46:10]

Need one for TransformNodeData?

[Khushal, 2015/11/13 10:33:13]

Done.

+  return opacity == other.opacity &&
+         screen_space_opacity == other.screen_space_opacity &&
+         has_render_surface == other.has_render_surface &&
+         transform_id == other.transform_id && clip_id == other.clip_id;

[David Trainor- moved to gerrit, 2015/11/12 22:46:10]

new line imo

[Khushal, 2015/11/13 10:33:12]

presubmit complains. :(

+}
+
+void EffectNodeData::ToProtobuf(proto::TreeNode* proto) const {
+  DCHECK(!proto->has_effect_node_data());
+  proto::EffectNodeData* data = proto->mutable_effect_node_data();
+  data->set_opacity(opacity);
+  data->set_screen_space_opacity(screen_space_opacity);
+  data->set_has_render_surface(has_render_surface);
+  data->set_transform_id(transform_id);
+  data->set_clip_id(clip_id);
+}
+
+void EffectNodeData::FromProtobuf(const proto::TreeNode& proto) {
+  CheckIsValidTreeNodeProto(proto, proto::PropertyTree::Effect);
+
+  proto::EffectNodeData data = proto.effect_node_data();

[David Trainor- moved to gerrit, 2015/11/12 22:46:11]

const &

[Khushal, 2015/11/13 10:33:12]

Done.

+
+  opacity = data.opacity();
+  screen_space_opacity = data.screen_space_opacity();
+  has_render_surface = data.has_render_surface();
+  transform_id = data.transform_id();
+  clip_id = data.clip_id();
+}
+
 void TransformTree::clear() {
   PropertyTree<TransformNode>::clear();
 
   nodes_affected_by_inner_viewport_bounds_delta_.clear();
   nodes_affected_by_outer_viewport_bounds_delta_.clear();
 }
 
 bool TransformTree::ComputeTransform(int source_id,
                                      int dest_id,
                                      gfx::Transform* transform) const {
@@ skipping 485 matching lines @@
 }
 
 bool TransformTree::HasNodesAffectedByInnerViewportBoundsDelta() const {
   return !nodes_affected_by_inner_viewport_bounds_delta_.empty();
 }
 
 bool TransformTree::HasNodesAffectedByOuterViewportBoundsDelta() const {
   return !nodes_affected_by_outer_viewport_bounds_delta_.empty();
 }
 
+void TransformTree::ToProtobuf(proto::PropertyTree* proto) const {
+  DCHECK(!proto->has_property_type());
+  proto->set_property_type(proto::PropertyTree::Transform);
+
+  PropertyTree::ToProtobuf(proto);
+  proto::TransformTreeData* data = proto->mutable_transform_tree_data();
+
+  data->set_source_to_parent_updates_allowed(source_to_parent_updates_allowed_);
+  data->set_page_scale_factor(page_scale_factor_);
+  data->set_device_scale_factor(device_scale_factor_);
+  data->set_device_transform_scale_factor(device_transform_scale_factor_);
+
+  Vector2dFToProto(inner_viewport_bounds_delta_,
+                   data->mutable_inner_viewport_bounds_delta());
+  Vector2dFToProto(outer_viewport_bounds_delta_,
+                   data->mutable_outer_viewport_bounds_delta());
+
+  for (int i : nodes_affected_by_inner_viewport_bounds_delta_)

[David Trainor- moved to gerrit, 2015/11/12 22:46:10]

would it be cleaner to use auto here and below?

[Khushal, 2015/11/13 10:33:12]

Done.

+    data->add_nodes_affected_by_inner_viewport_bounds_delta(i);
+
+  for (int i : nodes_affected_by_outer_viewport_bounds_delta_)
+    data->add_nodes_affected_by_outer_viewport_bounds_delta(i);
+}
+
+void TransformTree::FromProtobuf(const proto::PropertyTree& proto) {
+  DCHECK(proto.has_property_type());
+  DCHECK_EQ(proto.property_type(), proto::PropertyTree::Transform);
+
+  PropertyTree::FromProtobuf(proto);
+  proto::TransformTreeData data = proto.transform_tree_data();

[David Trainor- moved to gerrit, 2015/11/12 22:46:11]

const &

[Khushal, 2015/11/13 10:33:12]

Done.

+
+  source_to_parent_updates_allowed_ = data.source_to_parent_updates_allowed();
+  page_scale_factor_ = data.page_scale_factor();
+  device_scale_factor_ = data.device_scale_factor();
+  device_transform_scale_factor_ = data.device_transform_scale_factor();
+
+  inner_viewport_bounds_delta_ =
+      ProtoToVector2dF(data.inner_viewport_bounds_delta());
+  outer_viewport_bounds_delta_ =
+      ProtoToVector2dF(data.outer_viewport_bounds_delta());
+
+  DCHECK(nodes_affected_by_inner_viewport_bounds_delta_.empty());
+  for (int i = 0; i < data.nodes_affected_by_inner_viewport_bounds_delta_size();
+       i++) {
+    nodes_affected_by_inner_viewport_bounds_delta_.push_back(
+        data.nodes_affected_by_inner_viewport_bounds_delta(i));
+  }
+
+  DCHECK(nodes_affected_by_outer_viewport_bounds_delta_.empty());
+  for (int i = 0; i < data.nodes_affected_by_outer_viewport_bounds_delta_size();
+       i++) {
+    nodes_affected_by_outer_viewport_bounds_delta_.push_back(
+        data.nodes_affected_by_outer_viewport_bounds_delta(i));
+  }
+}
+
 void EffectTree::UpdateOpacities(int id) {
   EffectNode* node = Node(id);
   node->data.screen_space_opacity = node->data.opacity;
 
   EffectNode* parent_node = parent(node);
   if (parent_node)
     node->data.screen_space_opacity *= parent_node->data.screen_space_opacity;
 }
 
 void TransformTree::UpdateNodeAndAncestorsHaveIntegerTranslations(
@@ skipping 16 matching lines @@
   node->data.clip = viewport_rect;
   set_needs_update(true);
 }
 
 gfx::RectF ClipTree::ViewportClip() {
   const unsigned long min_size = 1;
   DCHECK_GT(size(), min_size);
   return Node(1)->data.clip;
 }
 
+void ClipTree::ToProtobuf(proto::PropertyTree* proto) const {
+  DCHECK(!proto->has_property_type());
+  proto->set_property_type(proto::PropertyTree::Clip);
+
+  PropertyTree::ToProtobuf(proto);
+}
+
+void ClipTree::FromProtobuf(const proto::PropertyTree& proto) {
+  DCHECK(proto.has_property_type());
+  DCHECK_EQ(proto.property_type(), proto::PropertyTree::Clip);
+
+  PropertyTree::FromProtobuf(proto);
+}
+
+void EffectTree::ToProtobuf(proto::PropertyTree* proto) const {
+  DCHECK(!proto->has_property_type());
+  proto->set_property_type(proto::PropertyTree::Effect);
+
+  PropertyTree::ToProtobuf(proto);
+}
+
+void EffectTree::FromProtobuf(const proto::PropertyTree& proto) {
+  DCHECK(proto.has_property_type());
+  DCHECK_EQ(proto.property_type(), proto::PropertyTree::Effect);
+
+  PropertyTree::FromProtobuf(proto);
+}
+
 PropertyTrees::PropertyTrees()
     : needs_rebuild(true),
       non_root_surfaces_enabled(true),
       sequence_number(0) {}
 
+void PropertyTrees::ToProtobuf(proto::PropertyTrees* proto) const {
+  // TODO(khushalsagar): Add support for sending diffs when serializaing

[David Trainor- moved to gerrit, 2015/11/12 22:46:11]

Add a bug number.

[Khushal, 2015/11/13 10:33:13]

Done.

+  // property trees.
+  transform_tree.ToProtobuf(proto->mutable_transform_tree());
+  effect_tree.ToProtobuf(proto->mutable_effect_tree());
+  clip_tree.ToProtobuf(proto->mutable_clip_tree());
+  proto->set_needs_rebuild(needs_rebuild);

[David Trainor- moved to gerrit, 2015/11/12 22:46:11]

Do we actually need this?  I guess it's fine to send.  Maybe we need it for when
we move PropertyTrees between LayerImpl trees?

[Khushal, 2015/11/13 10:33:12]

Not really. Once the tree has been re-built when updating layers, this flag is
reset, so when we send the property trees during a commit, this would probably
always be false.
The impl side changes it on its copy of the tree and then re-builds it when the
pending and active tree are being synchronized. Though I'm not sure if this is
being done right now.

I added it because I wasn't sure if we should do the direct serialization right
now or consider what happens during the commit flow. May be when we optimize
this later, this will be sent for the first commit and for each subsequent one,
we'll see that the field hasn't changed so we'll never re-send it.

I'm not sure what would be better. Wdyt?

+  proto->set_non_root_surfaces_enabled(non_root_surfaces_enabled);
+
+  // TODO(khushalsagar): Consider using the sequence number to decide if

[David Trainor- moved to gerrit, 2015/11/12 22:46:10]

Use same bug number as above imo :)

[Khushal, 2015/11/13 10:33:13]

Done.

+  // property trees need to be serialized again for a commit.
+  proto->set_sequence_number(sequence_number);
+}
+
+// static
+PropertyTrees PropertyTrees::CreateFromProtobuf(
+    const proto::PropertyTrees& proto) {
+  PropertyTrees property_trees;
+
+  property_trees.transform_tree.FromProtobuf(proto.transform_tree());
+  property_trees.effect_tree.FromProtobuf(proto.effect_tree());
+  property_trees.clip_tree.FromProtobuf(proto.clip_tree());
+
+  property_trees.needs_rebuild = proto.needs_rebuild();
+  property_trees.non_root_surfaces_enabled = proto.non_root_surfaces_enabled();
+  property_trees.sequence_number = proto.sequence_number();
+
+  return property_trees;
+}
+
 }  // namespace cc