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

This will help us track down how an invalid resource is ending up in
the frame hopefully.

R=enne, piman@chromium.org
BUG=455931

Review URL: https://codereview.chromium.org/1062043003

Cr-Commit-Position: refs/heads/master@{#324103}

cc/layers/delegated_renderer_layer_impl.cc

@@ -394,6 +394,14 @@ void DelegatedRendererLayerImpl::AppendRainbowDebugBorder(
   }
 }
 
+// TODO(danakj): crbug.com/455931
+static ResourceProvider::ResourceId ValidateResource(
+    ResourceProvider* provider,
+    ResourceProvider::ResourceId id) {
+  provider->ValidateResource(id);
+  return id;
+}
+
 void DelegatedRendererLayerImpl::AppendRenderPassQuads(
     RenderPass* render_pass,
     const RenderPass* delegated_render_pass,
@@ -488,6 +496,10 @@ void DelegatedRendererLayerImpl::AppendRenderPassQuads(
         output_quad->visible_rect = quad_visible_rect;
       }
     }
+
+    // TODO(danakj): crbug.com/455931
+    render_pass->quad_list.back()->IterateResources(
+        base::Bind(&ValidateResource, layer_tree_impl()->resource_provider()));
   }
 }
 

cc/layers/heads_up_display_layer_impl.cc

