cc: Generate tilings at other scales for impl-side painting

cc/picture_layer_tiling_set.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/picture_layer_tiling_set.h"
 
 namespace cc {
 
+namespace {
+
+class LargestToSmallestScaleFunctor {
+ public:
+  bool operator() (PictureLayerTiling* left, PictureLayerTiling* right) {
+    return left->contents_scale() > right->contents_scale();
+  }
+};
+
+}  // namespace
+
+
 PictureLayerTilingSet::PictureLayerTilingSet(
     PictureLayerTilingClient * client)
     : client_(client) {
 }
 
 PictureLayerTilingSet::~PictureLayerTilingSet() {
 }
 
 void PictureLayerTilingSet::CloneAll(
     const PictureLayerTilingSet& other,
@@ skipping 11 matching lines @@
 void PictureLayerTilingSet::Clone(
     const PictureLayerTiling* tiling,
     const Region& invalidation) {
 
   for (size_t i = 0; i < tilings_.size(); ++i)
     DCHECK_NE(tilings_[i]->contents_scale(), tiling->contents_scale());
 
   tilings_.append(tiling->Clone());
   tilings_.last()->SetClient(client_);
   tilings_.last()->Invalidate(invalidation);
+
+  sort(tilings_.begin(), tilings_.end(), LargestToSmallestScaleFunctor());
 }
 
 void PictureLayerTilingSet::SetLayerBounds(gfx::Size layer_bounds) {
   if (layer_bounds_ == layer_bounds)
     return;
   layer_bounds_ = layer_bounds;
   for (size_t i = 0; i < tilings_.size(); ++i)
     tilings_[i]->SetLayerBounds(layer_bounds);
 }
 
 gfx::Size PictureLayerTilingSet::LayerBounds() const {
   return layer_bounds_;
 }
 
-const PictureLayerTiling* PictureLayerTilingSet::AddTiling(
+PictureLayerTiling* PictureLayerTilingSet::AddTiling(
     float contents_scale,
     gfx::Size tile_size) {
   tilings_.append(PictureLayerTiling::Create(contents_scale, tile_size));
-  tilings_.last()->SetClient(client_);
-  tilings_.last()->SetLayerBounds(layer_bounds_);
-  return tilings_.last();
+  PictureLayerTiling* appended = tilings_.last();
+  appended->SetClient(client_);
+  appended->SetLayerBounds(layer_bounds_);
+
+  sort(tilings_.begin(), tilings_.end(), LargestToSmallestScaleFunctor());
+  return appended;
+}
+
+void PictureLayerTilingSet::RemoveAll() {
+  tilings_.clear();
+}
+
+void PictureLayerTilingSet::Remove(PictureLayerTiling* tiling) {
+  for (size_t i = 0; i < tilings_.size(); ++i) {
+    if (tilings_[i] == tiling) {
+      tilings_.remove(i);
+      return;
+    }
+  }
 }
 
 void PictureLayerTilingSet::Reset() {
   for (size_t i = 0; i < tilings_.size(); ++i)
     tilings_[i]->Reset();
 }
 
-PictureLayerTilingSet::Iterator::Iterator(const PictureLayerTilingSet* set,
-                                          float contents_scale,
-                                          gfx::Rect content_rect)
+PictureLayerTilingSet::Iterator::Iterator(
+    const PictureLayerTilingSet* set,
+    float contents_scale,
+    gfx::Rect content_rect,
+    float ideal_contents_scale)
     : set_(set),
       contents_scale_(contents_scale),
+      ideal_contents_scale_(ideal_contents_scale),
       current_tiling_(-1) {
   missing_region_.Union(content_rect);
+
+  for (ideal_tiling_ = 0;
+       ideal_tiling_ < set_->tilings_.size();
+       ++ideal_tiling_) {
+    PictureLayerTiling* tiling = set_->tilings_[ideal_tiling_];
+    if (tiling->contents_scale() < ideal_contents_scale_) {
+      if (ideal_tiling_ > 0)
+        ideal_tiling_--;
+      break;
+    }
+  }
+
   ++(*this);
 }
 
 PictureLayerTilingSet::Iterator::~Iterator() {
 }
 
 gfx::Rect PictureLayerTilingSet::Iterator::geometry_rect() const {
   if (!tiling_iter_) {
     if (!region_iter_.has_rect())
       return gfx::Rect();
@@ skipping 19 matching lines @@
     return NULL;
   return *tiling_iter_;
 }
 
 Tile* PictureLayerTilingSet::Iterator::operator*() const {
   if (!tiling_iter_)
     return NULL;
   return *tiling_iter_;
 }
 
+PictureLayerTiling* PictureLayerTilingSet::Iterator::CurrentTiling() {
+  if (current_tiling_ < 0 || current_tiling_ >= set_->tilings_.size())
+    return NULL;
+  return set_->tilings_[current_tiling_];
+}
+
+int PictureLayerTilingSet::Iterator::NextTiling() const {
+  // Prefer hi-res tiles, but prefer the least hi-res if bigger than ideal,
+  // since it won't add any additional fidelity on screen.
+  if (current_tiling_ < 0)
+    return ideal_tiling_;
+  else if (current_tiling_ > ideal_tiling_)
+    return current_tiling_ + 1;
+  else if (current_tiling_)
+    return current_tiling_ - 1;
+  else
+    return ideal_tiling_ + 1;
+}
+
 PictureLayerTilingSet::Iterator& PictureLayerTilingSet::Iterator::operator++() {
   bool first_time = current_tiling_ < 0;
 
   if (!*this && !first_time)
     return *this;
 
   if (tiling_iter_)
     ++tiling_iter_;
 
   // Loop until we find a valid place to stop.
   while (true) {
     while (tiling_iter_ && (!*tiling_iter_ || !tiling_iter_->GetResourceId())) {
       missing_region_.Union(tiling_iter_.geometry_rect());
       ++tiling_iter_;
     }
     if (tiling_iter_)
       return *this;
 
     // If the set of current rects for this tiling is done, go to the next
     // tiling and set up to iterate through all of the remaining holes.
     // This will also happen the first time through the loop.
     if (!region_iter_.has_rect()) {
-      current_tiling_++;
+      current_tiling_ = NextTiling();
       current_region_.Swap(missing_region_);
       missing_region_.Clear();
       region_iter_ = Region::Iterator(current_region_);
 
       // All done and all filled.
       if (!region_iter_.has_rect()) {
         current_tiling_ = set_->tilings_.size();
         return *this;
       }
 
@@ skipping 41 matching lines @@
         device_viewport,
         layer_content_scale_x,
         layer_content_scale_y,
         last_screen_transform,
         current_screen_transform,
         time_delta);
   }
 }
 
 }  // namespace cc