cc: Added tile bundles

cc/resources/tile_bundle.cc

+// Copyright 2013 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/tile_bundle.h"
+
+#include <algorithm>
+
+#include "cc/resources/picture_layer_tiling.h"
+#include "cc/resources/tile.h"
+#include "cc/resources/tile_manager.h"
+
+namespace cc {
+
+TileBundle::Id TileBundle::s_next_id_ = 0;
+
+TileBundle::TileBundle(TileManager* tile_manager,
+                       int offset_x,
+                       int offset_y,
+                       int width,
+                       int height)
+    : RefCountedManaged<TileBundle>(tile_manager),
+      tile_manager_(tile_manager),
+      index_offset_x_(offset_x),
+      index_offset_y_(offset_y),
+      index_count_x_(width),
+      index_count_y_(height),
+      conservative_tile_count_(0),
+      needs_tile_swap_(false),
+      id_(s_next_id_++) {
+  tiles_[ACTIVE_TREE].resize(index_count_y_);
+  for (int i = 0; i < index_count_y_; ++i)
+    tiles_[ACTIVE_TREE][i].resize(index_count_x_);
+
+  tiles_[PENDING_TREE].resize(index_count_y_);
+  for (int i = 0; i < index_count_y_; ++i)
+    tiles_[PENDING_TREE][i].resize(index_count_x_);
+}
+
+TileBundle::~TileBundle() {}
+
+Tile* TileBundle::TileAt(WhichTree tree, int index_x, int index_y) {
+  DCHECK(!needs_tile_swap_);
+
+  UpdateToLocalIndex(&index_x, &index_y);
+  return TileAtLocalIndex(tree, index_x, index_y);
+}
+
+Tile* TileBundle::TileAtLocalIndex(WhichTree tree, int index_x, int index_y) {
+  return tiles_[tree][index_y][index_x].get();
+}
+
+void TileBundle::SetPriority(WhichTree tree, const TilePriority& priority) {
+  DCHECK(!needs_tile_swap_);
+
+  if (priority_[tree] == priority)
+    return;
+
+  priority_[tree] = priority;
+  tile_manager_->DidChangeTileBundlePriority(this);
+}
+
+TilePriority TileBundle::GetPriority(WhichTree tree) const {
+  return priority_[tree];
+}
+
+bool TileBundle::RemoveTileAt(WhichTree tree, int index_x, int index_y) {
+  DCHECK(!needs_tile_swap_);
+
+  UpdateToLocalIndex(&index_x, &index_y);
+  bool removed = !!tiles_[tree][index_y][index_x];
+  tiles_[tree][index_y][index_x] = NULL;
+  if (removed)
+    --conservative_tile_count_;
+  return removed;
+}
+
+void TileBundle::AddTileAt(WhichTree tree,
+                           int index_x,
+                           int index_y,
+                           scoped_refptr<Tile> tile) {
+  DCHECK(!needs_tile_swap_);
+
+  UpdateToLocalIndex(&index_x, &index_y);
+  DCHECK(!tiles_[tree][index_y][index_x]);
+  tiles_[tree][index_y][index_x] = tile;
+  ++conservative_tile_count_;
+}
+
+void TileBundle::DidBecomeRecycled() {
+  priority_[ACTIVE_TREE] = TilePriority();
+  needs_tile_swap_ = !needs_tile_swap_;
+}
+
+void TileBundle::DidBecomeActive() {
+  priority_[ACTIVE_TREE] = priority_[PENDING_TREE];
+  priority_[PENDING_TREE] = TilePriority();
+  tiles_[ACTIVE_TREE].swap(tiles_[PENDING_TREE]);
+  needs_tile_swap_ = false;
+}
+
+void TileBundle::UpdateToLocalIndex(int* index_x, int* index_y) {
+  DCHECK(index_x);
+  DCHECK(index_y);
+
+  *index_x -= index_offset_x_;
+  *index_y -= index_offset_y_;
+
+  DCHECK_GE(*index_x, 0);
+  DCHECK_GE(*index_y, 0);
+  DCHECK_LT(*index_x, index_count_x_);
+  DCHECK_LT(*index_x, index_count_y_);
+}
+
+void TileBundle::SwapTilesIfRequired() {
+  if (!needs_tile_swap_)
+    return;
+
+  std::swap(priority_[ACTIVE_TREE], priority_[PENDING_TREE]);
+  tiles_[ACTIVE_TREE].swap(tiles_[PENDING_TREE]);
+  needs_tile_swap_ = false;
+}
+
+TileBundle::Iterator::Iterator(TileBundle* bundle)
+    : bundle_(bundle),
+      current_tile_(NULL),
+      index_x_(0),
+      index_y_(0),
+      current_tree_(ACTIVE_TREE),
+      min_tree_(ACTIVE_TREE),
+      max_tree_(PENDING_TREE) {
+  if (!InitializeNewTile())
+    ++(*this);
+}
+
+TileBundle::Iterator::Iterator(TileBundle* bundle, WhichTree tree)
+    : bundle_(bundle),
+      current_tile_(NULL),
+      index_x_(0),
+      index_y_(0),
+      current_tree_(tree),
+      min_tree_(tree),
+      max_tree_(tree) {
+  if (!InitializeNewTile())
+    ++(*this);
+}
+
+TileBundle::Iterator::~Iterator() {}
+
+TileBundle::Iterator& TileBundle::Iterator::operator++() {
+  do {
+    current_tree_ = static_cast<WhichTree>(current_tree_ + 1);
+    if (current_tree_ > max_tree_) {
+      current_tree_ = min_tree_;
+      ++index_x_;
+      if (index_x_ >= bundle_->index_count_x_) {
+        index_x_ = 0;
+        ++index_y_;
+        if (index_y_ >= bundle_->index_count_y_)
+          break;
+      }
+    }
+  } while (!InitializeNewTile());
+
+  return *this;
+}
+
+bool TileBundle::Iterator::InitializeNewTile() {
+  Tile* tile = bundle_->TileAtLocalIndex(current_tree_, index_x_, index_y_);
+
+  // We succeed only if we have a tile and it is different
+  // from what we currently have. This is to avoid the iterator
+  // returning the same tile twice when it's shared between trees.
+  if (!tile || tile == current_tile_)
+    return false;
+
+  current_tile_ = tile;
+  return true;
+}
+
+}  // namespace cc