cc: Convert non-const reference arguments to pointers.

cc/output/direct_renderer.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/output/direct_renderer.h"
 
 #include <vector>
 
 #include "base/debug/trace_event.h"
 #include "base/metrics/histogram.h"
@@ skipping 59 matching lines @@
 void DirectRenderer::QuadRectTransform(gfx::Transform* quad_rect_transform,
                                        const gfx::Transform& quad_transform,
                                        const gfx::RectF& quad_rect) {
   *quad_rect_transform = quad_transform;
   quad_rect_transform->Translate(0.5 * quad_rect.width() + quad_rect.x(),
                                  0.5 * quad_rect.height() + quad_rect.y());
   quad_rect_transform->Scale(quad_rect.width(), quad_rect.height());
 }
 
 // static
-void DirectRenderer::InitializeMatrices(DrawingFrame& frame,
+void DirectRenderer::InitializeMatrices(DrawingFrame* frame,
                                         gfx::Rect draw_rect,
                                         bool flip_y) {
   if (flip_y) {
-    frame.projection_matrix = OrthoProjectionMatrix(draw_rect.x(),
-                                                    draw_rect.right(),
-                                                    draw_rect.bottom(),
-                                                    draw_rect.y());
+    frame->projection_matrix = OrthoProjectionMatrix(draw_rect.x(),
+                                                     draw_rect.right(),
+                                                     draw_rect.bottom(),
+                                                     draw_rect.y());
   } else {
-    frame.projection_matrix = OrthoProjectionMatrix(draw_rect.x(),
-                                                    draw_rect.right(),
-                                                    draw_rect.y(),
-                                                    draw_rect.bottom());
+    frame->projection_matrix = OrthoProjectionMatrix(draw_rect.x(),
+                                                     draw_rect.right(),
+                                                     draw_rect.y(),
+                                                     draw_rect.bottom());
   }
-  frame.window_matrix =
+  frame->window_matrix =
       window_matrix(0, 0, draw_rect.width(), draw_rect.height());
-  frame.flipped_y = flip_y;
+  frame->flipped_y = flip_y;
 }
 
 // static
 gfx::Rect DirectRenderer::MoveScissorToWindowSpace(
-    const DrawingFrame& frame, const gfx::RectF& scissor_rect) {
+    const DrawingFrame* frame, const gfx::RectF& scissor_rect) {
   gfx::Rect scissor_rect_in_canvas_space = gfx::ToEnclosingRect(scissor_rect);
   // The scissor coordinates must be supplied in viewport space so we need to
   // offset by the relative position of the top left corner of the current
   // render pass.
-  gfx::Rect framebuffer_output_rect = frame.current_render_pass->output_rect;
+  gfx::Rect framebuffer_output_rect = frame->current_render_pass->output_rect;
   scissor_rect_in_canvas_space.set_x(
       scissor_rect_in_canvas_space.x() - framebuffer_output_rect.x());
-  if (frame.flipped_y && !frame.current_texture) {
+  if (frame->flipped_y && !frame->current_texture) {
     scissor_rect_in_canvas_space.set_y(
         framebuffer_output_rect.height() -
         (scissor_rect_in_canvas_space.bottom() - framebuffer_output_rect.y()));
   } else {
     scissor_rect_in_canvas_space.set_y(
         scissor_rect_in_canvas_space.y() - framebuffer_output_rect.y());
   }
   return scissor_rect_in_canvas_space;
 }
 
@@ skipping 49 matching lines @@
   for (size_t i = 0; i < render_passes_in_draw_order.size(); ++i) {
     if (!render_pass_textures_.contains(render_passes_in_draw_order[i]->id)) {
       scoped_ptr<CachedResource> texture =
           CachedResource::Create(resource_provider_);
       render_pass_textures_.set(render_passes_in_draw_order[i]->id,
                               texture.Pass());
     }
   }
 }
 
-void DirectRenderer::DrawFrame(RenderPassList& render_passes_in_draw_order) {
+void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order) {
   TRACE_EVENT0("cc", "DirectRenderer::DrawFrame");
   UMA_HISTOGRAM_COUNTS("Renderer4.renderPassCount",
-                       render_passes_in_draw_order.size());
+                       render_passes_in_draw_order->size());
 
-  const RenderPass* root_render_pass = render_passes_in_draw_order.back();
+  const RenderPass* root_render_pass = render_passes_in_draw_order->back();
   DCHECK(root_render_pass);
 
   DrawingFrame frame;
   frame.root_render_pass = root_render_pass;
   frame.root_damage_rect =
       Capabilities().using_partial_swap ?
       root_render_pass->damage_rect : root_render_pass->output_rect;
   frame.root_damage_rect.Intersect(gfx::Rect(ViewportSize()));
 
-  BeginDrawingFrame(frame);
-  for (size_t i = 0; i < render_passes_in_draw_order.size(); ++i)
-    DrawRenderPass(frame, render_passes_in_draw_order[i]);
-  FinishDrawingFrame(frame);
+  BeginDrawingFrame(&frame);
+  for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i)
+    DrawRenderPass(&frame, render_passes_in_draw_order->at(i));
+  FinishDrawingFrame(&frame);
 
