cc: Added tile bundles

cc/resources/tile_bundle.h

Index: cc/resources/tile_bundle.h
diff --git a/cc/resources/tile_bundle.h b/cc/resources/tile_bundle.h
new file mode 100644
index 0000000000000000000000000000000000000000..5d658e5132f61c944a51cbfb2902997902dbbfe2
--- /dev/null
+++ b/cc/resources/tile_bundle.h
@@ -0,0 +1,114 @@
+// 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.
+
+#ifndef CC_RESOURCES_TILE_BUNDLE_H_
+#define CC_RESOURCES_TILE_BUNDLE_H_
+
+#include <utility>
+#include <vector>
+
+#include "base/memory/ref_counted.h"
+#include "cc/base/ref_counted_managed.h"
+#include "cc/resources/tile_priority.h"
+
+namespace cc {
+
+class TileManager;
+class Tile;
+class PictureLayerTiling;
+class CC_EXPORT TileBundle : public RefCountedManaged<TileBundle> {

[enne (OOO), 2013/12/04 01:01:38]

Can you separate this from the forward declarations with a blank line?

[vmpstr, 2013/12/04 01:11:57]

Done.

+ public:
+  typedef uint64 Id;
+  typedef std::vector<scoped_refptr<Tile> > TileVector;
+  typedef std::vector<TileVector> TileGrid;
+
+  inline Id id() const { return id_; }
+
+  Tile* TileAt(WhichTree tree, int index_x, int index_y);
+  bool RemoveTileAt(WhichTree tree, int index_x, int index_y);
+  void AddTileAt(WhichTree tree,
+                 int index_x,
+                 int index_y,
+                 scoped_refptr<Tile> tile);
+  inline bool IsEmpty() const { return conservative_count_ == 0; }

[enne (OOO), 2013/12/04 01:01:38]

No need for inline on member functions.

[vmpstr, 2013/12/04 01:11:57]

Done.

+
+  void DidBecomeRecycled();
+  void DidBecomeActive();
+
+  void SetPriority(WhichTree tree, const TilePriority& priority);
+  TilePriority GetPriority(WhichTree tree) const;
+
+  void SwapTilesIfRequired();
+
+  class Iterator {
+   public:
+    explicit Iterator(TileBundle* bundle);
+    Iterator(TileBundle* bundle, WhichTree tree);
+    ~Iterator();
+
+    Iterator& operator++();
+
+    inline Tile* operator*() { return current_tile_; }
+    inline Tile* operator->() { return current_tile_; }
+    inline operator bool() const {
+      return index_y_ < bundle_->index_count_y_;
+    }
+
+    inline int index_x() {
+      return index_x_ + bundle_->index_offset_x_;
+    }
+    inline int index_y() {
+      return index_y_ + bundle_->index_offset_y_;
+    }
+
+    TilePriority priority(WhichTree tree) const {
+      return bundle_->GetPriority(tree);
+    }
+
+   private:
+    bool InitializeNewTile();
+
+    TileBundle* bundle_;
+    Tile* current_tile_;
+    int index_x_;
+    int index_y_;
+    WhichTree current_tree_;
+
+    WhichTree min_tree_;
+    WhichTree max_tree_;
+  };
+
+ private:
+  friend class TileManager;
+  friend class Iterator;
+
+  TileBundle(TileManager* tile_manager,
+             int offset_x,
+             int offset_y,
+             int width,
+             int height);
+  ~TileBundle();
+
+  void UpdateToLocalIndex(int* index_x, int* index_y);
+  Tile* TileAtLocalIndex(WhichTree tree, int x, int y);
+
+  TileManager* tile_manager_;
+
+  TileGrid tiles_[NUM_TREES];
+  int index_offset_x_;
+  int index_offset_y_;
+  int index_count_x_;
+  int index_count_y_;
+
+  TilePriority priority_[NUM_TREES];
+  size_t conservative_count_;

[enne (OOO), 2013/12/04 01:01:38]

Can you rename this to tile_count to differentiate from index_count?

What makes it "conservative"?

size_t => int

[vmpstr, 2013/12/04 01:11:57]

Done.
If there's only one tile, but it's on both trees, the count will be 2. That is,
the only thing you can really say is that if it's 0, then the bundle is empty.
When it's non zero then it could be larger than the amount of tiles actually
stored in it (due to them appearing on two trees).
Done.

+  bool needs_tile_swap_;
+
+  Id id_;
+  static Id s_next_id_;
+};
+
+}  // namespace cc
+
+#endif  // CC_RESOURCES_TILE_BUNDLE_H_