cc: Add per-layer memory usage to tracing snapshots

R=nduca@chromium.org
BUG=none

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

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

13 files changed, 99 insertions, 5 deletions

diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index 745090e..6ad5a68 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -1008,6 +1008,7 @@ void LayerImpl::AsValueInto(base::DictionaryValue* state) const {
   state->SetInteger("layer_id", id());
   state->Set("bounds", MathUtil::AsValue(bounds()).release());
   state->SetInteger("draws_content", DrawsContent());
+  state->SetInteger("gpu_memory_usage", GPUMemoryUsageInBytes());
 
   bool clipped;
   gfx::QuadF layer_quad = MathUtil::MapQuad(
@@ -1027,6 +1028,8 @@ void LayerImpl::AsValueInto(base::DictionaryValue* state) const {
     state->Set("replica_layer", replica_layer_->AsValue().release());
 }
 
+size_t LayerImpl::GPUMemoryUsageInBytes() const { return 0; }
+
 scoped_ptr<base::Value> LayerImpl::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   AsValueInto(state.get());
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index 1798b93..a8f7f1b 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -413,6 +413,7 @@ class CC_EXPORT LayerImpl : LayerAnimationValueObserver {
   virtual void PushPropertiesTo(LayerImpl* layer);
 
   scoped_ptr<base::Value> AsValue() const;
+  virtual size_t GPUMemoryUsageInBytes() const;
 
  protected:
   LayerImpl(LayerTreeImpl* layer_impl, int id);
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 00bb878..eaad533 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -977,4 +977,8 @@ void PictureLayerImpl::AsValueInto(base::DictionaryValue* state) const {
   state->Set("invalidation", invalidation_.AsValue().release());
 }
 
+size_t PictureLayerImpl::GPUMemoryUsageInBytes() const {
+  return tilings_->GPUMemoryUsageInBytes();
+}
+
 }  // namespace cc
diff --git a/cc/layers/picture_layer_impl.h b/cc/layers/picture_layer_impl.h
index f982ea8..38a70c4 100644
--- a/cc/layers/picture_layer_impl.h
+++ b/cc/layers/picture_layer_impl.h
@@ -74,6 +74,8 @@ class CC_EXPORT PictureLayerImpl
 
   virtual bool AreVisibleResourcesReady() const OVERRIDE;
 
+  virtual size_t GPUMemoryUsageInBytes() const OVERRIDE;
+
  protected:
   PictureLayerImpl(LayerTreeImpl* tree_impl, int id);
   PictureLayerTiling* AddTiling(float contents_scale);
diff --git a/cc/layers/tiled_layer_impl.cc b/cc/layers/tiled_layer_impl.cc
index 486628c..4489d85 100644
--- a/cc/layers/tiled_layer_impl.cc
+++ b/cc/layers/tiled_layer_impl.cc
@@ -117,6 +117,21 @@ void TiledLayerImpl::AsValueInto(base::DictionaryValue* state) const {
   state->Set("invalidation", MathUtil::AsValue(update_rect()).release());
 }
 
+size_t TiledLayerImpl::GPUMemoryUsageInBytes() const {
+  size_t amount = 0;
+  const size_t kMemoryUsagePerTileInBytes =
+      4 * tiler_->tile_size().width() * tiler_->tile_size().height();
+  for (LayerTilingData::TileMap::const_iterator iter = tiler_->tiles().begin();
+       iter != tiler_->tiles().end();
+       ++iter) {
+    const DrawableTile* tile = static_cast<DrawableTile*>(iter->second);
+    if (!tile || !tile->resource_id())
+      continue;
+    amount += kMemoryUsagePerTileInBytes;
+  }
+  return amount;
+}
+
 void TiledLayerImpl::PushPropertiesTo(LayerImpl* layer) {
   LayerImpl::PushPropertiesTo(layer);
 
diff --git a/cc/layers/tiled_layer_impl.h b/cc/layers/tiled_layer_impl.h
index f628037..2bd5460 100644
--- a/cc/layers/tiled_layer_impl.h
+++ b/cc/layers/tiled_layer_impl.h
@@ -45,6 +45,10 @@ class CC_EXPORT TiledLayerImpl : public LayerImpl {
   virtual Region VisibleContentOpaqueRegion() const OVERRIDE;
   virtual void DidLoseOutputSurface() OVERRIDE;
 
+  const LayerTilingData* TilingForTesting() const { return tiler_.get(); }
+
+  virtual size_t GPUMemoryUsageInBytes() const OVERRIDE;
+
  protected:
   TiledLayerImpl(LayerTreeImpl* tree_impl, int id);
   // Exposed for testing.
diff --git a/cc/layers/tiled_layer_impl_unittest.cc b/cc/layers/tiled_layer_impl_unittest.cc
index 37bcc2b..8a371fa 100644
--- a/cc/layers/tiled_layer_impl_unittest.cc
+++ b/cc/layers/tiled_layer_impl_unittest.cc
@@ -22,9 +22,7 @@ class TiledLayerImplTest : public testing::Test {
  public:
   TiledLayerImplTest() : host_impl_(&proxy_) {}
 
-  // Create a default tiled layer with textures for all tiles and a default
-  // visibility of the entire layer size.
-  scoped_ptr<TiledLayerImpl> CreateLayer(
+  scoped_ptr<TiledLayerImpl> CreateLayerNoTiles(
       gfx::Size tile_size,
       gfx::Size layer_size,
       LayerTilingData::BorderTexelOption border_texels) {
@@ -42,10 +40,21 @@ class TiledLayerImplTest : public testing::Test {
     layer->SetContentBounds(layer_size);
     layer->CreateRenderSurface();
     layer->draw_properties().render_target = layer.get();
+    return layer.Pass();
+  }
+
+  // Create a default tiled layer with textures for all tiles and a default
+  // visibility of the entire layer size.
+  scoped_ptr<TiledLayerImpl> CreateLayer(
+      gfx::Size tile_size,
+      gfx::Size layer_size,
+      LayerTilingData::BorderTexelOption border_texels) {
+    scoped_ptr<TiledLayerImpl> layer =
+        CreateLayerNoTiles(tile_size, layer_size, border_texels);
 
     ResourceProvider::ResourceId resource_id = 1;
-    for (int i = 0; i < tiler->num_tiles_x(); ++i) {
-      for (int j = 0; j < tiler->num_tiles_y(); ++j) {
+    for (int i = 0; i < layer->TilingForTesting()->num_tiles_x(); ++i) {
+      for (int j = 0; j < layer->TilingForTesting()->num_tiles_y(); ++j) {
         layer->PushTileProperties(
             i, j, resource_id++, gfx::Rect(0, 0, 1, 1), false);
       }
@@ -260,5 +269,34 @@ TEST_F(TiledLayerImplTest, TextureInfoForLayerNoBorders) {
   }
 }
 
+TEST_F(TiledLayerImplTest, GPUMemoryUsage) {
+  gfx::Size tile_size(20, 30);
+  int num_tiles_x = 12;
+  int num_tiles_y = 32;
+  gfx::Size layer_size(tile_size.width() * num_tiles_x,
+                       tile_size.height() * num_tiles_y);
+
+  scoped_ptr<TiledLayerImpl> layer = CreateLayerNoTiles(
+      tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
+
+  EXPECT_EQ(layer->GPUMemoryUsageInBytes(), 0u);
+
+  ResourceProvider::ResourceId resource_id = 1;
+  layer->PushTileProperties(0, 1, resource_id++, gfx::Rect(0, 0, 1, 1), false);
+  layer->PushTileProperties(2, 3, resource_id++, gfx::Rect(0, 0, 1, 1), false);
+  layer->PushTileProperties(2, 0, resource_id++, gfx::Rect(0, 0, 1, 1), false);
+
+  EXPECT_EQ(
+      layer->GPUMemoryUsageInBytes(),
+      static_cast<size_t>(3 * 4 * tile_size.width() * tile_size.height()));
+
+  ResourceProvider::ResourceId empty_resource(0);
+  layer->PushTileProperties(0, 1, empty_resource, gfx::Rect(0, 0, 1, 1), false);
+  layer->PushTileProperties(2, 3, empty_resource, gfx::Rect(0, 0, 1, 1), false);
+  layer->PushTileProperties(2, 0, empty_resource, gfx::Rect(0, 0, 1, 1), false);
+
+  EXPECT_EQ(layer->GPUMemoryUsageInBytes(), 0u);
+}
+
 }  // namespace
 }  // namespace cc
diff --git a/cc/resources/managed_tile_state.cc b/cc/resources/managed_tile_state.cc
index a9452e6..b929fda 100644
--- a/cc/resources/managed_tile_state.cc
+++ b/cc/resources/managed_tile_state.cc
@@ -74,6 +74,12 @@ bool ManagedTileState::DrawingInfo::IsReadyToDraw() const {
   }
 }
 
+size_t ManagedTileState::DrawingInfo::GPUMemoryUsageInBytes() const {
+  if (!resource_)
+    return 0;
+  return resource_->bytes();
+}
+
 ManagedTileState::~ManagedTileState() {
 }
 
diff --git a/cc/resources/managed_tile_state.h b/cc/resources/managed_tile_state.h
index f925053..520211a 100644
--- a/cc/resources/managed_tile_state.h
+++ b/cc/resources/managed_tile_state.h
@@ -65,6 +65,8 @@ class CC_EXPORT ManagedTileState {
                mode_ == PICTURE_PILE_MODE;
       }
 
+      size_t GPUMemoryUsageInBytes() const;
+
       scoped_ptr<ResourcePool::Resource>& GetResourceForTesting() {
         return resource_;
       }
@@ -107,6 +109,7 @@ class CC_EXPORT ManagedTileState {
 
   ManagedTileState();
   ~ManagedTileState();
+
   scoped_ptr<base::Value> AsValue() const;
 
   // Persisted state: valid all the time.
diff --git a/cc/resources/picture_layer_tiling.cc b/cc/resources/picture_layer_tiling.cc
index 1a041f2..8fd52a4 100644
--- a/cc/resources/picture_layer_tiling.cc
+++ b/cc/resources/picture_layer_tiling.cc
@@ -487,6 +487,15 @@ scoped_ptr<base::Value> PictureLayerTiling::AsValue() const {
   return state.PassAs<base::Value>();
 }
 
+size_t PictureLayerTiling::GPUMemoryUsageInBytes() const {
+  size_t amount = 0;
+  for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
+    const Tile* tile = it->second;
+    amount += tile->drawing_info().GPUMemoryUsageInBytes();
+  }
+  return amount;
+}
+
 namespace {
 
 // This struct represents an event at which the expending rect intersects
diff --git a/cc/resources/picture_layer_tiling.h b/cc/resources/picture_layer_tiling.h
index cdb34d4..7c52bd4 100644
--- a/cc/resources/picture_layer_tiling.h
+++ b/cc/resources/picture_layer_tiling.h
@@ -151,6 +151,7 @@ class CC_EXPORT PictureLayerTiling {
   }
 
   scoped_ptr<base::Value> AsValue() const;
+  size_t GPUMemoryUsageInBytes() const;
 
   static gfx::Rect ExpandRectEquallyToAreaBoundedBy(
       gfx::Rect starting_rect,
diff --git a/cc/resources/picture_layer_tiling_set.cc b/cc/resources/picture_layer_tiling_set.cc
index d27a9114..c57e044 100644
--- a/cc/resources/picture_layer_tiling_set.cc
+++ b/cc/resources/picture_layer_tiling_set.cc
@@ -301,4 +301,11 @@ scoped_ptr<base::Value> PictureLayerTilingSet::AsValue() const {
   return state.PassAs<base::Value>();
 }
 
+size_t PictureLayerTilingSet::GPUMemoryUsageInBytes() const {
+  size_t amount = 0;
+  for (size_t i = 0; i < tilings_.size(); ++i)
+    amount += tilings_[i]->GPUMemoryUsageInBytes();
+  return amount;
+}
+
 }  // namespace cc
diff --git a/cc/resources/picture_layer_tiling_set.h b/cc/resources/picture_layer_tiling_set.h
index 716ef5e..b8ff631 100644
--- a/cc/resources/picture_layer_tiling_set.h
+++ b/cc/resources/picture_layer_tiling_set.h
@@ -106,6 +106,7 @@ class CC_EXPORT PictureLayerTilingSet {
   };
 
   scoped_ptr<base::Value> AsValue() const;
+  size_t GPUMemoryUsageInBytes() const;
 
  private:
   PictureLayerTilingClient* client_;