Introduce Tile Versions

BUG=155209


Review URL: https://chromiumcodereview.appspot.com/11364194

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@167079 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 197 insertions, 28 deletions

diff --git a/cc/tile.cc b/cc/tile.cc
index 536b2efc..7c205e8 100644
--- a/cc/tile.cc
+++ b/cc/tile.cc
@@ -10,17 +10,60 @@ namespace cc {
 
 Tile::Tile(TileManager* tile_manager,
            gfx::Size tile_size,
+           GLenum format,
            gfx::Rect rect_inside_picture,
            TileQuality quality)
   : tile_manager_(tile_manager),
     tile_size_(tile_size),
+    format_(format),
     rect_inside_picture_(rect_inside_picture),
     quality_(quality) {
-  tile_manager_->RegisterTile(this);
 }
 
 Tile::~Tile() {
-  tile_manager_->UnregisterTile(this);
+  for (size_t i = 0; i < versions_.size(); i++)
+    tile_manager_->DidDeleteTileVersion(versions_[i]);
+  versions_.clear();
+}
+
+void Tile::SetPicturePile(int frame_number, PicturePile* picture_pile) {
+  DCHECK(GetVersion(frame_number) == NULL);
+  TileVersion* version = new TileVersion(this, frame_number, picture_pile);
+  versions_.push_back(version);
+  tile_manager_->DidCreateTileVersion(version);
+}
+
+void Tile::ModifyPriority(int frame_number, const TilePriority& priority) {
+  TileVersion* version = GetVersion(frame_number);
+  DCHECK(version) <<
+    "Tile must have a picture pile before its priority can be modified";
+  tile_manager_->WillModifyTileVersionPriority(version, priority);
+  version->ModifyPriority(priority);
+}
+
+ResourceProvider::ResourceId Tile::GetDrawableResourceId(int frame_number) {
+  TileVersion* version = GetVersion(frame_number);
+  if (!version)
+    return 0;
+  return version->resource_id();
+}
+
+void Tile::DeleteVersionOnRequestOfTileManager(int frame_number) {
+  for (size_t i = 0; i < versions_.size(); i++) {
+    if (versions_[i]->frame_number() == frame_number) {
+      versions_.erase(versions_.begin() + frame_number);
+      return;
+    }
+  }
+  DCHECK(false) << "Could not find version";
+}
+
+TileVersion* Tile::GetVersion(int frame_number) {
+  for (size_t i = 0; i < versions_.size(); i++) {
+    if (versions_[i]->frame_number() == frame_number)
+      return versions_[i];
+  }
+  return NULL;
 }
 
 }  // namespace cc
