cc: Add ResourceId validation checks at the time of AppendQuads.

cc/layers/tiled_layer_impl_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/layers/tiled_layer_impl.h"
 
 #include "cc/layers/append_quads_data.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/resources/layer_tiling_data.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
+#include "cc/test/fake_output_surface.h"
 #include "cc/test/layer_test_common.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
 class TiledLayerImplTest : public testing::Test {
  public:
   TiledLayerImplTest()
-      : host_impl_(&proxy_, &shared_bitmap_manager_, &task_graph_runner_) {}
+      : host_impl_(&proxy_, &shared_bitmap_manager_, &task_graph_runner_) {
+    host_impl_.InitializeRenderer(FakeOutputSurface::Create3d());
+  }
 
   scoped_ptr<TiledLayerImpl> CreateLayerNoTiles(
       const gfx::Size& tile_size,
       const gfx::Size& layer_size,
       LayerTilingData::BorderTexelOption border_texels) {
     scoped_ptr<TiledLayerImpl> layer =
         TiledLayerImpl::Create(host_impl_.active_tree(), 1);
     scoped_ptr<LayerTilingData> tiler =
         LayerTilingData::Create(tile_size, border_texels);
     tiler->SetTilingSize(layer_size);
@@ skipping 11 matching lines @@
 
   // Create a default tiled layer with textures for all tiles and a default
   // visibility of the entire layer size.
   scoped_ptr<TiledLayerImpl> CreateLayer(
       const gfx::Size& tile_size,
       const 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 < layer->TilingForTesting()->num_tiles_x(); ++i) {
-      for (int j = 0; j < layer->TilingForTesting()->num_tiles_y(); ++j)
-        layer->PushTileProperties(i, j, resource_id++, false);
+      for (int j = 0; j < layer->TilingForTesting()->num_tiles_y(); ++j) {
+        ResourceProvider::ResourceId resource_id =
+            host_impl_.resource_provider()->CreateResource(
+                gfx::Size(1, 1), GL_CLAMP_TO_EDGE,
+                ResourceProvider::TEXTURE_HINT_IMMUTABLE, RGBA_8888);
+        layer->PushTileProperties(i, j, resource_id, false);
+      }
     }
 
     return layer.Pass();
   }
 
   void GetQuads(RenderPass* render_pass,
                 const gfx::Size& tile_size,
                 const gfx::Size& layer_size,
                 LayerTilingData::BorderTexelOption border_texel_option,
                 const gfx::Rect& visible_content_rect) {
@@ skipping 256 matching lines @@
   tiled_layer->SetBounds(layer_bounds);
   tiled_layer->SetContentBounds(layer_bounds);
   tiled_layer->SetDrawsContent(true);
   tiled_layer->set_skips_draw(false);
 
   scoped_ptr<LayerTilingData> tiler =
       LayerTilingData::Create(tile_size, LayerTilingData::NO_BORDER_TEXELS);
   tiler->SetTilingSize(layer_bounds);
   tiled_layer->SetTilingData(*tiler);
 
-  ResourceProvider::ResourceId resource_id = 1;
   for (int i = 0; i < tiled_layer->TilingForTesting()->num_tiles_x(); ++i) {
-    for (int j = 0; j < tiled_layer->TilingForTesting()->num_tiles_y(); ++j)
-      tiled_layer->PushTileProperties(i, j, resource_id++, false);
+    for (int j = 0; j < tiled_layer->TilingForTesting()->num_tiles_y(); ++j) {
+      ResourceProvider::ResourceId resource_id =
+          impl.resource_provider()->CreateResource(
+              gfx::Size(1, 1), GL_CLAMP_TO_EDGE,
+              ResourceProvider::TEXTURE_HINT_IMMUTABLE, RGBA_8888);
+      tiled_layer->PushTileProperties(i, j, resource_id, false);
+    }
   }
 
   impl.CalcDrawProps(viewport_size);
 
   {
     SCOPED_TRACE("No occlusion");
     gfx::Rect occluded;
     impl.AppendQuadsWithOcclusion(tiled_layer, occluded);
 
     LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
@@ skipping 19 matching lines @@
     LayerTestCommon::VerifyQuadsAreOccluded(
         impl.quad_list(), occluded, &partially_occluded_count);
     // The layer outputs one quad, which is partially occluded.
     EXPECT_EQ(100u - 10u, impl.quad_list().size());
     EXPECT_EQ(10u + 10u, partially_occluded_count);
   }
 }
 
 }  // namespace
 }  // namespace cc