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