cc: Stop cache transform invertibility at Layer and LayerImpl

cc/layers/layer.cc

 // Copyright 2010 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.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 60 matching lines @@
       draws_content_(false),
       hide_layer_and_subtree_(false),
       masks_to_bounds_(false),
       contents_opaque_(false),
       double_sided_(true),
       should_flatten_transform_(true),
       use_parent_backface_visibility_(false),
       use_local_transform_for_backface_visibility_(false),
       should_check_backface_visibility_(false),
       force_render_surface_for_testing_(false),
-      transform_is_invertible_(true),
       has_render_surface_(false),
       subtree_property_changed_(false),
       background_color_(0),
       safe_opaque_background_color_(0),
       opacity_(1.f),
       blend_mode_(SkXfermode::kSrcOver_Mode),
       draw_blend_mode_(SkXfermode::kSrcOver_Mode),
       scroll_parent_(nullptr),
       clip_parent_(nullptr),
       replica_layer_(nullptr),
@@ skipping 494 matching lines @@
 }
 
 bool Layer::IsContainerForFixedPositionLayers() const {
   if (!transform_.IsIdentityOrTranslation())
     return true;
   if (parent_ && !parent_->transform_.IsIdentityOrTranslation())
     return true;
   return is_container_for_fixed_position_layers_;
 }
 
-bool Are2dAxisAligned(const gfx::Transform& a,
-                      const gfx::Transform& b,
-                      bool* is_invertible) {
+bool Are2dAxisAligned(const gfx::Transform& a, const gfx::Transform& b) {
   if (a.IsScaleOrTranslation() && b.IsScaleOrTranslation()) {
-    *is_invertible = b.IsInvertible();
     return true;
   }
 
   gfx::Transform inverse(gfx::Transform::kSkipInitialization);
-  *is_invertible = b.GetInverse(&inverse);
-
-  inverse *= a;
-  return inverse.Preserves2dAxisAlignment();
+  if (b.GetInverse(&inverse)) {
+    inverse *= a;
+    return inverse.Preserves2dAxisAlignment();
+  } else {
+    // TODO(weiliangc): Should return false because b is not invertible.
+    return a.Preserves2dAxisAlignment();
+  }
 }
 
 void Layer::SetTransform(const gfx::Transform& transform) {
   DCHECK(IsPropertyChangeAllowed());
   if (transform_ == transform)
     return;
 
   SetSubtreePropertyChanged();
   if (layer_tree_host_) {
     if (TransformNode* transform_node =
             layer_tree_host_->property_trees()->transform_tree.Node(
                 transform_tree_index())) {
       if (transform_node->owner_id == id()) {
         // We need to trigger a rebuild if we could have affected 2d axis
         // alignment. We'll check to see if transform and transform_ are axis
         // align with respect to one another.
-        bool invertible = false;
         bool preserves_2d_axis_alignment =
-            Are2dAxisAligned(transform_, transform, &invertible);
+            Are2dAxisAligned(transform_, transform);
         transform_node->data.local = transform;
         transform_node->data.needs_local_transform_update = true;
         transform_node->data.transform_changed = true;
         layer_tree_host_->property_trees()->transform_tree.set_needs_update(
             true);
         if (preserves_2d_axis_alignment)
           SetNeedsCommitNoRebuild();
         else
           SetNeedsCommit();
         transform_ = transform;
-        transform_is_invertible_ = invertible;
         return;
       }
     }
   }
 
   transform_ = transform;
-  transform_is_invertible_ = transform.IsInvertible();
 
   SetNeedsCommit();
 }
 
 void Layer::SetTransformOrigin(const gfx::Point3F& transform_origin) {
   DCHECK(IsPropertyChangeAllowed());
   if (transform_origin_ == transform_origin)
     return;
   transform_origin_ = transform_origin;
 
@@ skipping 718 matching lines @@
   PointFToProto(position_, base->mutable_position());
   base->set_is_container_for_fixed_position_layers(
       is_container_for_fixed_position_layers_);
   position_constraint_.ToProtobuf(base->mutable_position_constraint());
   base->set_should_flatten_transform(should_flatten_transform_);
   base->set_should_flatten_transform_from_property_tree(
       should_flatten_transform_from_property_tree_);
   base->set_draw_blend_mode(SkXfermodeModeToProto(draw_blend_mode_));
   base->set_use_parent_backface_visibility(use_parent_backface_visibility_);
   TransformToProto(transform_, base->mutable_transform());
-  base->set_transform_is_invertible(transform_is_invertible_);
   base->set_sorting_context_id(sorting_context_id_);
   base->set_num_descendants_that_draw_content(
       num_descendants_that_draw_content_);
 
   base->set_scroll_clip_layer_id(scroll_clip_layer_id_);
   base->set_user_scrollable_horizontal(user_scrollable_horizontal_);
   base->set_user_scrollable_vertical(user_scrollable_vertical_);
 
   int scroll_parent_id = scroll_parent_ ? scroll_parent_->id() : INVALID_ID;
   base->set_scroll_parent_id(scroll_parent_id);
@@ skipping 59 matching lines @@
   position_ = ProtoToPointF(base.position());
   is_container_for_fixed_position_layers_ =
       base.is_container_for_fixed_position_layers();
   position_constraint_.FromProtobuf(base.position_constraint());
   should_flatten_transform_ = base.should_flatten_transform();
   should_flatten_transform_from_property_tree_ =
       base.should_flatten_transform_from_property_tree();
   draw_blend_mode_ = SkXfermodeModeFromProto(base.draw_blend_mode());
   use_parent_backface_visibility_ = base.use_parent_backface_visibility();
   transform_ = ProtoToTransform(base.transform());
-  transform_is_invertible_ = base.transform_is_invertible();
   sorting_context_id_ = base.sorting_context_id();
   num_descendants_that_draw_content_ = base.num_descendants_that_draw_content();
 
   scroll_clip_layer_id_ = base.scroll_clip_layer_id();
   user_scrollable_horizontal_ = base.user_scrollable_horizontal();
   user_scrollable_vertical_ = base.user_scrollable_vertical();
 
   scroll_parent_ = base.scroll_parent_id() == INVALID_ID
                        ? nullptr
                        : layer_tree_host_->LayerById(base.scroll_parent_id());
@@ skipping 134 matching lines @@
         layer_tree_host_->property_trees()->effect_tree.set_needs_update(true);
       }
     }
   }
 }
 
 void Layer::OnTransformAnimated(const gfx::Transform& transform) {
   if (transform_ == transform)
     return;
   transform_ = transform;
-  transform_is_invertible_ = transform.IsInvertible();
   // Changing the transform may change the visible part of this layer, so a new
   // recording may be needed.
   SetNeedsUpdate();
   if (layer_tree_host_) {
     if (TransformNode* node =
             layer_tree_host_->property_trees()->transform_tree.Node(
                 transform_tree_index())) {
       if (node->owner_id == id()) {
         node->data.local = transform;
         node->data.needs_local_transform_update = true;
@@ skipping 130 matching lines @@
       ->data.num_copy_requests_in_subtree;
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, -1);
   return draw_property_utils::ScreenSpaceTransform(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc