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 {
 
 template <typename T>
+bool TreeNode<T>::operator==(const TreeNode<T>& other) const {
+  return id == other.id && parent_id == other.parent_id &&
+         owner_id == other.owner_id && data == other.data;
+}
+
+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 struct TreeNode<TransformNodeData>;
+template struct TreeNode<ClipNodeData>;
+template struct TreeNode<EffectNodeData>;
+
+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 18 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>
+bool PropertyTree<T>::operator==(const PropertyTree<T>& other) const {
+  return nodes_ == other.nodes() && needs_update_ == other.needs_update();
+}
+
+template <typename T>
+void PropertyTree<T>::ToProtobuf(proto::PropertyTree* proto) const {
+  DCHECK_EQ(0, proto->nodes_size());
+  for (const auto& node : nodes_)
+    node.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_.back().FromProtobuf(proto.nodes(0));
+
+  for (int i = 1; i < proto.nodes_size(); ++i) {
+    nodes_.push_back(T());
+    nodes_.back().FromProtobuf(proto.nodes(i));
+  }
+
+  needs_update_ = proto.needs_update();
+}
+
 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 14 matching lines @@
       in_subtree_of_page_scale_layer(false),
       post_local_scale_factor(1.0f),
       local_maximum_animation_target_scale(0.f),
       local_starting_animation_scale(0.f),
       combined_maximum_animation_target_scale(0.f),
       combined_starting_animation_scale(0.f) {}
 
 TransformNodeData::~TransformNodeData() {
 }
 
+bool TransformNodeData::operator==(const TransformNodeData& other) const {
+  return pre_local == other.pre_local && local == other.local &&
+         post_local == other.post_local && to_parent == other.to_parent &&
+         to_target == other.to_target && from_target == other.from_target &&
+         to_screen == other.to_screen && from_screen == other.from_screen &&
+         target_id == other.target_id &&
+         content_target_id == other.content_target_id &&
+         source_node_id == other.source_node_id &&
+         needs_local_transform_update == other.needs_local_transform_update &&
+         is_invertible == other.is_invertible &&
+         ancestors_are_invertible == other.ancestors_are_invertible &&
+         is_animated == other.is_animated &&
+         to_screen_is_animated == other.to_screen_is_animated &&
+         has_only_translation_animations ==
+             other.has_only_translation_animations &&
+         to_screen_has_scale_animation == other.to_screen_has_scale_animation &&
+         flattens_inherited_transform == other.flattens_inherited_transform &&
+         node_and_ancestors_are_flat == other.node_and_ancestors_are_flat &&
+         node_and_ancestors_have_only_integer_translation ==
+             other.node_and_ancestors_have_only_integer_translation &&
+         scrolls == other.scrolls &&
+         needs_sublayer_scale == other.needs_sublayer_scale &&
+         affected_by_inner_viewport_bounds_delta_x ==
+             other.affected_by_inner_viewport_bounds_delta_x &&
+         affected_by_inner_viewport_bounds_delta_y ==
+             other.affected_by_inner_viewport_bounds_delta_y &&
+         affected_by_outer_viewport_bounds_delta_x ==
+             other.affected_by_outer_viewport_bounds_delta_x &&
+         affected_by_outer_viewport_bounds_delta_y ==
+             other.affected_by_outer_viewport_bounds_delta_y &&
+         in_subtree_of_page_scale_layer ==
+             other.in_subtree_of_page_scale_layer &&
+         post_local_scale_factor == other.post_local_scale_factor &&
+         local_maximum_animation_target_scale ==
+             other.local_maximum_animation_target_scale &&
+         local_starting_animation_scale ==
+             other.local_starting_animation_scale &&
+         combined_maximum_animation_target_scale ==
+             other.combined_maximum_animation_target_scale &&
+         combined_starting_animation_scale ==
+             other.combined_starting_animation_scale &&
+         sublayer_scale == other.sublayer_scale &&
+         scroll_offset == other.scroll_offset &&
+         scroll_snap == other.scroll_snap &&
+         source_offset == other.source_offset &&
+         source_to_parent == other.source_to_parent;
+}
+
 void TransformNodeData::update_pre_local_transform(
     const gfx::Point3F& transform_origin) {
   pre_local.MakeIdentity();
   pre_local.Translate3d(-transform_origin.x(), -transform_origin.y(),
                         -transform_origin.z());
 }
 
 void TransformNodeData::update_post_local_transform(
     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) {
+  DCHECK(proto.has_transform_node_data());
+  const proto::TranformNodeData& data = proto.transform_node_data();
+
+  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 &&
+         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) {
+  DCHECK(proto.has_clip_node_data());
+  const proto::ClipNodeData& data = proto.clip_node_data();
+
+  clip = ProtoToRectF(data.clip());
+  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 {
+  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;
+}
+
+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) {
+  DCHECK(proto.has_effect_node_data());
+  const proto::EffectNodeData& data = proto.effect_node_data();
+
+  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();
 }
 
+bool TransformTree::operator==(const TransformTree& other) const {
+  return PropertyTree::operator==(other) &&
+         source_to_parent_updates_allowed_ ==
+             other.source_to_parent_updates_allowed() &&
+         page_scale_factor_ == other.page_scale_factor() &&
+         device_scale_factor_ == other.device_scale_factor() &&
+         device_transform_scale_factor_ ==
+             other.device_transform_scale_factor() &&
+         inner_viewport_bounds_delta_ == other.inner_viewport_bounds_delta() &&
+         outer_viewport_bounds_delta_ == other.outer_viewport_bounds_delta() &&
+         nodes_affected_by_inner_viewport_bounds_delta_ ==
+             other.nodes_affected_by_inner_viewport_bounds_delta() &&
+         nodes_affected_by_outer_viewport_bounds_delta_ ==
+             other.nodes_affected_by_outer_viewport_bounds_delta();
+}
+
+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 (auto i : nodes_affected_by_inner_viewport_bounds_delta_)
+    data->add_nodes_affected_by_inner_viewport_bounds_delta(i);
+
+  for (auto 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);
+  const proto::TransformTreeData& data = proto.transform_tree_data();
+
+  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;
 }
 
