Raster PictureLayerTiling with fractional translation

cc/tiles/picture_layer_tiling_set.cc

Index: cc/tiles/picture_layer_tiling_set.cc
diff --git a/cc/tiles/picture_layer_tiling_set.cc b/cc/tiles/picture_layer_tiling_set.cc
index c338ea57bf05f8e247f0b4ab276d3e95d84f6968..688d4a23e8ea43745b95f8698569260af2d4cd6f 100644
--- a/cc/tiles/picture_layer_tiling_set.cc
+++ b/cc/tiles/picture_layer_tiling_set.cc
@@ -22,7 +22,8 @@ class LargestToSmallestScaleFunctor {
  public:
   bool operator()(const std::unique_ptr<PictureLayerTiling>& left,
                   const std::unique_ptr<PictureLayerTiling>& right) {
-    return left->contents_scale() > right->contents_scale();
+    return left->contents_transform().pre_scale() >
+           right->contents_transform().pre_scale();
   }
 };
 
@@ -80,11 +81,18 @@ void PictureLayerTilingSet::CopyTilingsAndPropertiesFromPendingTwin(
 
   bool tiling_sort_required = false;
   for (const auto& pending_twin_tiling : pending_twin_set->tilings_) {
-    float contents_scale = pending_twin_tiling->contents_scale();
-    PictureLayerTiling* this_tiling = FindTilingWithScale(contents_scale);
+    ScaleTranslate2d contents_transform =
+        pending_twin_tiling->contents_transform();
+    PictureLayerTiling* this_tiling =
+        FindTilingWithScale(contents_transform.pre_scale());
+    if (this_tiling &&
+        this_tiling->contents_transform() != contents_transform) {
+      Remove(this_tiling);
+      this_tiling = nullptr;
+    }
     if (!this_tiling) {
       std::unique_ptr<PictureLayerTiling> new_tiling(new PictureLayerTiling(
-          tree_, contents_scale, raster_source_, client_));
+          tree_, contents_transform, raster_source_, client_));
       tilings_.push_back(std::move(new_tiling));
       this_tiling = tilings_.back().get();
       tiling_sort_required = true;
@@ -119,7 +127,8 @@ void PictureLayerTilingSet::UpdateTilingsToCurrentRasterSourceForActivation(
   // If the tiling is not shared (FindTilingWithScale returns nullptr), then
   // invalidate tiles and update them to the new raster source.
   for (const auto& tiling : tilings_) {
-    if (pending_twin_set->FindTilingWithScale(tiling->contents_scale()))
+    if (pending_twin_set->FindTilingWithScale(
+            tiling->contents_transform().pre_scale()))
       continue;
 
     tiling->SetRasterSourceAndResize(raster_source);
@@ -222,8 +231,10 @@ void PictureLayerTilingSet::CleanUpTilings(
   std::vector<PictureLayerTiling*> to_remove;
   for (const auto& tiling : tilings_) {
     // Keep all tilings within the min/max scales.
-    if (tiling->contents_scale() >= min_acceptable_high_res_scale &&
-        tiling->contents_scale() <= max_acceptable_high_res_scale) {
+    if (tiling->contents_transform().pre_scale() >=
+            min_acceptable_high_res_scale &&
+        tiling->contents_transform().pre_scale() <=
+            max_acceptable_high_res_scale) {
       continue;
     }
 
@@ -261,18 +272,19 @@ void PictureLayerTilingSet::MarkAllTilingsNonIdeal() {
 }
 
 PictureLayerTiling* PictureLayerTilingSet::AddTiling(
-    float contents_scale,
+    const ScaleTranslate2d& contents_transform,
     scoped_refptr<RasterSource> raster_source) {
   if (!raster_source_)
     raster_source_ = raster_source;
 
   for (size_t i = 0; i < tilings_.size(); ++i) {
-    DCHECK_NE(tilings_[i]->contents_scale(), contents_scale);
+    DCHECK_NE(tilings_[i]->contents_transform().pre_scale(),
+              contents_transform.pre_scale());
     DCHECK_EQ(tilings_[i]->raster_source(), raster_source.get());
   }
 
   tilings_.push_back(base::MakeUnique<PictureLayerTiling>(
-      tree_, contents_scale, raster_source, client_));
+      tree_, contents_transform, raster_source, client_));
   PictureLayerTiling* appended = tilings_.back().get();
   state_since_last_tile_priority_update_.added_tilings = true;
 
@@ -290,7 +302,7 @@ int PictureLayerTilingSet::NumHighResTilings() const {
 PictureLayerTiling* PictureLayerTilingSet::FindTilingWithScale(
     float scale) const {
   for (size_t i = 0; i < tilings_.size(); ++i) {
-    if (tilings_[i]->contents_scale() == scale)
+    if (tilings_[i]->contents_transform().pre_scale() == scale)
       return tilings_[i].get();
   }
   return nullptr;
@@ -312,7 +324,7 @@ void PictureLayerTilingSet::RemoveTilingsBelowScale(float minimum_scale) {
   auto to_remove = std::remove_if(
       tilings_.begin(), tilings_.end(),
       [minimum_scale](const std::unique_ptr<PictureLayerTiling>& tiling) {
-        return tiling->contents_scale() < minimum_scale;
+        return tiling->contents_transform().pre_scale() < minimum_scale;
       });
   tilings_.erase(to_remove, tilings_.end());
 }
@@ -321,7 +333,7 @@ void PictureLayerTilingSet::RemoveTilingsAboveScale(float maximum_scale) {
   auto to_remove = std::remove_if(
       tilings_.begin(), tilings_.end(),
       [maximum_scale](const std::unique_ptr<PictureLayerTiling>& tiling) {
-        return tiling->contents_scale() > maximum_scale;
+        return tiling->contents_transform().pre_scale() > maximum_scale;
       });
   tilings_.erase(to_remove, tilings_.end());
 }
@@ -353,7 +365,7 @@ float PictureLayerTilingSet::GetSnappedContentsScale(
   float snapped_contents_scale = start_scale;
   float snapped_ratio = snap_to_existing_tiling_ratio;
   for (const auto& tiling : tilings_) {
-    float tiling_contents_scale = tiling->contents_scale();
+    float tiling_contents_scale = tiling->contents_transform().pre_scale();
     float ratio = LargerRatio(tiling_contents_scale, start_scale);
     if (ratio < snapped_ratio) {
       snapped_contents_scale = tiling_contents_scale;
@@ -367,7 +379,7 @@ float PictureLayerTilingSet::GetMaximumContentsScale() const {
   if (tilings_.empty())
     return 0.f;
   // The first tiling has the largest contents scale.
-  return tilings_[0]->contents_scale();
+  return tilings_[0]->contents_transform().pre_scale();
 }
 
 bool PictureLayerTilingSet::TilingsNeedUpdate(
@@ -554,7 +566,7 @@ PictureLayerTilingSet::CoverageIterator::CoverageIterator(
   size_t tilings_size = set_->tilings_.size();
   for (ideal_tiling_ = 0; ideal_tiling_ < tilings_size; ++ideal_tiling_) {
     PictureLayerTiling* tiling = set_->tilings_[ideal_tiling_].get();
-    if (tiling->contents_scale() < ideal_contents_scale_) {
+    if (tiling->contents_transform().pre_scale() < ideal_contents_scale_) {
       if (ideal_tiling_ > 0)
         ideal_tiling_--;
       break;