Roll Chrome into Mojo.

cc/resources/picture_layer_tiling.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/resources/picture_layer_tiling.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 454 matching lines @@
     DCHECK_EQ(last_geometry_rect.y(), current_geometry_rect_.y());
   }
 
   return *this;
 }
 
 gfx::Rect PictureLayerTiling::CoverageIterator::geometry_rect() const {
   return current_geometry_rect_;
 }
 
-gfx::Rect
-PictureLayerTiling::CoverageIterator::full_tile_geometry_rect() const {
-  gfx::Rect rect = tiling_->tiling_data_.TileBoundsWithBorder(tile_i_, tile_j_);
-  rect.set_size(tiling_->tiling_data_.max_texture_size());
-  return rect;
-}
-
 gfx::RectF PictureLayerTiling::CoverageIterator::texture_rect() const {
   gfx::PointF tex_origin =
       tiling_->tiling_data_.TileBoundsWithBorder(tile_i_, tile_j_).origin();
 
   // Convert from dest space => content space => texture space.
   gfx::RectF texture_rect(current_geometry_rect_);
   texture_rect.Scale(dest_to_content_scale_,
                      dest_to_content_scale_);
   texture_rect.Intersect(gfx::Rect(tiling_->tiling_size()));
   if (texture_rect.IsEmpty())
     return texture_rect;
   texture_rect.Offset(-tex_origin.OffsetFromOrigin());
 
   return texture_rect;
 }
 