+bool ClipTree::operator==(const ClipTree& other) const {
+  return PropertyTree::operator==(other);
+}
+
+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);
+}
+
+bool EffectTree::operator==(const EffectTree& other) const {
+  return PropertyTree::operator==(other);
+}
+
+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) {}
 
+bool PropertyTrees::operator==(const PropertyTrees& other) const {
+  return transform_tree == other.transform_tree &&
+         effect_tree == other.effect_tree && clip_tree == other.clip_tree &&
+         needs_rebuild == other.needs_rebuild &&
+         non_root_surfaces_enabled == other.non_root_surfaces_enabled &&
+         sequence_number == other.sequence_number;
+}
+
+void PropertyTrees::ToProtobuf(proto::PropertyTrees* proto) const {
+  // TODO(khushalsagar): Add support for sending diffs when serializaing
+  // property trees. See crbug/555370.
+  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);
+  proto->set_non_root_surfaces_enabled(non_root_surfaces_enabled);
+
+  // TODO(khushalsagar): Consider using the sequence number to decide if
+  // property trees need to be serialized again for a commit. See crbug/555370.
+  proto->set_sequence_number(sequence_number);
+}
+
+// static
+void PropertyTrees::FromProtobuf(const proto::PropertyTrees& proto) {
+  transform_tree.FromProtobuf(proto.transform_tree());
+  effect_tree.FromProtobuf(proto.effect_tree());
+  clip_tree.FromProtobuf(proto.clip_tree());
+
+  needs_rebuild = proto.needs_rebuild();
+  non_root_surfaces_enabled = proto.non_root_surfaces_enabled();
+  sequence_number = proto.sequence_number();
+}
+
 }  // namespace cc