cc: Explicitly invalidate all dropped recordings on the main thread.

cc/resources/picture_layer_tiling_set_unittest.cc

 // Copyright 2012 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/resources/picture_layer_tiling_set.h"
 
 #include <map>
 #include <vector>
 
 #include "cc/resources/resource_pool.h"
@@ skipping 212 matching lines @@
       EXPECT_TRUE(tiling->live_tiles_rect().IsEmpty());
     else if (!tiling->live_tiles_rect().IsEmpty())
       EXPECT_TRUE(tiling->TilingRect().Contains(tiling->live_tiles_rect()));
 
     std::vector<Tile*> tiles = tiling->AllTilesForTesting();
     for (size_t i = 0; i < tiles.size(); ++i) {
       const Tile* tile = tiles[i];
       ASSERT_TRUE(!!tile);
       EXPECT_EQ(tile->picture_pile(), pile);
       EXPECT_TRUE(tile->content_rect().Intersects(tiling->live_tiles_rect()))
-          << "All tiles must be inside the live tiles rect.";
+          << "All tiles must be inside the live tiles rect."
+          << " Tile rect: " << tile->content_rect().ToString()
+          << " Live rect: " << tiling->live_tiles_rect().ToString()
+          << " Scale: " << tiling->contents_scale();
     }
 
     for (PictureLayerTiling::CoverageIterator iter(
              tiling, tiling->contents_scale(), tiling->live_tiles_rect());
          iter;
          ++iter) {
       EXPECT_TRUE(*iter) << "The live tiles rect must be full.";
     }
   }
 
@@ skipping 36 matching lines @@
   std::vector<Tile*> tiles = tiling->AllTilesForTesting();
   for (size_t i = 0; i < tiles.size(); ++i) {
     if (tiles[i]->content_rect().origin() == gfx::Point())
       return tiles[i];
   }
   return NULL;
 }
 
 TEST_F(PictureLayerTilingSetSyncTest, KeepExisting) {
   float source_scales[] = {0.7f, 1.f, 1.1f, 2.f};
-  for (size_t i = 0; i < arraysize(source_scales); ++i)
+  for (size_t i = 1; i < arraysize(source_scales); ++i)
     source_->AddTiling(source_scales[i]);
   float target_scales[] = {0.5f, 1.f, 2.f};
-  for (size_t i = 0; i < arraysize(target_scales); ++i)
+  for (size_t i = 1; i < arraysize(target_scales); ++i)
     target_->AddTiling(target_scales[i]);
 
   PictureLayerTiling* tiling1 = source_->TilingAtScale(1.f);
   ASSERT_TRUE(tiling1);
   tiling1->CreateAllTilesForTesting();
   EXPECT_EQ(tiling1->contents_scale(), 1.f);
   Tile* tile1 = FindTileAtOrigin(tiling1);
   ASSERT_TRUE(tile1);
 
   PictureLayerTiling* tiling2 = source_->TilingAtScale(2.f);
@@ skipping 105 matching lines @@
   std::vector<Tile*> new_tiles = target_->tiling_at(0)->AllTilesForTesting();
   for (size_t i = 0; i < original_tiles.size(); ++i) {
     std::vector<Tile*>::iterator find =
         std::find(new_tiles.begin(), new_tiles.end(), original_tiles[i]);
     EXPECT_TRUE(find == new_tiles.end());
   }
 }
 
 }  // namespace
 }  // namespace cc