cc: Remove tile sharing from tilings.

cc/resources/tiling_set_raster_queue_required.cc

 // Copyright 2014 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/tiling_set_raster_queue_required.h"
 
 #include <utility>
 
 #include "cc/resources/picture_layer_tiling_set.h"
 #include "cc/resources/tile.h"
@@ skipping 13 matching lines @@
   // PictureLayerTiling::IsTileRequiredFor*, which all return false if the
   // resolution is not HIGH_RESOLUTION.
   PictureLayerTiling* tiling =
       tiling_set->FindTilingWithResolution(HIGH_RESOLUTION);
   // If we don't have a high res tiling, then this queue will yield no tiles.
   // See PictureLayerImpl::CanHaveTilings for examples of when a HIGH_RESOLUTION
   // tiling would not be generated.
   if (!tiling)
     return;
 
-  iterator_ = TilingIterator(tiling, &tiling->tiling_data_);
+  if (type == RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION &&
+      tiling->IsActiveTree()) {

[enne (OOO), 2015/04/02 21:45:34]

This is a bit weird.  ActiveTiling knows it's active, but PictureLayerTiling has
to ask the client?

Also, aren't both branches of this if statement the same? If it's the active
tree, then you ask for the pending visible rect.  If it's pending, you ask for
the current visible rect.  Why not just ask for the pending visible rect in both
cases?

[vmpstr, 2015/04/02 22:33:27]

I can reduce it to just an if based on type. For required for draw, we want
active visible rect; for required for activation, we want the pending visible
rect. I guess it's a bit of a misnomer for me to say pending, since we reserve
that for pending tree/active tree. To clarify, pending visible rect means the
rect that will become the current visible rect upon activation (which in cases
of no pending tree is the current visible rect). Whereas the current visible
rect is the visible rect that is currently in effect on the given tiling (ie
it's visible rect on pending when asking the pending tree and it's visible rect
on active when asking the active tree).

+    iterator_ = TilingIterator(tiling, &tiling->tiling_data_,
+                               tiling->pending_visible_rect());
+  } else {
+    iterator_ = TilingIterator(tiling, &tiling->tiling_data_,
+                               tiling->current_visible_rect());
+  }
   while (!iterator_.done() && !IsTileRequired(*iterator_))
     ++iterator_;
 }
 
 TilingSetRasterQueueRequired::~TilingSetRasterQueueRequired() {
 }
 
 bool TilingSetRasterQueueRequired::IsEmpty() const {
   return iterator_.done();
 }
@@ skipping 21 matching lines @@
          (type_ == RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW &&
           tile->required_for_draw());
 }
 
 TilingSetRasterQueueRequired::TilingIterator::TilingIterator()
     : tiling_(nullptr), current_tile_(nullptr) {
 }
 
 TilingSetRasterQueueRequired::TilingIterator::TilingIterator(
     PictureLayerTiling* tiling,
-    TilingData* tiling_data)
+    TilingData* tiling_data,
+    const gfx::Rect& rect)
     : tiling_(tiling), tiling_data_(tiling_data), current_tile_(nullptr) {
-  if (!tiling_->has_visible_rect_tiles()) {
-    // Verify that if we would create the iterator, then it would be empty (ie
-    // it would return false when evaluated as a bool).
-    DCHECK(!TilingData::Iterator(tiling_data_, tiling->current_visible_rect(),
-                                 false));
-    return;
-  }
-
   visible_iterator_ =
-      TilingData::Iterator(tiling_data_, tiling_->current_visible_rect(),
-                           false /* include_borders */);
+      TilingData::Iterator(tiling_data_, rect, false /* include_borders */);
   if (!visible_iterator_)
     return;
 
   current_tile_ =
       tiling_->TileAt(visible_iterator_.index_x(), visible_iterator_.index_y());
 
   // If this is a valid tile, return it. Note that we have to use a tiling check
   // for occlusion, since the tile's internal state has not yet been updated.
   if (current_tile_ && current_tile_->NeedsRaster() &&
       !tiling_->IsTileOccluded(current_tile_)) {
@@ skipping 33 matching lines @@
     // in the NOW bin, which means that it can be required.
     break;
   }
 
   if (current_tile_)
     tiling_->UpdateTileAndTwinPriority(current_tile_);
   return *this;
 }
 
 }  // namespace cc