cc: Make the DrawQuad subclasses into struct-like classes.

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"
@@ skipping 115 matching lines @@
                 SkColor borderColor;
                 float borderWidth;
 
                 if (m_skipsDraw || !tile || !tile->resourceId()) {
                     borderColor = DebugColors::MissingTileBorderColor();
                     borderWidth = DebugColors::MissingTileBorderWidth(layerTreeHostImpl());
                 } else {
                     borderColor = DebugColors::TileBorderColor();
                     borderWidth = DebugColors::TileBorderWidth(layerTreeHostImpl());
                 }
-                quadSink.append(DebugBorderDrawQuad::create(sharedQuadState, tileRect, borderColor, borderWidth).PassAs<DrawQuad>(), appendQuadsData);
+                scoped_ptr<DebugBorderDrawQuad> debugBorderQuad = DebugBorderDrawQuad::Create();
+                debugBorderQuad->SetNew(sharedQuadState, tileRect, borderColor, borderWidth);
+                quadSink.append(debugBorderQuad.PassAs<DrawQuad>(), appendQuadsData);
             }
         }
     }
 
     if (m_skipsDraw)
         return;
 
     for (int j = top; j <= bottom; ++j) {
         for (int i = left; i <= right; ++i) {
             DrawableTile* tile = tileAt(i, j);
             gfx::Rect tileRect = m_tiler->tileBounds(i, j);
             gfx::Rect displayRect = tileRect;
             tileRect.Intersect(contentRect);
 
             // Skip empty tiles.
             if (tileRect.IsEmpty())
                 continue;
 
             if (!tile || !tile->resourceId()) {
                 if (drawCheckerboardForMissingTiles()) {
                     SkColor checkerColor;
                     if (showDebugBorders())
                         checkerColor = tile ? DebugColors::InvalidatedTileCheckerboardColor() : DebugColors::EvictedTileCheckerboardColor();
                     else
                         checkerColor = kTileCheckerboardColor;
 
-                    appendQuadsData.hadMissingTiles |= quadSink.append(CheckerboardDrawQuad::create(sharedQuadState, tileRect, checkerColor).PassAs<DrawQuad>(), appendQuadsData);
-                } else
-                    appendQuadsData.hadMissingTiles |= quadSink.append(SolidColorDrawQuad::create(sharedQuadState, tileRect, backgroundColor()).PassAs<DrawQuad>(), appendQuadsData);
+                    scoped_ptr<CheckerboardDrawQuad> checkerboardQuad = CheckerboardDrawQuad::Create();
+                    checkerboardQuad->SetNew(sharedQuadState, tileRect, checkerColor);
+                    appendQuadsData.hadMissingTiles |= quadSink.append(checkerboardQuad.PassAs<DrawQuad>(), appendQuadsData);
+                } else {
+                    scoped_ptr<SolidColorDrawQuad> solidColorQuad = SolidColorDrawQuad::Create();
+                    solidColorQuad->SetNew(sharedQuadState, tileRect, backgroundColor());
+                    appendQuadsData.hadMissingTiles |= quadSink.append(solidColorQuad.PassAs<DrawQuad>(), appendQuadsData);
+                }
                 continue;
             }
 
             gfx::Rect tileOpaqueRect = contentsOpaque() ? tileRect : gfx::IntersectRects(tile->opaqueRect(), contentRect);
 
             // Keep track of how the top left has moved, so the texture can be
             // offset the same amount.
             gfx::Vector2d displayOffset = tileRect.origin() - displayRect.origin();
             gfx::Vector2d textureOffset = m_tiler->textureOffset(i, j) + displayOffset;
             gfx::RectF texCoordRect = gfx::RectF(tileRect.size()) + textureOffset;
 
             float tileWidth = static_cast<float>(m_tiler->tileSize().width());
             float tileHeight = static_cast<float>(m_tiler->tileSize().height());
             gfx::Size textureSize(tileWidth, tileHeight);
 
             bool clipped = false;
             gfx::QuadF visibleContentInTargetQuad = MathUtil::mapQuad(drawTransform(), gfx::QuadF(visibleContentRect()), clipped);
             bool isAxisAlignedInTarget = !clipped && visibleContentInTargetQuad.IsRectilinear();
             bool useAA = m_tiler->hasBorderTexels() && !isAxisAlignedInTarget;
 
             bool leftEdgeAA = !i && useAA;
             bool topEdgeAA = !j && useAA;
             bool rightEdgeAA = i == m_tiler->numTilesX() - 1 && useAA;
             bool bottomEdgeAA = j == m_tiler->numTilesY() - 1 && useAA;
 
-            quadSink.append(TileDrawQuad::create(sharedQuadState, tileRect, tileOpaqueRect, tile->resourceId(), texCoordRect, textureSize, tile->contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA).PassAs<DrawQuad>(), appendQuadsData);
+            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)
 {
     if (m_tiler)
         m_tiler->reset();
     else
         m_tiler = LayerTilingData::create(tiler.tileSize(), tiler.hasBorderTexels() ? LayerTilingData::HasBorderTexels : LayerTilingData::NoBorderTexels);
@@ skipping 33 matching lines @@
 {
     m_tiler->reset();
 }
 
 const char* TiledLayerImpl::layerTypeAsString() const
 {
     return "ContentLayer";
 }
 
 }  // namespace cc