-gfx::Size PictureLayerTiling::CoverageIterator::texture_size() const {
-  return tiling_->tiling_data_.max_texture_size();
-}
-
 bool PictureLayerTiling::RemoveTileAt(int i,
                                       int j,
                                       PictureLayerTiling* recycled_twin) {
   TileMap::iterator found = tiles_.find(TileMapKey(i, j));
   if (found == tiles_.end())
     return false;
   found->second->set_shared(false);
   tiles_.erase(found);
   if (recycled_twin) {
     // Recycled twin does not also have a recycled twin, so pass null.
@@ skipping 282 matching lines @@
   if (resolution_ != HIGH_RESOLUTION)
     return false;
 
   if (IsTileOccluded(tile))
     return false;
 
   return true;
 }
 
 void PictureLayerTiling::UpdateTileAndTwinPriority(Tile* tile) const {
-  UpdateTilePriority(tile);
+  WhichTree tree = client_->GetTree();
+  WhichTree twin_tree = tree == ACTIVE_TREE ? PENDING_TREE : ACTIVE_TREE;
+
+  UpdateTilePriorityForTree(tile, tree);
 
   const PictureLayerTiling* twin_tiling =
       client_->GetPendingOrActiveTwinTiling(this);
   if (!tile->is_shared() || !twin_tiling) {
-    WhichTree tree = client_->GetTree();
-    WhichTree twin_tree = tree == ACTIVE_TREE ? PENDING_TREE : ACTIVE_TREE;
     tile->SetPriority(twin_tree, TilePriority());
     tile->set_is_occluded(twin_tree, false);
     if (twin_tree == PENDING_TREE)
       tile->set_required_for_activation(false);
     else
       tile->set_required_for_draw(false);
     return;
   }
 
-  twin_tiling->UpdateTilePriority(tile);
+  twin_tiling->UpdateTilePriorityForTree(tile, twin_tree);
 }
 
-void PictureLayerTiling::UpdateTilePriority(Tile* tile) const {
+void PictureLayerTiling::UpdateTilePriorityForTree(Tile* tile,
+                                                   WhichTree tree) const {
   // TODO(vmpstr): This code should return the priority instead of setting it on
   // the tile. This should be a part of the change to move tile priority from
   // tiles into iterators.
   TilePriority::PriorityBin max_tile_priority_bin =
       client_->GetMaxTilePriorityBin();
-  WhichTree tree = client_->GetTree();
 
   DCHECK_EQ(TileAt(tile->tiling_i_index(), tile->tiling_j_index()), tile);
   gfx::Rect tile_bounds =
       tiling_data_.TileBounds(tile->tiling_i_index(), tile->tiling_j_index());
 
   if (max_tile_priority_bin <= TilePriority::NOW &&
       current_visible_rect_.Intersects(tile_bounds)) {
     tile->SetPriority(tree, TilePriority(resolution_, TilePriority::NOW, 0));
     if (tree == PENDING_TREE) {
       tile->set_required_for_activation(
@@ skipping 197 matching lines @@
     if (delta < event.distance)
       break;
   }
 
   gfx::Rect result(origin_x, origin_y, width, height);
   if (cache)
     cache->previous_result = result;
   return result;
 }
 
-PictureLayerTiling::TilingRasterTileIterator::TilingRasterTileIterator()
-    : tiling_(NULL), current_tile_(NULL) {}
-
-PictureLayerTiling::TilingRasterTileIterator::TilingRasterTileIterator(
-    PictureLayerTiling* tiling)
-    : tiling_(tiling), phase_(VISIBLE_RECT), current_tile_(NULL) {
-  if (!tiling_->has_visible_rect_tiles_) {
-    AdvancePhase();
-    return;
-  }
-
-  visible_iterator_ = TilingData::Iterator(&tiling_->tiling_data_,
-                                           tiling_->current_visible_rect_,
-                                           false /* include_borders */);
-  if (!visible_iterator_) {
-    AdvancePhase();
-    return;
-  }
-
-  current_tile_ =
-      tiling_->TileAt(visible_iterator_.index_x(), visible_iterator_.index_y());
-  if (!current_tile_ || !TileNeedsRaster(current_tile_)) {
-    ++(*this);
-    return;
-  }
-  tiling_->UpdateTileAndTwinPriority(current_tile_);
-}
-
-PictureLayerTiling::TilingRasterTileIterator::~TilingRasterTileIterator() {}
-
-void PictureLayerTiling::TilingRasterTileIterator::AdvancePhase() {
-  DCHECK_LT(phase_, EVENTUALLY_RECT);
-
-  do {
-    phase_ = static_cast<Phase>(phase_ + 1);
-    switch (phase_) {
-      case VISIBLE_RECT:
-        NOTREACHED();
-        return;
-      case SKEWPORT_RECT:
-        if (!tiling_->has_skewport_rect_tiles_)
-          continue;
-
-        spiral_iterator_ = TilingData::SpiralDifferenceIterator(
-            &tiling_->tiling_data_,
-            tiling_->current_skewport_rect_,
-            tiling_->current_visible_rect_,
-            tiling_->current_visible_rect_);
-        break;
-      case SOON_BORDER_RECT:
-        if (!tiling_->has_soon_border_rect_tiles_)
-          continue;
-
-        spiral_iterator_ = TilingData::SpiralDifferenceIterator(
-            &tiling_->tiling_data_,
-            tiling_->current_soon_border_rect_,
-            tiling_->current_skewport_rect_,
-            tiling_->current_visible_rect_);
-        break;
-      case EVENTUALLY_RECT:
-        if (!tiling_->has_eventually_rect_tiles_) {
-          current_tile_ = NULL;
-          return;
-        }
-
-        spiral_iterator_ = TilingData::SpiralDifferenceIterator(
-            &tiling_->tiling_data_,
-            tiling_->current_eventually_rect_,
-            tiling_->current_skewport_rect_,
-            tiling_->current_soon_border_rect_);
-        break;
-    }
-
-    while (spiral_iterator_) {
-      current_tile_ = tiling_->TileAt(spiral_iterator_.index_x(),
-                                      spiral_iterator_.index_y());
-      if (current_tile_ && TileNeedsRaster(current_tile_))
-        break;
-      ++spiral_iterator_;
-    }
-
-    if (!spiral_iterator_ && phase_ == EVENTUALLY_RECT) {
-      current_tile_ = NULL;
-      break;
-    }
-  } while (!spiral_iterator_);
-
-  if (current_tile_)
-    tiling_->UpdateTileAndTwinPriority(current_tile_);
-}
-
-PictureLayerTiling::TilingRasterTileIterator&
-PictureLayerTiling::TilingRasterTileIterator::
-operator++() {
-  current_tile_ = NULL;
-  while (!current_tile_ || !TileNeedsRaster(current_tile_)) {
-    std::pair<int, int> next_index;
-    switch (phase_) {
-      case VISIBLE_RECT:
-        ++visible_iterator_;
-        if (!visible_iterator_) {
-          AdvancePhase();
-          return *this;
-        }
-        next_index = visible_iterator_.index();
-        break;
-      case SKEWPORT_RECT:
-      case SOON_BORDER_RECT:
-        ++spiral_iterator_;
-        if (!spiral_iterator_) {
-          AdvancePhase();
-          return *this;
-        }
-        next_index = spiral_iterator_.index();
-        break;
-      case EVENTUALLY_RECT:
-        ++spiral_iterator_;
-        if (!spiral_iterator_) {
-          current_tile_ = NULL;
-          return *this;
-        }
-        next_index = spiral_iterator_.index();
-        break;
-    }
-    current_tile_ = tiling_->TileAt(next_index.first, next_index.second);
-  }
-
-  if (current_tile_)
-    tiling_->UpdateTileAndTwinPriority(current_tile_);
-  return *this;
-}
-
 }  // namespace cc