cc: Separate the priority from the tile and put in new PrioritizedTile

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>
 
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/base/math_util.h"
+#include "cc/resources/prioritized_tile.h"
 #include "cc/resources/tile.h"
 #include "cc/resources/tile_priority.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace cc {
 namespace {
 
@@ skipping 776 matching lines @@
 
   bool tile_is_visible = current_visible_rect_.Intersects(tile->content_rect());
   if (!tile_is_visible)
     return false;
 
   if (IsTileOccludedOnCurrentTree(tile))
     return false;
   return true;
 }
 
-void PictureLayerTiling::UpdateTilePriority(Tile* tile) const {
-  tile->set_priority(ComputePriorityForTile(tile));
-  tile->set_is_occluded(IsTileOccluded(tile));
+void PictureLayerTiling::UpdateTilePriority(

[vmpstr, 2015/05/08 18:11:06]

If you do go the route of GetPrioritizedTile(tile), then I think you would also
want to have a separate call for UpdateRequiredStateForTile(tile) that changes
the required_for_* flags.

Yes, it's going to be two calls, but it's more explicit.

[hendrikw, 2015/05/08 19:21:02]

messier, dangerous, but I like to live dangerously.  hopefully we can move the
required stuff within the prioritized tile.

+    PrioritizedTile* prioritized_tile) const {
+  Tile* tile = prioritized_tile->tile();
+  prioritized_tile->set_priority(ComputePriorityForTile(tile));
+  prioritized_tile->set_is_occluded(IsTileOccluded(tile));
   tile->set_required_for_activation(IsTileRequiredForActivation(tile));
   tile->set_required_for_draw(IsTileRequiredForDraw(tile));
 }
 
+std::map<const Tile*, PrioritizedTile>
+PictureLayerTiling::UpdateAndGetAllPrioritizedTilesForTesting() {
+  std::map<const Tile*, PrioritizedTile> result;
+  for (auto& key_tile_pair : tiles_) {

[vmpstr, 2015/05/08 18:11:06]

const auto&?

[hendrikw, 2015/05/08 19:21:02]

Done.

+    PrioritizedTile prioritized_tile;
+    prioritized_tile.UpdateTile(key_tile_pair.second.get(), this);
+    result.insert(std::make_pair(prioritized_tile.tile(), prioritized_tile));
+  }
+  return result;
+}
+
 void PictureLayerTiling::VerifyAllTilesHaveCurrentRasterSource() const {
 #if DCHECK_IS_ON()
   for (const auto& tile_pair : tiles_)
     DCHECK_EQ(raster_source_.get(), tile_pair.second->raster_source());
 #endif
 }
 
 TilePriority PictureLayerTiling::ComputePriorityForTile(
     const Tile* tile) const {
   // TODO(vmpstr): See if this can be moved to iterators.
@@ skipping 205 matching lines @@
       break;
   }
 
   gfx::Rect result(origin_x, origin_y, width, height);
   if (cache)
     cache->previous_result = result;
   return result;
 }
 
 }  // namespace cc