cc: Turn DrawQuad into a struct-like class with public data members.

cc/delegated_renderer_layer_impl.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/delegated_renderer_layer_impl.h"
 
 #include "cc/append_quads_data.h"
 #include "cc/math_util.h"
 #include "cc/quad_sink.h"
 #include "cc/render_pass_draw_quad.h"
@@ skipping 122 matching lines @@
         RenderPass* delegatedRenderPass = m_renderPassesInDrawOrder[renderPassIndex];
         appendRenderPassQuads(quadSink, appendQuadsData, delegatedRenderPass);
     }
 }
 
 void DelegatedRendererLayerImpl::appendRenderPassQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData, RenderPass* delegatedRenderPass) const
 {
     const SharedQuadState* currentSharedQuadState = 0;
     SharedQuadState* copiedSharedQuadState = 0;
     for (size_t i = 0; i < delegatedRenderPass->quadList().size(); ++i) {
-        DrawQuad* quad = delegatedRenderPass->quadList()[i];
+        const DrawQuad* quad = delegatedRenderPass->quadList()[i];
 
-        if (quad->shared_quad_state() != currentSharedQuadState) {
-            currentSharedQuadState = quad->shared_quad_state();
+        if (quad->shared_quad_state != currentSharedQuadState) {
+            currentSharedQuadState = quad->shared_quad_state;
             copiedSharedQuadState = quadSink.useSharedQuadState(currentSharedQuadState->copy());
             bool targetIsFromDelegatedRendererLayer = appendQuadsData.renderPassId.layerId == id();
             if (!targetIsFromDelegatedRendererLayer) {
               // Should be the root render pass.
               DCHECK(delegatedRenderPass == m_renderPassesInDrawOrder.last());
               // This layer must be drawing to a renderTarget other than itself.
               DCHECK(renderTarget() != this);
 
               copiedSharedQuadState->clippedRectInTarget = MathUtil::mapClippedRect(drawTransform(), copiedSharedQuadState->clippedRectInTarget);
               copiedSharedQuadState->quadTransform = copiedSharedQuadState->quadTransform * drawTransform();
               copiedSharedQuadState->opacity *= drawOpacity();
             }
         }
         DCHECK(copiedSharedQuadState);
 
         scoped_ptr<DrawQuad> copyQuad;
-        if (quad->material() != DrawQuad::RENDER_PASS)
+        if (quad->material != DrawQuad::RENDER_PASS)
             copyQuad = quad->Copy(copiedSharedQuadState);
         else {
             RenderPass::Id contributingDelegatedRenderPassId = RenderPassDrawQuad::materialCast(quad)->renderPassId();
             RenderPass::Id contributingRenderPassId = convertDelegatedRenderPassId(contributingDelegatedRenderPassId);
             DCHECK(contributingRenderPassId != appendQuadsData.renderPassId);
 
             copyQuad = RenderPassDrawQuad::materialCast(quad)->copy(copiedSharedQuadState, contributingRenderPassId).PassAs<DrawQuad>();
         }
         DCHECK(copyQuad.get());
 
         quadSink.append(copyQuad.Pass(), appendQuadsData);
     }
 }
 
 const char* DelegatedRendererLayerImpl::layerTypeAsString() const
 {
     return "DelegatedRendererLayer";
 }
 
 }  // namespace cc