Raster PictureLayerTiling with fractional translation

cc/layers/picture_layer.cc

 // Copyright 2012 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/picture_layer.h"
 
 #include "base/auto_reset.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/picture_layer_impl.h"
 #include "cc/layers/recording_source.h"
 #include "cc/paint/paint_record.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
+#include "cc/trees/transform_node.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace cc {
 
 PictureLayer::PictureLayerInputs::PictureLayerInputs() = default;
 
 PictureLayer::PictureLayerInputs::~PictureLayerInputs() = default;
 
 scoped_refptr<PictureLayer> PictureLayer::Create(ContentLayerClient* client) {
   return make_scoped_refptr(new PictureLayer(client));
@@ skipping 22 matching lines @@
 
 void PictureLayer::PushPropertiesTo(LayerImpl* base_layer) {
   Layer::PushPropertiesTo(base_layer);
   TRACE_EVENT0("cc", "PictureLayer::PushPropertiesTo");
   PictureLayerImpl* layer_impl = static_cast<PictureLayerImpl*>(base_layer);
   // TODO(danakj): Make mask_type_ a constructor parameter for PictureLayer.
   DCHECK_EQ(layer_impl->mask_type(), mask_type());
   DropRecordingSourceContentIfInvalid();
 
   layer_impl->SetNearestNeighbor(picture_layer_inputs_.nearest_neighbor);
+  layer_impl->SetUseTransformedRasterization(
+      ShouldUseTransformedRasterization());
 
   // Preserve lcd text settings from the current raster source.
   bool can_use_lcd_text = layer_impl->RasterSourceUsesLCDText();
   scoped_refptr<RasterSource> raster_source =
       recording_source_->CreateRasterSource(can_use_lcd_text);
   layer_impl->set_gpu_raster_max_texture_size(
       layer_tree_host()->device_viewport_size());
   layer_impl->UpdateRasterSource(std::move(raster_source),
                                  &last_updated_invalidation_, nullptr);
   DCHECK(last_updated_invalidation_.IsEmpty());
@@ skipping 26 matching lines @@
     recording_source_->SetNeedsDisplayRect(layer_rect);
   Layer::SetNeedsDisplayRect(layer_rect);
 }
 
 bool PictureLayer::Update() {
   update_source_frame_number_ = layer_tree_host()->SourceFrameNumber();
   bool updated = Layer::Update();
 
   gfx::Size layer_size = paint_properties().bounds;
 
-  recording_source_->SetBackgroundColor(SafeOpaqueBackgroundColor());
+  // When transformed rasterization is used, we try to match the rendering
+  // without a compositing layer, thus we don't over draw background to fill
+  // snapped edges.
+  SkColor background_color = ShouldUseTransformedRasterization()
+                                 ? SK_ColorTRANSPARENT
+                                 : SafeOpaqueBackgroundColor();
+  recording_source_->SetBackgroundColor(background_color);
   recording_source_->SetRequiresClear(
       !contents_opaque() &&
       !picture_layer_inputs_.client->FillsBoundsCompletely());
 
   TRACE_EVENT1("cc", "PictureLayer::Update", "source_frame_number",
                layer_tree_host()->SourceFrameNumber());
   devtools_instrumentation::ScopedLayerTreeTask update_layer(
       devtools_instrumentation::kUpdateLayer, id(), layer_tree_host()->GetId());
 
   // UpdateAndExpandInvalidation will give us an invalidation that covers
@@ skipping 77 matching lines @@
 }
 
 void PictureLayer::SetNearestNeighbor(bool nearest_neighbor) {
   if (picture_layer_inputs_.nearest_neighbor == nearest_neighbor)
     return;
 
   picture_layer_inputs_.nearest_neighbor = nearest_neighbor;
   SetNeedsCommit();
 }
 
+void PictureLayer::SetAllowTransformedRasterization(bool allowed) {
+  if (picture_layer_inputs_.allow_transformed_rasterization == allowed)
+    return;
+
+  picture_layer_inputs_.allow_transformed_rasterization = allowed;
+  SetNeedsCommit();
+}
+
 bool PictureLayer::HasDrawableContent() const {
   return picture_layer_inputs_.client && Layer::HasDrawableContent();
 }
 
 void PictureLayer::RunMicroBenchmark(MicroBenchmark* benchmark) {
   benchmark->RunOnLayer(this);
 }
 
 void PictureLayer::DropRecordingSourceContentIfInvalid() {
   int source_frame_number = layer_tree_host()->SourceFrameNumber();
@@ skipping 15 matching lines @@
     // Update may not get called for the layer (if it's not in the viewport
     // for example), even though it has resized making the recording source no
     // longer valid. In this case just destroy the recording source.
     recording_source_->SetEmptyBounds();
     picture_layer_inputs_.recorded_viewport = gfx::Rect();
     picture_layer_inputs_.display_list = nullptr;
     picture_layer_inputs_.painter_reported_memory_usage = 0;
   }
 }
 
+bool PictureLayer::ShouldUseTransformedRasterization() const {
+  if (!picture_layer_inputs_.allow_transformed_rasterization)
+    return false;
+
+  const TransformTree& transform_tree =
+      layer_tree_host()->property_trees()->transform_tree;
+  DCHECK(!transform_tree.needs_update());
+  if (transform_tree.Node(transform_tree_index())
+          ->to_screen_is_potentially_animated)
+    return false;
+
+  const gfx::Transform& to_screen =
+      transform_tree.ToScreen(transform_tree_index());
+  if (!to_screen.IsScaleOrTranslation())
+    return false;
+
+  float origin_x =
+      to_screen.matrix().getFloat(0, 3) + offset_to_transform_parent().x();
+  float origin_y =
+      to_screen.matrix().getFloat(1, 3) + offset_to_transform_parent().y();
+  if (origin_x - floorf(origin_x) == 0.f && origin_y - floorf(origin_y) == 0.f)
+    return false;
+
+  return true;
+}
+
 const DisplayItemList* PictureLayer::GetDisplayItemList() {
   return picture_layer_inputs_.display_list.get();
 }
 
 }  // namespace cc