cc: Temporary diagnostics.

cc/tiled_layer_impl.cc

 // Copyright 2011 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/tiled_layer_impl.h"
 
 #include "base/basictypes.h"
 #include "base/stringprintf.h"
 #include "cc/append_quads_data.h"
 #include "cc/checkerboard_draw_quad.h"
 #include "cc/debug_border_draw_quad.h"
 #include "cc/debug_colors.h"
 #include "cc/layer_tiling_data.h"
 #include "cc/math_util.h"
 #include "cc/quad_sink.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/tile_draw_quad.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/quad_f.h"
 
 using namespace std;
 
 namespace cc {
 
+// Temporary diagnostic.
+static bool safeToDeleteDrawableTile = false;
+
 class DrawableTile : public LayerTilingData::Tile {
 public:
     static scoped_ptr<DrawableTile> create() { return make_scoped_ptr(new DrawableTile()); }
 
+    virtual ~DrawableTile() { CHECK(safeToDeleteDrawableTile); }
+
     ResourceProvider::ResourceId resourceId() const { return m_resourceId; }
     void setResourceId(ResourceProvider::ResourceId resourceId) { m_resourceId = resourceId; }
     bool contentsSwizzled() { return m_contentsSwizzled; }
     void setContentsSwizzled(bool contentsSwizzled) { m_contentsSwizzled = contentsSwizzled; }
 
 private:
     DrawableTile()
         : m_resourceId(0)
         , m_contentsSwizzled(false) { }
 
     ResourceProvider::ResourceId m_resourceId;
     bool m_contentsSwizzled;
 
     DISALLOW_COPY_AND_ASSIGN(DrawableTile);
 };
 
 TiledLayerImpl::TiledLayerImpl(int id)
     : LayerImpl(id)
     , m_skipsDraw(true)
 {
 }
 
 TiledLayerImpl::~TiledLayerImpl()
 {
+    safeToDeleteDrawableTile = true;
+    if (m_tiler)
+      m_tiler->reset();
+    safeToDeleteDrawableTile = false;
 }
 
 ResourceProvider::ResourceId TiledLayerImpl::contentsResourceId() const
 {
     // This function is only valid for single texture layers, e.g. masks.
     DCHECK(m_tiler);
     DCHECK(m_tiler->numTilesX() == 1);
     DCHECK(m_tiler->numTilesY() == 1);
 
     DrawableTile* tile = tileAt(0, 0);
@@ skipping 21 matching lines @@
 DrawableTile* TiledLayerImpl::tileAt(int i, int j) const
 {
     return static_cast<DrawableTile*>(m_tiler->tileAt(i, j));
 }
 
 DrawableTile* TiledLayerImpl::createTile(int i, int j)
 {
     scoped_ptr<DrawableTile> tile(DrawableTile::create());
     DrawableTile* addedTile = tile.get();
     m_tiler->addTile(tile.PassAs<LayerTilingData::Tile>(), i, j);
+
+    // Temporary diagnostic checks.
+    CHECK(addedTile);

[enne (OOO), 2012/12/04 00:57:02]

I've added these checks in the past and never gotten anything from them.  :(

+    CHECK(tileAt(i, j));
+
     return addedTile;
 }
 
 void TiledLayerImpl::getDebugBorderProperties(SkColor* color, float* width) const
 {
     *color = DebugColors::TiledContentLayerBorderColor();
     *width = DebugColors::TiledContentLayerBorderWidth(layerTreeHostImpl());
 }
 
 void TiledLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData)
@@ skipping 88 matching lines @@
 
             scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
             quad->SetNew(sharedQuadState, tileRect, tileOpaqueRect, tile->resourceId(), texCoordRect, textureSize, tile->contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
             quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
         }
     }
 }
 
 void TiledLayerImpl::setTilingData(const LayerTilingData& tiler)
 {
+    safeToDeleteDrawableTile = true;
+
     if (m_tiler)
         m_tiler->reset();
     else
         m_tiler = LayerTilingData::create(tiler.tileSize(), tiler.hasBorderTexels() ? LayerTilingData::HasBorderTexels : LayerTilingData::NoBorderTexels);
     *m_tiler = tiler;
+
+    safeToDeleteDrawableTile = false;
 }
 
 void TiledLayerImpl::pushTileProperties(int i, int j, ResourceProvider::ResourceId resourceId, const gfx::Rect& opaqueRect, bool contentsSwizzled)
 {
     DrawableTile* tile = tileAt(i, j);
     if (!tile)
         tile = createTile(i, j);
     tile->setResourceId(resourceId);
     tile->setOpaqueRect(opaqueRect);
     tile->setContentsSwizzled(contentsSwizzled);
@@ skipping 13 matching lines @@
 {
     if (m_skipsDraw)
         return Region();
     if (contentsOpaque())
         return visibleContentRect();
     return m_tiler->opaqueRegionInContentRect(visibleContentRect());
 }
 
 void TiledLayerImpl::didLoseContext()
 {
+    safeToDeleteDrawableTile = true;
+    // Temporary diagnostic check.
+    CHECK(m_tiler);
     m_tiler->reset();
+    safeToDeleteDrawableTile = false;
 }
 
 const char* TiledLayerImpl::layerTypeAsString() const
 {
     return "ContentLayer";
 }
 
 }  // namespace cc