diff --git a/cc/tile.h b/cc/tile.h
index fb57375..0d82d7e 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,
+              PicturePile* picture_pile)
+    : tile_(tile),
+      frame_number_(frame_number),
+      picture_pile_(picture_pile),
+      resource_id_(0) {}
+
+  int frame_number() const { return frame_number_; }
+
+  const PicturePile* picture_pile() const {
+    return picture_pile_;
+  }
+
+  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_;
+  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, 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
diff --git a/cc/tile_manager.cc b/cc/tile_manager.cc
index 68f399c..ced363c 100644
--- a/cc/tile_manager.cc
+++ b/cc/tile_manager.cc
@@ -8,26 +8,56 @@
 
 namespace cc {
 
-TileManager::TileManager(TileManagerClient* client) {
+TileManager::TileManager(TileManagerClient* client)
+  : client_(client)
+  , manage_tiles_pending_(false)
+{
 }
 
 TileManager::~TileManager() {
-  DCHECK(registered_tiles_.size() == 0);
+  ManageTiles();
+  DCHECK(tile_versions_.size() == 0);
 }
 
-void TileManager::RegisterTile(Tile* tile) {
-  registered_tiles_.push_back(tile);
+void TileManager::SetGlobalState(const GlobalStateThatImpactsTilePriority& global_state) {
+  global_state_ = global_state;
+  ScheduleManageTiles();
 }
 
-void TileManager::UnregisterTile(Tile* tile) {
-  // TODO(nduca): Known slow. Shrug. Fish need frying.
-  for (size_t i =  0; i < registered_tiles_.size(); i++) {
-    if (registered_tiles_[i] == tile) {
-      registered_tiles_.erase(registered_tiles_.begin() + i);
+void TileManager::ManageTiles() {
+  // Figure out how much memory we would be willing to give out.
+
+  // Free up memory.
+
+  // GC old versions.
+}
+
+void TileManager::DidCreateTileVersion(TileVersion* version) {
+  tile_versions_.push_back(version);
+  ScheduleManageTiles();
+}
+
+void TileManager::DidDeleteTileVersion(TileVersion* version) {
+  for (size_t i = 0; i < tile_versions_.size(); i++) {
+    if (tile_versions_[i] == version) {
+      tile_versions_.erase(tile_versions_.begin() + i);
       return;
     }
   }
-  DCHECK(false) << "Tile " << tile << " wasnt regitered.";
+  DCHECK(false) << "Could not find tile version.";
+}
+
+void TileManager::WillModifyTileVersionPriority(TileVersion*, const TilePriority& new_priority) {
+  // TODO(nduca): Do something smarter if reprioritization turns out to be
+  // costly.
+  ScheduleManageTiles();
+}
+
+void TileManager::ScheduleManageTiles() {
+  if (manage_tiles_pending_)
+    return;
+  ScheduleManageTiles();
+  manage_tiles_pending_ = true;
 }
 
 }
diff --git a/cc/tile_manager.h b/cc/tile_manager.h
index 4a09350..72a47b7f 100644
--- a/cc/tile_manager.h
+++ b/cc/tile_manager.h
@@ -7,14 +7,18 @@
 
 #include <vector>
 
+#include "base/values.h"
+#include "cc/tile_priority.h"
+
 namespace cc {
 
 class Tile;
+class TileVersion;
 class ResourceProvider;
 
 class TileManagerClient {
  public:
-  virtual void ScheduleManage() = 0;
+  virtual void ScheduleManageTiles() = 0;
 
  protected:
   ~TileManagerClient() { }
@@ -28,18 +32,25 @@ class TileManager {
  public:
   TileManager(TileManagerClient* client);
   ~TileManager();
-  void Manage() { }
+
+  void SetGlobalState(const GlobalStateThatImpactsTilePriority& state);
+  void ManageTiles();
 
  protected:
   // Methods called by Tile
-  void RegisterTile(Tile*);
-  void UnregisterTile(Tile*);
+  void DidCreateTileVersion(TileVersion*);
+  void WillModifyTileVersionPriority(TileVersion*, const TilePriority& new_priority);
+  void DidDeleteTileVersion(TileVersion*);
 
  private:
   friend class Tile;
+  void ScheduleManageTiles();
 
   TileManagerClient* client_;
-  std::vector<Tile*> registered_tiles_;
+  bool manage_tiles_pending_;
+
+  GlobalStateThatImpactsTilePriority global_state_;
+  std::vector<TileVersion*> tile_versions_;
 };
 
 }
diff --git a/cc/tile_priority.h b/cc/tile_priority.h
index 357fb9e..41c30ac 100644
--- a/cc/tile_priority.h
+++ b/cc/tile_priority.h
@@ -7,21 +7,23 @@
 
 #include "base/memory/ref_counted.h"
 #include "cc/picture_pile.h"
-#include "cc/tile_priority.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 
 namespace cc {
 
 struct TilePriority {
+  // Set to true for tiles that should be favored during, for example,
+  // scrolls.
+  bool on_primary_tree;
+
   // A given layer may have multiple tilings, of differing quality.
   // would_be_drawn is set for the tiles that are visible that would be
   // drawn if they were chosen.
   bool would_be_drawn;
 
-  // Set to true for tiles that should be favored during, for example,
-  // scrolls.
-  bool on_primary_tree;
+  // We expect it to be useful soon.
+  bool nice_to_have;
 
   // Used to prefer tiles near to the viewport.
   float distance_to_viewport;
@@ -29,10 +31,46 @@ struct TilePriority {
   // TODO(enne): some metric that penalizes blurriness.
 };
 
+enum TileMemoryLimitPolicy {
+  // Nothing.
+  ALLOW_NOTHING,
+
+  // Use as little as possible.
+  ALLOW_ONLY_REQUIRED, // On primary tree, would be drawn.
+
+  // Use as little as possible.
+  ALLOW_NICE_TO_HAVE, // On either tree, nice to have
+
+  // Use as much memory, up to memory size.
+  ALLOW_ANYTHING,
+};
+
+class GlobalStateThatImpactsTilePriority {
+public:
+  GlobalStateThatImpactsTilePriority()
+    : memory_limit_policy(ALLOW_NOTHING)
+    , memory_limit_in_bytes(0)
+    , smoothness_takes_priority(false)
+    , pending_tree_frame_number(-1)
+    , active_tree_frame_number(-1) {
+  }
+
+  TileMemoryLimitPolicy memory_limit_policy;
+
+  size_t memory_limit_in_bytes;
+
+  // Set when scrolling.
+  bool smoothness_takes_priority;
+
+  // Use -1 if no tree.
+  int pending_tree_frame_number;
+  int active_tree_frame_number;
+};
+
 class TilePriorityComparator {
  public:
-  TilePriorityComparator(bool currently_scrolling)
-   : currently_scrolling_(currently_scrolling) {}
+  TilePriorityComparator(GlobalStateThatImpactsTilePriority& global_state)
+   : global_state_(global_state) {}
 
   int compare(const TilePriority& a, const TilePriority& b) {
     // TODO(nduca,enne): Implement a comparator using the attributes here.
@@ -40,7 +78,7 @@ class TilePriorityComparator {
   }
 
  private:
-  bool currently_scrolling_;
+  GlobalStateThatImpactsTilePriority global_state_;
 };
 
 }  // namespace cc