@@ -159,6 +159,9 @@ void HeadsUpDisplayLayerImpl::AppendQuads(
   bool nearest_neighbor = false;
   TextureDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
+  // TODO(danakj): crbug.com/455931
+  layer_tree_impl()->resource_provider()->ValidateResource(
+      resources_.back()->id());
   quad->SetNew(shared_quad_state,
                quad_rect,
                opaque_rect,

cc/layers/io_surface_layer_impl.cc

@@ -77,6 +77,9 @@ void IOSurfaceLayerImpl::AppendQuads(
   if (visible_quad_rect.IsEmpty())
     return;
 
+  // TODO(danakj): crbug.com/455931
+  layer_tree_impl()->resource_provider()->ValidateResource(
+      io_surface_resource_id_);
   IOSurfaceDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<IOSurfaceDrawQuad>();
   quad->SetNew(shared_quad_state,

cc/layers/io_surface_layer_impl_unittest.cc

@@ -22,6 +22,10 @@ TEST(IOSurfaceLayerImplTest, Occlusion) {
   io_surface_layer_impl->SetContentBounds(layer_size);
   io_surface_layer_impl->SetDrawsContent(true);
 
+  io_surface_layer_impl->SetIOSurfaceProperties(1, gfx::Size(1, 1));
+  io_surface_layer_impl->WillDraw(DRAW_MODE_HARDWARE, impl.resource_provider());
+  io_surface_layer_impl->DidDraw(impl.resource_provider());
+
   impl.CalcDrawProps(viewport_size);
 
   {

cc/layers/nine_patch_layer_impl.cc

@@ -100,6 +100,9 @@ void NinePatchLayerImpl::AppendQuads(
   if (!resource)
     return;
 
+  // TODO(danakj): crbug.com/455931
+  layer_tree_impl()->resource_provider()->ValidateResource(resource);
+
   static const bool flipped = false;
   static const bool nearest_neighbor = false;
   static const bool premultiplied_alpha = true;

cc/layers/nine_patch_layer_impl_unittest.cc

@@ -9,6 +9,7 @@
 #include "cc/resources/ui_resource_bitmap.h"
 #include "cc/resources/ui_resource_client.h"
 #include "cc/test/fake_impl_proxy.h"
+#include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_ui_resource_layer_tree_host_impl.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_test_common.h"
@@ -45,6 +46,8 @@ void NinePatchLayerLayoutTest(const gfx::Size& bitmap_size,
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeUIResourceLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
+  host_impl.InitializeRenderer(FakeOutputSurface::Create3d());
+
   scoped_ptr<NinePatchLayerImpl> layer =
       NinePatchLayerImpl::Create(host_impl.active_tree(), 1);
   layer->draw_properties().visible_content_rect = visible_content_rect;

cc/layers/painted_scrollbar_layer_impl.cc

@@ -103,6 +103,8 @@ void PaintedScrollbarLayerImpl::AppendQuads(
   if (thumb_resource_id && !visible_thumb_quad_rect.IsEmpty()) {
     gfx::Rect opaque_rect;
     const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
+    // TODO(danakj): crbug.com/455931
+    layer_tree_impl()->resource_provider()->ValidateResource(thumb_resource_id);
     TextureDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
     quad->SetNew(shared_quad_state, scaled_thumb_quad_rect, opaque_rect,
@@ -122,6 +124,8 @@ void PaintedScrollbarLayerImpl::AppendQuads(
     gfx::Rect opaque_rect(contents_opaque() ? scaled_track_quad_rect
                                             : gfx::Rect());
     const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
+    // TODO(danakj): crbug.com/455931
+    layer_tree_impl()->resource_provider()->ValidateResource(track_resource_id);
     TextureDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
     quad->SetNew(shared_quad_state, scaled_track_quad_rect, opaque_rect,

cc/layers/picture_layer_impl.cc

@@ -305,6 +305,9 @@ void PictureLayerImpl::AppendQuads(RenderPass* render_pass,
             append_quads_data->num_incomplete_tiles++;
           }
 
+          // TODO(danakj): crbug.com/455931
+          layer_tree_impl()->resource_provider()->ValidateResource(
+              draw_info.resource_id());
           TileDrawQuad* quad =
               render_pass->CreateAndAppendDrawQuad<TileDrawQuad>();
           quad->SetNew(shared_quad_state, geometry_rect, opaque_rect,

cc/layers/texture_layer_impl.cc

@@ -167,6 +167,8 @@ void TextureLayerImpl::AppendQuads(RenderPass* render_pass,
       render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   ResourceProvider::ResourceId id =
       valid_texture_copy_ ? texture_copy_->id() : external_texture_resource_;
+  // TODO(danakj): crbug.com/455931
+  layer_tree_impl()->resource_provider()->ValidateResource(id);
   quad->SetNew(shared_quad_state,
                quad_rect,
                opaque_rect,

cc/layers/tiled_layer_impl.cc

@@ -16,6 +16,7 @@
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/resources/layer_tiling_data.h"
+#include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/occlusion.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/geometry/quad_f.h"
@@ -259,6 +260,9 @@ void TiledLayerImpl::AppendQuads(RenderPass* render_pass,
       float tile_height = static_cast<float>(tiler_->tile_size().height());
       gfx::Size texture_size(tile_width, tile_height);
 
+      // TODO(danakj): crbug.com/455931
+      layer_tree_impl()->resource_provider()->ValidateResource(
+          tile->resource_id());
       TileDrawQuad* quad = render_pass->CreateAndAppendDrawQuad<TileDrawQuad>();
       quad->SetNew(shared_quad_state,
                    tile_rect,

cc/layers/tiled_layer_impl_unittest.cc

@@ -9,6 +9,7 @@
 #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"
@@ -21,7 +22,9 @@ 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,
@@ -53,10 +56,14 @@ class TiledLayerImplTest : public testing::Test {
     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();
@@ -333,10 +340,14 @@ TEST_F(TiledLayerImplTest, Occlusion) {
   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);

cc/layers/ui_resource_layer_impl.cc

@@ -110,6 +110,9 @@ void UIResourceLayerImpl::AppendQuads(
   if (!resource)
     return;
 
+  // TODO(danakj): crbug.com/455931
+  layer_tree_impl()->resource_provider()->ValidateResource(resource);
+
   static const bool flipped = false;
   static const bool nearest_neighbor = false;
   static const bool premultiplied_alpha = true;

cc/layers/ui_resource_layer_impl_unittest.cc

@@ -9,6 +9,7 @@
 #include "cc/resources/ui_resource_client.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/fake_ui_resource_layer_tree_host_impl.h"
 #include "cc/test/layer_test_common.h"
 #include "cc/test/test_shared_bitmap_manager.h"
@@ -59,6 +60,8 @@ TEST(UIResourceLayerImplTest, VerifyDrawQuads) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeUIResourceLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
+  host_impl.InitializeRenderer(FakeOutputSurface::Create3d());
+
   // Make sure we're appending quads when there are valid values.
   gfx::Size bitmap_size(100, 100);
   gfx::Size layer_size(100, 100);;
@@ -101,6 +104,7 @@ TEST(UIResourceLayerImplTest, VerifySetOpaqueOnSkBitmap) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeUIResourceLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
+  host_impl.InitializeRenderer(FakeOutputSurface::Create3d());
 
   gfx::Size bitmap_size(100, 100);
   gfx::Size layer_size(100, 100);;
@@ -128,6 +132,7 @@ TEST(UIResourceLayerImplTest, VerifySetOpaqueOnLayer) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeUIResourceLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
+  host_impl.InitializeRenderer(FakeOutputSurface::Create3d());
 
   gfx::Size bitmap_size(100, 100);
   gfx::Size layer_size(100, 100);

cc/layers/video_layer_impl.cc

@@ -201,6 +201,9 @@ void VideoLayerImpl::AppendQuads(RenderPass* render_pass,
       float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
       bool flipped = false;
       bool nearest_neighbor = false;
+      // TODO(danakj): crbug.com/455931
+      layer_tree_impl()->resource_provider()->ValidateResource(
+          software_resources_[0]);
       TextureDrawQuad* texture_quad =
           render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
       texture_quad->SetNew(shared_quad_state,
@@ -240,6 +243,17 @@ void VideoLayerImpl::AppendQuads(RenderPass* render_pass,
                    frame_->format(), media::VideoFrame::kAPlane, coded_size));
       }
 
+      // TODO(danakj): crbug.com/455931
+      layer_tree_impl()->resource_provider()->ValidateResource(
+          frame_resources_[0]);
+      layer_tree_impl()->resource_provider()->ValidateResource(
+          frame_resources_[1]);
+      layer_tree_impl()->resource_provider()->ValidateResource(
+          frame_resources_[2]);
+      if (frame_resources_.size() > 3) {
+        layer_tree_impl()->resource_provider()->ValidateResource(
+            frame_resources_[3]);
+      }
       gfx::RectF tex_coord_rect(
           tex_x_offset, tex_y_offset, tex_width_scale, tex_height_scale);
       YUVVideoDrawQuad* yuv_video_quad =
@@ -261,6 +275,9 @@ void VideoLayerImpl::AppendQuads(RenderPass* render_pass,
       float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
       bool flipped = false;
       bool nearest_neighbor = false;
+      // TODO(danakj): crbug.com/455931
+      layer_tree_impl()->resource_provider()->ValidateResource(
+          frame_resources_[0]);
       TextureDrawQuad* texture_quad =
           render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
       texture_quad->SetNew(shared_quad_state,
@@ -281,6 +298,9 @@ void VideoLayerImpl::AppendQuads(RenderPass* render_pass,
       DCHECK_EQ(frame_resources_.size(), 1u);
       if (frame_resources_.size() < 1u)
         break;
+      // TODO(danakj): crbug.com/455931
+      layer_tree_impl()->resource_provider()->ValidateResource(
+          frame_resources_[0]);
       gfx::Transform scale;
       scale.Scale(tex_width_scale, tex_height_scale);
       StreamVideoDrawQuad* stream_video_quad =
@@ -295,6 +315,9 @@ void VideoLayerImpl::AppendQuads(RenderPass* render_pass,
       DCHECK_EQ(frame_resources_.size(), 1u);
       if (frame_resources_.size() < 1u)
         break;
+      // TODO(danakj): crbug.com/455931
+      layer_tree_impl()->resource_provider()->ValidateResource(
+          frame_resources_[0]);
       IOSurfaceDrawQuad* io_surface_quad =
           render_pass->CreateAndAppendDrawQuad<IOSurfaceDrawQuad>();
       io_surface_quad->SetNew(shared_quad_state,

cc/resources/resource_provider.cc

@@ -870,7 +870,7 @@ base::TimeTicks ResourceProvider::EstimatedUploadCompletionTime(
 
 ResourceProvider::Resource* ResourceProvider::GetResource(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  // Try to differentiate GetResource with a bad id vs with no id.
+  // TODO(danakj): crbug.com/455931
   CHECK(id);
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
@@ -2132,6 +2132,13 @@ GLint ResourceProvider::GetActiveTextureUnit(GLES2Interface* gl) {
   return active_unit;
 }
 
+void ResourceProvider::ValidateResource(ResourceId id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  CHECK(id);
+  ResourceMap::iterator it = resources_.find(id);
+  CHECK(it != resources_.end());
+}
+
 GLES2Interface* ResourceProvider::ContextGL() const {
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->ContextGL() : NULL;

cc/resources/resource_provider.h

@@ -435,6 +435,8 @@ class CC_EXPORT ResourceProvider {
 
   OutputSurface* output_surface() { return output_surface_; }
 
+  void ValidateResource(ResourceId id);
+
  private:
   struct Resource {
     enum Origin { INTERNAL, EXTERNAL, DELEGATED };

cc/test/fake_ui_resource_layer_tree_host_impl.cc

@@ -12,8 +12,7 @@ namespace cc {
 FakeUIResourceLayerTreeHostImpl::FakeUIResourceLayerTreeHostImpl(
     Proxy* proxy,
     SharedBitmapManager* manager)
-    : FakeLayerTreeHostImpl(proxy, manager, nullptr),
-      fake_next_resource_id_(1) {
+    : FakeLayerTreeHostImpl(proxy, manager, nullptr) {
 }
 
 FakeUIResourceLayerTreeHostImpl::~FakeUIResourceLayerTreeHostImpl() {}
@@ -25,7 +24,10 @@ void FakeUIResourceLayerTreeHostImpl::CreateUIResource(
     DeleteUIResource(uid);
 
   UIResourceData data;
-  data.resource_id = fake_next_resource_id_++;
+  data.resource_id = resource_provider()->CreateResource(
+      bitmap.GetSize(), GL_CLAMP_TO_EDGE,
+      ResourceProvider::TEXTURE_HINT_IMMUTABLE, RGBA_8888);
+
   data.size = bitmap.GetSize();
   data.opaque = bitmap.GetOpaque();
   fake_ui_resource_map_[uid] = data;

cc/test/fake_ui_resource_layer_tree_host_impl.h

@@ -27,7 +27,6 @@ class FakeUIResourceLayerTreeHostImpl : public FakeLayerTreeHostImpl {
   bool IsUIResourceOpaque(UIResourceId uid) const override;
 
  private:
-  ResourceProvider::ResourceId fake_next_resource_id_;
   typedef base::hash_map<UIResourceId, LayerTreeHostImpl::UIResourceData>
       UIResourceMap;
   UIResourceMap fake_ui_resource_map_;