Extract subpixel offsets from composited layer transforms when possible.

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 596 matching lines @@
 
   gfx::Transform inverse(gfx::Transform::kSkipInitialization);
   *is_invertible = b.GetInverse(&inverse);
 
   inverse *= a;
   return inverse.Preserves2dAxisAlignment();
 }
 
 void Layer::SetTransform(const gfx::Transform& transform) {
   DCHECK(IsPropertyChangeAllowed());
-  if (transform_ == transform)
+  transform_ = transform;
+
+  if (transform.IsIdentityOr2DTranslation()) {
+    gfx::Vector2dF translate = transform.To2dTranslation();
+    // Am I correct? -vmpstr
+    subpixel_offset_.set_x(translate.x() - std::floor(translate.x()));
+    subpixel_offset_.set_y(translate.y() - std::floor(translate.y()));
+    transform_.Translate(-subpixel_offset_.x(), -subpixel_offset_.y());
+    LOG(ERROR) << "Layer::SetTransform with subpixel: " << this << ": " << subpixel_offset_.ToString() << ": " << transform_.To2dTranslation().ToString();
+  }
+
+  if (transform_ == transform) {
+    LOG(ERROR) << "early out";
     return;
+  }
 
   SetSubtreePropertyChanged();
   if (layer_tree_host_) {
+            LOG(ERROR) << "layer_tree_host_ found";
+
     if (TransformNode* transform_node =
             layer_tree_host_->property_trees()->transform_tree.Node(
                 transform_tree_index())) {
+        LOG(ERROR) << "node found";
       if (transform_node->owner_id == id()) {
+        LOG(ERROR) << "id found";
         // 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);
         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;
       }
     }
+  } else {
+    LOG(ERROR) << "no layer tree host???";
   }
 
-  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 469 matching lines @@
   layer->SetSafeOpaqueBackgroundColor(safe_opaque_background_color_);
   layer->SetBounds(use_paint_properties ? paint_properties_.bounds
                                         : bounds_);
 
 #if defined(NDEBUG)
   if (frame_viewer_instrumentation::IsTracingLayerTreeSnapshots())
     layer->SetDebugInfo(TakeDebugInfo());
 #else
   layer->SetDebugInfo(TakeDebugInfo());
 #endif
-
+  layer->SetSubpixelOffset(subpixel_offset_);
   layer->SetTransformTreeIndex(transform_tree_index());
   layer->SetEffectTreeIndex(effect_tree_index());
   layer->SetClipTreeIndex(clip_tree_index());
   layer->SetScrollTreeIndex(scroll_tree_index());
   layer->set_offset_to_transform_parent(offset_to_transform_parent_);
   layer->SetDoubleSided(double_sided_);
   layer->SetDrawsContent(DrawsContent());
   layer->SetHideLayerAndSubtree(hide_layer_and_subtree_);
   layer->SetHasRenderSurface(has_render_surface_);
   // subtree_property_changed_ is propagated to all descendants while building
@@ skipping 696 matching lines @@
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 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