-  render_passes_in_draw_order.clear();
+  render_passes_in_draw_order->clear();
 }
 
 gfx::RectF DirectRenderer::ComputeScissorRectForRenderPass(
-    const DrawingFrame& frame) {
-  gfx::RectF render_pass_scissor = frame.current_render_pass->output_rect;
+    const DrawingFrame* frame) {
+  gfx::RectF render_pass_scissor = frame->current_render_pass->output_rect;
 
-  if (frame.root_damage_rect == frame.root_render_pass->output_rect)
+  if (frame->root_damage_rect == frame->root_render_pass->output_rect)
     return render_pass_scissor;
 
   gfx::Transform inverse_transform(gfx::Transform::kSkipInitialization);
-  if (frame.current_render_pass->transform_to_root_target.GetInverse(
+  if (frame->current_render_pass->transform_to_root_target.GetInverse(
           &inverse_transform)) {
     // Only intersect inverse-projected damage if the transform is invertible.
     gfx::RectF damage_rect_in_render_pass_space =
-        MathUtil::ProjectClippedRect(inverse_transform, frame.root_damage_rect);
+        MathUtil::ProjectClippedRect(inverse_transform,
+                                     frame->root_damage_rect);
     render_pass_scissor.Intersect(damage_rect_in_render_pass_space);
   }
 
   return render_pass_scissor;
 }
 
-void DirectRenderer::SetScissorStateForQuad(const DrawingFrame& frame,
+void DirectRenderer::SetScissorStateForQuad(const DrawingFrame* frame,
                                             const DrawQuad& quad) {
   if (quad.isClipped()) {
     gfx::RectF quad_scissor_rect = quad.clipRect();
     SetScissorTestRect(MoveScissorToWindowSpace(frame, quad_scissor_rect));
   } else {
     EnsureScissorTestDisabled();
   }
 }
 
 void DirectRenderer::SetScissorStateForQuadWithRenderPassScissor(
-    const DrawingFrame& frame,
+    const DrawingFrame* frame,
     const DrawQuad& quad,
     const gfx::RectF& render_pass_scissor,
     bool* should_skip_quad) {
   gfx::RectF quad_scissor_rect = render_pass_scissor;
 
   if (quad.isClipped())
     quad_scissor_rect.Intersect(quad.clipRect());
 
   if (quad_scissor_rect.IsEmpty()) {
     *should_skip_quad = true;
     return;
   }
 
   *should_skip_quad = false;
   SetScissorTestRect(MoveScissorToWindowSpace(frame, quad_scissor_rect));
 }
 
 void DirectRenderer::FinishDrawingQuadList() {}
 
-void DirectRenderer::DrawRenderPass(DrawingFrame& frame,
+void DirectRenderer::DrawRenderPass(DrawingFrame* frame,
                                     const RenderPass* render_pass) {
   TRACE_EVENT0("cc", "DirectRenderer::DrawRenderPass");
   if (!UseRenderPass(frame, render_pass))
     return;
 
   bool using_scissor_as_optimization = Capabilities().using_partial_swap;
   gfx::RectF render_pass_scissor;
 
   if (using_scissor_as_optimization) {
     render_pass_scissor = ComputeScissorRectForRenderPass(frame);
     SetScissorTestRect(MoveScissorToWindowSpace(frame, render_pass_scissor));
   }
 
-  if (frame.current_render_pass != frame.root_render_pass ||
+  if (frame->current_render_pass != frame->root_render_pass ||
       client_->ShouldClearRootRenderPass()) {
     if (!using_scissor_as_optimization)
       EnsureScissorTestDisabled();
     ClearFramebuffer(frame);
   }
 
   const QuadList& quad_list = render_pass->quad_list;
   for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
        it != quad_list.BackToFrontEnd();
        ++it) {
@@ skipping 12 matching lines @@
   }
   FinishDrawingQuadList();
 
   CachedResource* texture = render_pass_textures_.get(render_pass->id);
   if (texture) {
     texture->set_is_complete(
         !render_pass->has_occlusion_from_outside_target_surface);
   }
 }
 
-bool DirectRenderer::UseRenderPass(DrawingFrame& frame,
+bool DirectRenderer::UseRenderPass(DrawingFrame* frame,
                                    const RenderPass* render_pass) {
-  frame.current_render_pass = render_pass;
-  frame.current_texture = NULL;
+  frame->current_render_pass = render_pass;
+  frame->current_texture = NULL;
 
-  if (render_pass == frame.root_render_pass) {
+  if (render_pass == frame->root_render_pass) {
     BindFramebufferToOutputSurface(frame);
     InitializeMatrices(frame, render_pass->output_rect, FlippedFramebuffer());
     SetDrawViewportSize(render_pass->output_rect.size());
     return true;
   }
 
   CachedResource* texture = render_pass_textures_.get(render_pass->id);
   DCHECK(texture);
 
   gfx::Size size = RenderPassTextureSize(render_pass);
@@ skipping 21 matching lines @@
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 // static
 GLenum DirectRenderer::RenderPassTextureFormat(const RenderPass* render_pass) {
   return GL_RGBA;
 }
 
 }  // namespace cc