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(
+    const proto::TreeNode& proto,
+    const proto::TreeNode::PropertyType expected_type) {
+  DCHECK(proto.has_property_type());
+  DCHECK_EQ(expected_type, proto.property_type());
+  switch (proto.property_type()) {
+    case proto::TreeNode::Transform:
+      DCHECK(proto.has_transform_node_data());
+      DCHECK(!proto.has_clip_node_data());
+      DCHECK(!proto.has_effect_node_data());
+      return;
+    case proto::TreeNode::Clip:
+      DCHECK(!proto.has_transform_node_data());
+      DCHECK(proto.has_clip_node_data());
+      DCHECK(!proto.has_effect_node_data());
+      return;
+    case proto::TreeNode::Effect:
+      DCHECK(!proto.has_transform_node_data());
+      DCHECK(!proto.has_clip_node_data());
+      DCHECK(proto.has_effect_node_data());
+      return;
+    default:
+      NOTREACHED();
+  }
+}
+}
+
 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 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>
+void PropertyTree<T>::ToProtobuf(proto::PropertyTree* proto) const {

[Khushal, 2015/11/11 19:14:13]

Serialization for the base PropertyTree.

+  DCHECK_EQ(0, proto->nodes_size());
+  for (size_t i = 0; i < nodes_.size(); i++)
+    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(0, proto.nodes_size());
+  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));
+  }
+}
+
 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_property_type());

[Khushal, 2015/11/11 19:14:13]

We don't really need the property type here. I added it for the DCHECK.
But may be that's an overkill?
We can probably just check that the proto has only the expected data field set
here.

+  proto->set_property_type(proto::TreeNode::Transform);
+
+  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::TreeNode::Transform);
+
+  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) {}
 
+void ClipNodeData::ToProtobuf(proto::TreeNode* proto) const {
+  DCHECK(!proto->has_property_type());
+  proto->set_property_type(proto::TreeNode::Clip);
+
+  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::TreeNode::Clip);
+
+  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_property_type());
+  proto->set_property_type(proto::TreeNode::Effect);
+
+  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::TreeNode::Effect);
+
+  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();
 }
 
+void TransformTree::ToProtobuf(proto::TransformTree* proto) const {
+  DCHECK(!proto->has_property_tree());
+  PropertyTree::ToProtobuf(proto->mutable_property_tree());

[David Trainor- moved to gerrit, 2015/11/11 16:43:16]

I can't find this.  Not added yet?

[Khushal, 2015/11/11 19:14:13]

Added a comment for where it is.

+
+  proto->set_source_to_parent_updates_allowed(
+      source_to_parent_updates_allowed_);
+  proto->set_page_scale_factor(page_scale_factor_);
+  proto->set_device_scale_factor(device_scale_factor_);
+  proto->set_device_transform_scale_factor(device_transform_scale_factor_);
+
+  Vector2dFToProto(inner_viewport_bounds_delta_,
+                   proto->mutable_inner_viewport_bounds_delta());
+  Vector2dFToProto(outer_viewport_bounds_delta_,
+                   proto->mutable_outer_viewport_bounds_delta());
+
+  for (int i : nodes_affected_by_inner_viewport_bounds_delta_)
+    proto->add_nodes_affected_by_inner_viewport_bounds_delta(i);
+
+  for (int i : nodes_affected_by_outer_viewport_bounds_delta_)
+    proto->add_nodes_affected_by_outer_viewport_bounds_delta(i);
+}
+
+void TransformTree::FromProtobuf(const proto::TransformTree& proto) {
+  DCHECK(proto.has_property_tree());
+  PropertyTree::FromProtobuf(proto.property_tree());
+
+  source_to_parent_updates_allowed_ = proto.source_to_parent_updates_allowed();
+  page_scale_factor_ = proto.page_scale_factor();
+  device_scale_factor_ = proto.device_scale_factor();
+  device_transform_scale_factor_ = proto.device_transform_scale_factor();
+
+  inner_viewport_bounds_delta_ =
+      ProtoToVector2dF(proto.inner_viewport_bounds_delta());
+  outer_viewport_bounds_delta_ =
+      ProtoToVector2dF(proto.outer_viewport_bounds_delta());
+
+  DCHECK(nodes_affected_by_inner_viewport_bounds_delta_.empty());
+  for (int i = 0;
+       i < proto.nodes_affected_by_inner_viewport_bounds_delta_size(); i++) {
+    nodes_affected_by_inner_viewport_bounds_delta_.push_back(
+        proto.nodes_affected_by_inner_viewport_bounds_delta(i));
+  }
+
+  DCHECK(nodes_affected_by_outer_viewport_bounds_delta_.empty());
+  for (int i = 0;
+       i < proto.nodes_affected_by_outer_viewport_bounds_delta_size(); i++) {
+    nodes_affected_by_outer_viewport_bounds_delta_.push_back(
+        proto.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::ClipTree* proto) const {
+  DCHECK(!proto->has_property_tree());
+  PropertyTree::ToProtobuf(proto->mutable_property_tree());
+}
+
+void ClipTree::FromProtobuf(const proto::ClipTree& proto) {
+  DCHECK(proto.has_property_tree());
+  PropertyTree::FromProtobuf(proto.property_tree());
+}
+
+void EffectTree::ToProtobuf(proto::EffectTree* proto) const {
+  DCHECK(!proto->has_property_tree());
+  PropertyTree::ToProtobuf(proto->mutable_property_tree());
+}
+
+void EffectTree::FromProtobuf(const proto::EffectTree& proto) {
+  DCHECK(proto.has_property_tree());
+  PropertyTree::FromProtobuf(proto.property_tree());
+}
+
 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
+  // 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);
+  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.
+  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