Introduce Tile Versions

cc/tile.h

Index: cc/tile.h
diff --git a/cc/tile.h b/cc/tile.h
index fb57375af62d9ad1a286a5ad852ba96829f1e45b..1df68e6961b44a865b876e18787bc7c69c895cfd 100644
--- a/cc/tile.h
+++ b/cc/tile.h
@@ -6,6 +6,8 @@
 #define CC_TILE_H_
 
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
 #include "cc/picture_pile.h"
 #include "cc/resource_provider.h"
 #include "cc/tile_priority.h"
@@ -14,6 +16,7 @@
 
 namespace cc {
 
+class Tile;
 class TileManager;
 
 enum TileQuality {
@@ -21,30 +24,74 @@ enum TileQuality {
   NORMAL_TILE_QUALITY
 };
 
+class TileVersion {
+public:
+  TileVersion(Tile* tile, int frame_number,
+              scoped_ptr<PicturePile> picture_pile)

[enne (OOO), 2012/11/10 03:04:45]

This is weird.  How can the TileVersion own the PicturePile? I figured maybe the
layer would own it since the PicturePile's lifetime is tied to it more than
anything else?

Given that Tiles get unregistered when they die (which would happen if the layer
dies), then the PicturePile should persist correctly with a raw pointer on the
TileVersion.

+    : tile_(tile),
+      frame_number_(frame_number),
+      picture_pile_(picture_pile.release()),
+      resource_id_(0) {}
+
+  int frame_number() const { return frame_number_; }
+
+  const PicturePile* picture_pile() const {
+    return picture_pile_.get();
+  }
+
+  const TilePriority& priority() const {
+    return priority_;
+  }
+
+  void ModifyPriority(const TilePriority& priority) {
+    priority_ = priority;
+  }
+
+  ResourceProvider::ResourceId resource_id() const {
+    return resource_id_;
+  }
+
+private:
+  Tile* tile_;
+  int frame_number_;
+  scoped_ptr<PicturePile> picture_pile_;
+  TilePriority priority_;
+  ResourceProvider::ResourceId resource_id_;
+};
+
 class Tile : public base::RefCounted<Tile> {
  public:
   Tile(TileManager* tile_manager,
        gfx::Size tile_size,
+       GLenum format,
        gfx::Rect rect_inside_picture,
        TileQuality quality);
 
-  void SetPicturePile(int frame_number, scoped_ptr<PicturePile> picture_pile) {}
-  void SetPriority(int frame_number, TilePriority) {}
+  void SetPicturePile(int frame_number, scoped_ptr<PicturePile> picture_pile);
+  void ModifyPriority(int frame_number, const TilePriority& priority);
 
-  bool IsDrawable(int frame_number) { return false; }
-  ResourceProvider::ResourceId GetDrawableResourceId(int frame_number) { return 0; }
+  // Returns 0 if not drawable.
+  ResourceProvider::ResourceId GetDrawableResourceId(int frame_number);
+
+ protected:
+  // Methods called by TileManager.
+  void DeleteVersionOnRequestOfTileManager(int frame_number);
 
  private:
   friend class base::RefCounted<Tile>;
   friend class TileManager;
 
+  TileVersion* GetVersion(int frame_number);
   ~Tile();
 
   TileManager* tile_manager_;
   gfx::Rect tile_size_;
+  GLenum format_;
   gfx::Rect rect_inside_picture_;
   TileQuality quality_;
+  ScopedVector<TileVersion> versions_;
 };
 
+
 }  // namespace cc
 #endif