cc: Rename LayerImpl::DidLoseOutputSurface to ReleaseResources

cc/layers/picture_layer_impl_unittest.cc

 // 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.
 
 #include "cc/layers/picture_layer_impl.h"
 
 #include <utility>
 
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/picture_layer.h"
@@ skipping 146 matching lines @@
         contents_scale,
         device_scale_factor,
         page_scale_factor,
         animating_transform,
         &result_scale_x,
         &result_scale_y,
         &result_bounds);
   }
 
   void ResetTilingsAndRasterScales() {
-    pending_layer_->DidLoseOutputSurface();
-    active_layer_->DidLoseOutputSurface();
+    pending_layer_->ReleaseResources();
+    active_layer_->ReleaseResources();
   }
 
   void AssertAllTilesRequired(PictureLayerTiling* tiling) {
     std::vector<Tile*> tiles = tiling->AllTilesForTesting();
     for (size_t i = 0; i < tiles.size(); ++i)
       EXPECT_TRUE(tiles[i]->required_for_activation()) << "i: " << i;
     EXPECT_GT(tiles.size(), 0u);
   }
 
   void AssertNoTilesRequired(PictureLayerTiling* tiling) {
@@ skipping 806 matching lines @@
 
   // Mask layers dont create low res since they always fit on one tile.
   pending_layer_->SetIsMask(true);
   active_layer_->SetIsMask(true);
   SetContentsScaleOnBothLayers(
       contents_scale, device_scale, page_scale, animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
   EXPECT_BOTH_EQ(num_tilings(), 1u);
 }
 
-TEST_F(PictureLayerImplTest, DidLoseOutputSurface) {
+TEST_F(PictureLayerImplTest, ReleaseResources) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->CalculateContentsScale(1.3f,  // ideal contents scale
                                          2.7f,  // device scale
                                          3.2f,  // page cale
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
   EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
 
   // All tilings should be removed when losing output surface.
-  active_layer_->DidLoseOutputSurface();
+  active_layer_->ReleaseResources();
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
-  pending_layer_->DidLoseOutputSurface();
+  pending_layer_->ReleaseResources();
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   // This should create new tilings.
   pending_layer_->CalculateContentsScale(1.3f,  // ideal contents scale
                                          2.7f,  // device scale
                                          3.2f,  // page cale
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
@@ skipping 23 matching lines @@
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
 
   // The default value.
   EXPECT_EQ(gfx::Size(256, 256).ToString(),
             host_impl_.settings().default_tile_size.ToString());
 
   Tile* tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
   EXPECT_EQ(gfx::Size(256, 256).ToString(),
             tile->content_rect().size().ToString());
 
-  pending_layer_->DidLoseOutputSurface();
+  pending_layer_->ReleaseResources();
 
   // Change the max texture size on the output surface context.
   scoped_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   context->set_max_texture_size(140);
   host_impl_.DidLoseOutputSurface();
   host_impl_.InitializeRenderer(FakeOutputSurface::Create3d(
       context.Pass()).PassAs<OutputSurface>());
 
   pending_layer_->CalculateContentsScale(
@@ skipping 31 matching lines @@
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
 
   // The default value. The layer is smaller than this.
   EXPECT_EQ(gfx::Size(512, 512).ToString(),
             host_impl_.settings().max_untiled_layer_size.ToString());
 
   // There should be a single tile since the layer is small.
   PictureLayerTiling* high_res_tiling = pending_layer_->tilings()->tiling_at(0);
   EXPECT_EQ(1u, high_res_tiling->AllTilesForTesting().size());
 
-  pending_layer_->DidLoseOutputSurface();
+  pending_layer_->ReleaseResources();
 
   // Change the max texture size on the output surface context.
   scoped_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   context->set_max_texture_size(140);
   host_impl_.DidLoseOutputSurface();
   host_impl_.InitializeRenderer(FakeOutputSurface::Create3d(
       context.Pass()).PassAs<OutputSurface>());
 
   pending_layer_->CalculateContentsScale(
@@ skipping 258 matching lines @@
 
 TEST_F(PictureLayerImplTest, SyncTilingAfterReleaseResource) {
   SetupDefaultTrees(gfx::Size(10, 10));
   host_impl_.active_tree()->UpdateDrawProperties();
   EXPECT_FALSE(host_impl_.active_tree()->needs_update_draw_properties());
 
   // Contrived unit test of a real crash. A layer is transparent during a
   // context loss, and later becomes opaque, causing active layer SyncTiling to
   // be called.
   const float tile_scale = 2.f;
-  active_layer_->DidLoseOutputSurface();
+  active_layer_->ReleaseResources();
   EXPECT_FALSE(active_layer_->tilings()->TilingAtScale(tile_scale));
   pending_layer_->AddTiling(2.f);
   EXPECT_TRUE(active_layer_->tilings()->TilingAtScale(tile_scale));
 }
 
 TEST_F(PictureLayerImplTest, TileSizeForGpuRasterization) {
   gfx::Size default_tile_size_gpu(
       host_impl_.settings().default_tile_size_gpu_rasterization);
   gfx::Size layer_bounds(default_tile_size_gpu.width() + 1,
                          default_tile_size_gpu.height() + 1);
@@ skipping 144 matching lines @@
       TestContextProvider::Create(), NULL));
 
   // These will crash PictureLayerImpl if this is not true.
   ASSERT_TRUE(host_impl_.pending_tree()->needs_update_draw_properties());
   ASSERT_TRUE(host_impl_.active_tree()->needs_update_draw_properties());
   host_impl_.active_tree()->UpdateDrawProperties();
 }
 
 }  // namespace
 }  // namespace cc