cc/resources/picture_layer_tiling_set.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/resources/picture_layer_tiling_set.h"
   6
   7 #include <limits>
   8 #include <set>
   9 #include <vector>
  10
  11 namespace cc {
  12
  13 namespace {
  14
  15 class LargestToSmallestScaleFunctor {
  16  public:
  17   bool operator() (PictureLayerTiling* left, PictureLayerTiling* right) {
  18     return left->contents_scale() > right->contents_scale();
  19   }
  20 };
  21
  22 inline float LargerRatio(float float1, float float2) {
  23   DCHECK_GT(float1, 0.f);
  24   DCHECK_GT(float2, 0.f);
  25   return float1 > float2 ? float1 / float2 : float2 / float1;
  26 }
  27
  28 }  // namespace
  29
  30 // static
  31 scoped_ptr<PictureLayerTilingSet> PictureLayerTilingSet::Create(
  32     PictureLayerTilingClient* client,
  33     size_t max_tiles_for_interest_area,
  34     float skewport_target_time_in_seconds,
  35     int skewport_extrapolation_limit_in_content_pixels) {
  36   return make_scoped_ptr(new PictureLayerTilingSet(
  37       client, max_tiles_for_interest_area, skewport_target_time_in_seconds,
  38       skewport_extrapolation_limit_in_content_pixels));
  39 }
  40
  41 PictureLayerTilingSet::PictureLayerTilingSet(
  42     PictureLayerTilingClient* client,
  43     size_t max_tiles_for_interest_area,
  44     float skewport_target_time_in_seconds,
  45     int skewport_extrapolation_limit_in_content_pixels)
  46     : max_tiles_for_interest_area_(max_tiles_for_interest_area),
  47       skewport_target_time_in_seconds_(skewport_target_time_in_seconds),
  48       skewport_extrapolation_limit_in_content_pixels_(
  49           skewport_extrapolation_limit_in_content_pixels),
  50       client_(client) {
  51 }
  52
  53 PictureLayerTilingSet::~PictureLayerTilingSet() {
  54 }
  55
  56 void PictureLayerTilingSet::UpdateTilingsToCurrentRasterSource(
  57     scoped_refptr<RasterSource> raster_source,
  58     const PictureLayerTilingSet* twin_set,
  59     const Region& layer_invalidation,
  60     float minimum_contents_scale,
  61     float maximum_contents_scale) {
  62   RemoveTilingsBelowScale(minimum_contents_scale);
  63   RemoveTilingsAboveScale(maximum_contents_scale);
  64
  65   // Copy over tilings that are shared with the |twin_set| tiling set (if it
  66   // exists).
  67   if (twin_set) {
  68     for (PictureLayerTiling* twin_tiling : twin_set->tilings_) {
  69       float contents_scale = twin_tiling->contents_scale();
  70       DCHECK_GE(contents_scale, minimum_contents_scale);
  71       DCHECK_LE(contents_scale, maximum_contents_scale);
  72
  73       PictureLayerTiling* this_tiling = FindTilingWithScale(contents_scale);
  74       if (!this_tiling) {
  75         scoped_ptr<PictureLayerTiling> new_tiling = PictureLayerTiling::Create(
  76             contents_scale, raster_source, client_,
  77             max_tiles_for_interest_area_, skewport_target_time_in_seconds_,
  78             skewport_extrapolation_limit_in_content_pixels_);
  79         tilings_.push_back(new_tiling.Pass());
  80         this_tiling = tilings_.back();
  81       }
  82       this_tiling->CloneTilesAndPropertiesFrom(*twin_tiling);
  83     }
  84   }
  85
  86   // For unshared tilings, invalidate tiles and update them to the new raster
  87   // source.
  88   for (PictureLayerTiling* tiling : tilings_) {
  89     if (twin_set && twin_set->FindTilingWithScale(tiling->contents_scale()))
  90       continue;
  91
  92     tiling->SetRasterSourceAndResize(raster_source);
  93     tiling->Invalidate(layer_invalidation);
  94     tiling->SetRasterSourceOnTiles();
  95     // This is needed for cases where the live tiles rect didn't change but
  96     // recordings exist in the raster source that did not exist on the last
  97     // raster source.
  98     tiling->CreateMissingTilesInLiveTilesRect();
  99
 100     // If |twin_set| is present, use the resolutions from there. Otherwise leave
 101     // all resolutions as they are.
 102     if (twin_set)
 103       tiling->set_resolution(NON_IDEAL_RESOLUTION);
 104   }
 105
 106   tilings_.sort(LargestToSmallestScaleFunctor());
 107
 108 #if DCHECK_IS_ON()
 109   for (PictureLayerTiling* tiling : tilings_) {
 110     DCHECK(tiling->tile_size() ==
 111            client_->CalculateTileSize(tiling->tiling_size()))
 112         << "tile_size: " << tiling->tile_size().ToString()
 113         << " tiling_size: " << tiling->tiling_size().ToString()
 114         << " CalculateTileSize: "
 115         << client_->CalculateTileSize(tiling->tiling_size()).ToString();
 116   }
 117
 118   if (!tilings_.empty()) {
 119     size_t num_high_res = std::count_if(tilings_.begin(), tilings_.end(),
 120                                         [](PictureLayerTiling* tiling) {
 121       return tiling->resolution() == HIGH_RESOLUTION;
 122     });
 123     DCHECK_LE(num_high_res, 1u);
 124     // When commiting from the main thread the high res tiling may get dropped,
 125     // but when cloning to the active tree, there should always be one.
 126     if (twin_set)
 127       DCHECK_EQ(1u, num_high_res);
 128   }
 129 #endif
 130 }
 131
 132 void PictureLayerTilingSet::CleanUpTilings(
 133     float min_acceptable_high_res_scale,
 134     float max_acceptable_high_res_scale,
 135     const std::vector<PictureLayerTiling*>& needed_tilings,
 136     bool should_have_low_res,
 137     PictureLayerTilingSet* twin_set,
 138     PictureLayerTilingSet* recycled_twin_set) {
 139   float twin_low_res_scale = 0.f;
 140   if (twin_set) {
 141     PictureLayerTiling* tiling =
 142         twin_set->FindTilingWithResolution(LOW_RESOLUTION);
 143     if (tiling)
 144       twin_low_res_scale = tiling->contents_scale();
 145   }
 146
 147   std::vector<PictureLayerTiling*> to_remove;
 148   for (auto* tiling : tilings_) {
 149     // Keep all tilings within the min/max scales.
 150     if (tiling->contents_scale() >= min_acceptable_high_res_scale &&
 151         tiling->contents_scale() <= max_acceptable_high_res_scale) {
 152       continue;
 153     }
 154
 155     // Keep low resolution tilings, if the tiling set should have them.
 156     if (should_have_low_res &&
 157         (tiling->resolution() == LOW_RESOLUTION ||
 158          tiling->contents_scale() == twin_low_res_scale)) {
 159       continue;
 160     }
 161
 162     // Don't remove tilings that are required.
 163     if (std::find(needed_tilings.begin(), needed_tilings.end(), tiling) !=
 164         needed_tilings.end()) {
 165       continue;
 166     }
 167
 168     to_remove.push_back(tiling);
 169   }
 170
 171   for (auto* tiling : to_remove) {
 172     PictureLayerTiling* recycled_twin_tiling =
 173         recycled_twin_set
 174             ? recycled_twin_set->FindTilingWithScale(tiling->contents_scale())
 175             : nullptr;
 176     // Remove the tiling from the recycle tree. Note that we ignore resolution,
 177     // since we don't need to maintain high/low res on the recycle set.
 178     if (recycled_twin_tiling)
 179       recycled_twin_set->Remove(recycled_twin_tiling);
 180
 181     DCHECK_NE(HIGH_RESOLUTION, tiling->resolution());
 182     Remove(tiling);
 183   }
 184 }
 185
 186 void PictureLayerTilingSet::RemoveNonIdealTilings() {
 187   auto to_remove = tilings_.remove_if([](PictureLayerTiling* t) {
 188     return t->resolution() == NON_IDEAL_RESOLUTION;
 189   });
 190   tilings_.erase(to_remove, tilings_.end());
 191 }
 192
 193 void PictureLayerTilingSet::MarkAllTilingsNonIdeal() {
 194   for (auto* tiling : tilings_)
 195     tiling->set_resolution(NON_IDEAL_RESOLUTION);
 196 }
 197
 198 PictureLayerTiling* PictureLayerTilingSet::AddTiling(
 199     float contents_scale,
 200     scoped_refptr<RasterSource> raster_source) {
 201   for (size_t i = 0; i < tilings_.size(); ++i) {
 202     DCHECK_NE(tilings_[i]->contents_scale(), contents_scale);
 203     DCHECK_EQ(tilings_[i]->raster_source(), raster_source.get());
 204   }
 205
 206   tilings_.push_back(PictureLayerTiling::Create(
 207       contents_scale, raster_source, client_, max_tiles_for_interest_area_,
 208       skewport_target_time_in_seconds_,
 209       skewport_extrapolation_limit_in_content_pixels_));
 210   PictureLayerTiling* appended = tilings_.back();
 211
 212   tilings_.sort(LargestToSmallestScaleFunctor());
 213   return appended;
 214 }
 215
 216 int PictureLayerTilingSet::NumHighResTilings() const {
 217   int num_high_res = 0;
 218   for (size_t i = 0; i < tilings_.size(); ++i) {
 219     if (tilings_[i]->resolution() == HIGH_RESOLUTION)
 220       num_high_res++;
 221   }
 222   return num_high_res;
 223 }
 224
 225 PictureLayerTiling* PictureLayerTilingSet::FindTilingWithScale(
 226     float scale) const {
 227   for (size_t i = 0; i < tilings_.size(); ++i) {
 228     if (tilings_[i]->contents_scale() == scale)
 229       return tilings_[i];
 230   }
 231   return NULL;
 232 }
 233
 234 PictureLayerTiling* PictureLayerTilingSet::FindTilingWithResolution(
 235     TileResolution resolution) const {
 236   auto iter = std::find_if(tilings_.begin(), tilings_.end(),
 237                            [resolution](const PictureLayerTiling* tiling) {
 238     return tiling->resolution() == resolution;
 239   });
 240   if (iter == tilings_.end())
 241     return NULL;
 242   return *iter;
 243 }
 244
 245 void PictureLayerTilingSet::RemoveTilingsBelowScale(float minimum_scale) {
 246   auto to_remove =
 247       tilings_.remove_if([minimum_scale](PictureLayerTiling* tiling) {
 248         return tiling->contents_scale() < minimum_scale;
 249       });
 250   tilings_.erase(to_remove, tilings_.end());
 251 }
 252
 253 void PictureLayerTilingSet::RemoveTilingsAboveScale(float maximum_scale) {
 254   auto to_remove =
 255       tilings_.remove_if([maximum_scale](PictureLayerTiling* tiling) {
 256         return tiling->contents_scale() > maximum_scale;
 257       });
 258   tilings_.erase(to_remove, tilings_.end());
 259 }
 260
 261 void PictureLayerTilingSet::RemoveAllTilings() {
 262   tilings_.clear();
 263 }
 264
 265 void PictureLayerTilingSet::Remove(PictureLayerTiling* tiling) {
 266   ScopedPtrVector<PictureLayerTiling>::iterator iter =
 267     std::find(tilings_.begin(), tilings_.end(), tiling);
 268   if (iter == tilings_.end())
 269     return;
 270   tilings_.erase(iter);
 271 }
 272
 273 void PictureLayerTilingSet::RemoveAllTiles() {
 274   for (size_t i = 0; i < tilings_.size(); ++i)
 275     tilings_[i]->Reset();
 276 }
 277
 278 float PictureLayerTilingSet::GetSnappedContentsScale(
 279     float start_scale,
 280     float snap_to_existing_tiling_ratio) const {
 281   // If a tiling exists within the max snapping ratio, snap to its scale.
 282   float snapped_contents_scale = start_scale;
 283   float snapped_ratio = snap_to_existing_tiling_ratio;
 284   for (const auto* tiling : tilings_) {
 285     float tiling_contents_scale = tiling->contents_scale();
 286     float ratio = LargerRatio(tiling_contents_scale, start_scale);
 287     if (ratio < snapped_ratio) {
 288       snapped_contents_scale = tiling_contents_scale;
 289       snapped_ratio = ratio;
 290     }
 291   }
 292   return snapped_contents_scale;
 293 }
 294
 295 float PictureLayerTilingSet::GetMaximumContentsScale() const {
 296   if (tilings_.empty())
 297     return 0.f;
 298   // The first tiling has the largest contents scale.
 299   return tilings_[0]->contents_scale();
 300 }
 301
 302 bool PictureLayerTilingSet::UpdateTilePriorities(
 303     const gfx::Rect& required_rect_in_layer_space,
 304     float ideal_contents_scale,
 305     double current_frame_time_in_seconds,
 306     const Occlusion& occlusion_in_layer_space,
 307     bool can_require_tiles_for_activation) {
 308   bool updated = false;
 309   for (auto* tiling : tilings_) {
 310     tiling->set_can_require_tiles_for_activation(
 311         can_require_tiles_for_activation);
 312     updated |= tiling->ComputeTilePriorityRects(
 313         required_rect_in_layer_space, ideal_contents_scale,
 314         current_frame_time_in_seconds, occlusion_in_layer_space);
 315   }
 316   return updated;
 317 }
 318
 319 void PictureLayerTilingSet::GetAllTilesForTracing(
 320     std::set<const Tile*>* tiles) const {
 321   for (auto* tiling : tilings_)
 322     tiling->GetAllTilesForTracing(tiles);
 323 }
 324
 325 PictureLayerTilingSet::CoverageIterator::CoverageIterator(
 326     const PictureLayerTilingSet* set,
 327     float contents_scale,
 328     const gfx::Rect& content_rect,
 329     float ideal_contents_scale)
 330     : set_(set),
 331       contents_scale_(contents_scale),
 332       ideal_contents_scale_(ideal_contents_scale),
 333       current_tiling_(-1) {
 334   missing_region_.Union(content_rect);
 335
 336   for (ideal_tiling_ = 0;
 337        static_cast<size_t>(ideal_tiling_) < set_->tilings_.size();
 338        ++ideal_tiling_) {
 339     PictureLayerTiling* tiling = set_->tilings_[ideal_tiling_];
 340     if (tiling->contents_scale() < ideal_contents_scale_) {
 341       if (ideal_tiling_ > 0)
 342         ideal_tiling_--;
 343       break;
 344     }
 345   }
 346
 347   DCHECK_LE(set_->tilings_.size(),
 348             static_cast<size_t>(std::numeric_limits<int>::max()));
 349
 350   int num_tilings = set_->tilings_.size();
 351   if (ideal_tiling_ == num_tilings && ideal_tiling_ > 0)
 352     ideal_tiling_--;
 353
 354   ++(*this);
 355 }
 356
 357 PictureLayerTilingSet::CoverageIterator::~CoverageIterator() {
 358 }
 359
 360 gfx::Rect PictureLayerTilingSet::CoverageIterator::geometry_rect() const {
 361   if (!tiling_iter_) {
 362     if (!region_iter_.has_rect())
 363       return gfx::Rect();
 364     return region_iter_.rect();
 365   }
 366   return tiling_iter_.geometry_rect();
 367 }
 368
 369 gfx::RectF PictureLayerTilingSet::CoverageIterator::texture_rect() const {
 370   if (!tiling_iter_)
 371     return gfx::RectF();
 372   return tiling_iter_.texture_rect();
 373 }
 374
 375 Tile* PictureLayerTilingSet::CoverageIterator::operator->() const {
 376   if (!tiling_iter_)
 377     return NULL;
 378   return *tiling_iter_;
 379 }
 380
 381 Tile* PictureLayerTilingSet::CoverageIterator::operator*() const {
 382   if (!tiling_iter_)
 383     return NULL;
 384   return *tiling_iter_;
 385 }
 386
 387 TileResolution PictureLayerTilingSet::CoverageIterator::resolution() const {
 388   const PictureLayerTiling* tiling = CurrentTiling();
 389   DCHECK(tiling);
 390   return tiling->resolution();
 391 }
 392
 393 PictureLayerTiling* PictureLayerTilingSet::CoverageIterator::CurrentTiling()
 394     const {
 395   if (current_tiling_ < 0)
 396     return NULL;
 397   if (static_cast<size_t>(current_tiling_) >= set_->tilings_.size())
 398     return NULL;
 399   return set_->tilings_[current_tiling_];
 400 }
 401
 402 int PictureLayerTilingSet::CoverageIterator::NextTiling() const {
 403   // Order returned by this method is:
 404   // 1. Ideal tiling index
 405   // 2. Tiling index < Ideal in decreasing order (higher res than ideal)
 406   // 3. Tiling index > Ideal in increasing order (lower res than ideal)
 407   // 4. Tiling index > tilings.size() (invalid index)
 408   if (current_tiling_ < 0)
 409     return ideal_tiling_;
 410   else if (current_tiling_ > ideal_tiling_)
 411     return current_tiling_ + 1;
 412   else if (current_tiling_)
 413     return current_tiling_ - 1;
 414   else
 415     return ideal_tiling_ + 1;
 416 }
 417
 418 PictureLayerTilingSet::CoverageIterator&
 419 PictureLayerTilingSet::CoverageIterator::operator++() {
 420   bool first_time = current_tiling_ < 0;
 421
 422   if (!*this && !first_time)
 423     return *this;
 424
 425   if (tiling_iter_)
 426     ++tiling_iter_;
 427
 428   // Loop until we find a valid place to stop.
 429   while (true) {
 430     while (tiling_iter_ &&
 431            (!*tiling_iter_ || !tiling_iter_->IsReadyToDraw())) {
 432       missing_region_.Union(tiling_iter_.geometry_rect());
 433       ++tiling_iter_;
 434     }
 435     if (tiling_iter_)
 436       return *this;
 437
 438     // If the set of current rects for this tiling is done, go to the next
 439     // tiling and set up to iterate through all of the remaining holes.
 440     // This will also happen the first time through the loop.
 441     if (!region_iter_.has_rect()) {
 442       current_tiling_ = NextTiling();
 443       current_region_.Swap(&missing_region_);
 444       missing_region_.Clear();
 445       region_iter_ = Region::Iterator(current_region_);
 446
 447       // All done and all filled.
 448       if (!region_iter_.has_rect()) {
 449         current_tiling_ = set_->tilings_.size();
 450         return *this;
 451       }
 452
 453       // No more valid tiles, return this checkerboard rect.
 454       if (current_tiling_ >= static_cast<int>(set_->tilings_.size()))
 455         return *this;
 456     }
 457
 458     // Pop a rect off.  If there are no more tilings, then these will be
 459     // treated as geometry with null tiles that the caller can checkerboard.
 460     gfx::Rect last_rect = region_iter_.rect();
 461     region_iter_.next();
 462
 463     // Done, found next checkerboard rect to return.
 464     if (current_tiling_ >= static_cast<int>(set_->tilings_.size()))
 465       return *this;
 466
 467     // Construct a new iterator for the next tiling, but we need to loop
 468     // again until we get to a valid one.
 469     tiling_iter_ = PictureLayerTiling::CoverageIterator(
 470         set_->tilings_[current_tiling_],
 471         contents_scale_,
 472         last_rect);
 473   }
 474
 475   return *this;
 476 }
 477
 478 PictureLayerTilingSet::CoverageIterator::operator bool() const {
 479   return current_tiling_ < static_cast<int>(set_->tilings_.size()) ||
 480       region_iter_.has_rect();
 481 }
 482
 483 void PictureLayerTilingSet::AsValueInto(base::debug::TracedValue* state) const {
 484   for (size_t i = 0; i < tilings_.size(); ++i) {
 485     state->BeginDictionary();
 486     tilings_[i]->AsValueInto(state);
 487     state->EndDictionary();
 488   }
 489 }
 490
 491 size_t PictureLayerTilingSet::GPUMemoryUsageInBytes() const {
 492   size_t amount = 0;
 493   for (size_t i = 0; i < tilings_.size(); ++i)
 494     amount += tilings_[i]->GPUMemoryUsageInBytes();
 495   return amount;
 496 }
 497
 498 PictureLayerTilingSet::TilingRange PictureLayerTilingSet::GetTilingRange(
 499     TilingRangeType type) const {
 500   // Doesn't seem to be the case right now but if it ever becomes a performance
 501   // problem to compute these ranges each time this function is called, we can
 502   // compute them only when the tiling set has changed instead.
 503   TilingRange high_res_range(0, 0);
 504   TilingRange low_res_range(tilings_.size(), tilings_.size());
 505   for (size_t i = 0; i < tilings_.size(); ++i) {
 506     const PictureLayerTiling* tiling = tilings_[i];
 507     if (tiling->resolution() == HIGH_RESOLUTION)
 508       high_res_range = TilingRange(i, i + 1);
 509     if (tiling->resolution() == LOW_RESOLUTION)
 510       low_res_range = TilingRange(i, i + 1);
 511   }
 512
 513   TilingRange range(0, 0);
 514   switch (type) {
 515     case HIGHER_THAN_HIGH_RES:
 516       range = TilingRange(0, high_res_range.start);
 517       break;
 518     case HIGH_RES:
 519       range = high_res_range;
 520       break;
 521     case BETWEEN_HIGH_AND_LOW_RES:
 522       // TODO(vmpstr): This code assumes that high res tiling will come before
 523       // low res tiling, however there are cases where this assumption is
 524       // violated. As a result, it's better to be safe in these situations,
 525       // since otherwise we can end up accessing a tiling that doesn't exist.
 526       // See crbug.com/429397 for high res tiling appearing after low res
 527       // tiling discussion/fixes.
 528       if (high_res_range.start <= low_res_range.start)
 529         range = TilingRange(high_res_range.end, low_res_range.start);
 530       else
 531         range = TilingRange(low_res_range.end, high_res_range.start);
 532       break;
 533     case LOW_RES:
 534       range = low_res_range;
 535       break;
 536     case LOWER_THAN_LOW_RES:
 537       range = TilingRange(low_res_range.end, tilings_.size());
 538       break;
 539   }
 540
 541   DCHECK_LE(range.start, range.end);
 542   return range;
 543 }
 544
 545 }  // namespace cc