[1/5] Pass transformed rasterization policy from Blink

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/blimp/client_picture_cache.h"
 #include "cc/blimp/engine_picture_cache.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/picture_layer_impl.h"
 #include "cc/playback/recording_source.h"
 #include "cc/proto/cc_conversions.h"
 #include "cc/proto/gfx_conversions.h"
 #include "cc/proto/layer.pb.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
+#include "cc/trees/transform_node.h"
 #include "third_party/skia/include/core/SkPictureRecorder.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) {
@@ skipping 23 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 is_mask_ a constructor parameter for PictureLayer.
   DCHECK_EQ(layer_impl->is_mask(), is_mask_);
   DropRecordingSourceContentIfInvalid();
 
   layer_impl->SetNearestNeighbor(picture_layer_inputs_.nearest_neighbor);
+  layer_impl->SetUseTransformedRasterization(UseTransformedRasterization());
 
   // 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(
       GetLayerTree()->device_viewport_size());
   layer_impl->UpdateRasterSource(raster_source, &last_updated_invalidation_,
                                  nullptr);
   DCHECK(last_updated_invalidation_.IsEmpty());
@@ skipping 119 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::SetTypeForProtoSerialization(proto::LayerNode* proto) const {
   proto->set_type(proto::LayerNode::PICTURE_LAYER);
 }
 
 void PictureLayer::ToLayerPropertiesProto(proto::LayerProperties* proto) {
   DCHECK(GetLayerTree());
@@ skipping 44 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::UseTransformedRasterization() const {
+  if (!picture_layer_inputs_.allow_transformed_rasterization)
+    return false;
+
+  const TransformTree &transform_tree = GetLayerTree()->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