cc: Added tile bundles

cc/resources/shared_tile_bundle.h

+// 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_SHARED_TILE_BUNDLE_H_
+#define CC_RESOURCES_SHARED_TILE_BUNDLE_H_
+
+#include <utility>
+
+#include "base/containers/hash_tables.h"
+#include "cc/resources/tile_bundle.h"
+#include "cc/resources/tile_priority.h"
+
+namespace cc {
+
+class SharedTileBundle {

[enne (OOO), 2013/11/20 21:20:30]

I'm not quite sure I'm buying the SharedTileBundle idea.  Previously, a
PictureLayerTiling had a set of tiles, some of which were shared with its twin
layer.  Now, a PictureLayerTiling has a set of bundles (which have tiles).  The
tiles are shared with the twin but the bundles are not.

Now, I think I understand why you don't share the bundles, since invalidations
only affect tiles, and so you could share tiles but not share the entire bundle.
 But then if you don't share, you have to find and combine bundles later every
time you iterate through them, which seems like a lot of extra work and
complication.  Lots of asking for 

What about sharing bundles like you share tiles, but have active and pending
tile pointers and active and pending priorities.  Some bookkeeping will have to
be done during activation/recycling, but I think that's less than what has to be
done to generate SharedTileBundles.  If you do this, then you don't need to know
which bundle is active or pending because it will be explicit which tiles are
which, and then you can ditch the client pointer on bundles too.

+ public:
+  typedef std::pair<int, int> TileMapKey;
+  typedef base::hash_map<TileMapKey, Tile*> TileMap;
+
+  SharedTileBundle();
+  SharedTileBundle(const TilePriority& active_priority,
+                   const TilePriority& pending_priority);
+
+  void AddTileAt(int x, int y, Tile* tile);
+
+  inline const TilePriority& active_priority() const {
+    return active_priority_;
+  }
+
+  inline const TilePriority& pending_priority() const {
+    return pending_priority_;
+  }
+
+  class Iterator {
+   public:
+    explicit Iterator(SharedTileBundle* bundle);
+    ~Iterator();
+
+    inline Iterator& operator++() {
+      DCHECK(iterator_ != bundle_->tiles_.end());
+      ++iterator_;
+      return *this;
+    }
+
+    inline Tile* operator*() { return iterator_->second; }
+    inline Tile* operator->() { return iterator_->second; }
+    inline operator bool() const { return iterator_ != bundle_->tiles_.end(); }
+
+    inline int index_x() { return iterator_->first.first; }
+    inline int index_y() { return iterator_->first.second; }
+
+   private:
+    SharedTileBundle* bundle_;
+    SharedTileBundle::TileMap::const_iterator iterator_;
+  };
+
+ private:
+  TilePriority active_priority_;
+  TilePriority pending_priority_;
+
+  TileMap tiles_;
+};
+
+class BundleSetIterator {
+ public:
+  typedef base::hash_map<TileBundle::Id, TileBundle*> TileBundleMap;
+
+  explicit BundleSetIterator(TileBundleMap* bundles);
+  ~BundleSetIterator();
+
+  SharedTileBundle* operator*();
+  SharedTileBundle* operator->();
+  operator bool() const;
+
+  BundleSetIterator& operator++();
+
+ private:
+  enum SharedBundleType {
+    eBothPriorities,

[enne (OOO), 2013/11/20 21:20:30]

BOTH_PRIORITIES

+    eActivePriorityOnly,
+    ePendingPriorityOnly,
+    eMaxSharedBundleTypes
+  };
+
+  void AdvanceBundleIterator();
+  bool InitializeSharedBundles();
+  bool InitializeSharedBundle(SharedBundleType type);
+  void DetermineActivePendingBundles(TileBundle* bundle, TileBundle* twin);
+
+  TileBundleMap* bundles_;
+  TileBundleMap::iterator current_bundle_iterator_;
+  base::hash_set<TileBundle::Id> processed_bundles_;
+
+  SharedTileBundle current_bundle_;
+  SharedBundleType current_bundle_type_;
+
+  TileBundle* active_bundle_;
+  TileBundle* pending_bundle_;
+};
+
+}  // namespace cc
+
+#endif  // CC_RESOURCES_SHARED_TILE_BUNDLE_H_