cc: Convert non-const reference arguments to pointers.

cc/output/gl_renderer_unittest.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/gl_renderer.h"
 
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/resources/resource_provider.h"
@@ skipping 143 matching lines @@
   virtual bool HasImplThread() const OVERRIDE { return false; }
   virtual bool ShouldClearRootRenderPass() const OVERRIDE { return true; }
   virtual CompositorFrameMetadata MakeCompositorFrameMetadata() const OVERRIDE {
     return CompositorFrameMetadata();
   }
 
   // Methods added for test.
   int set_full_root_layer_damage_count() const {
     return set_full_root_layer_damage_count_;
   }
-  void set_last_call_was_set_visibility_pointer(bool* last_call_was_set_visibility) {
+  void set_last_call_was_set_visibility_pointer(
+      bool* last_call_was_set_visibility) {
     last_call_was_set_visibility_ = last_call_was_set_visibility;
   }
 
   RenderPass* root_render_pass() { return render_passes_in_draw_order_.back(); }
   RenderPassList* render_passes_in_draw_order() {
     return &render_passes_in_draw_order_;
   }
 
   size_t memory_allocation_limit_bytes() const {
     return memory_allocation_limit_bytes_;
@@ skipping 108 matching lines @@
 // Test GLRenderer DiscardBackbuffer functionality:
 // Begin drawing a frame while a framebuffer is discarded.
 // Expected: will recreate framebuffer.
 TEST_F(GLRendererTest, DiscardedBackbufferIsRecreatedForScopeDuration) {
   renderer_.SetVisible(false);
   context()->SetMemoryAllocation(suggest_have_backbuffer_no_);
   EXPECT_TRUE(renderer_.IsBackbufferDiscarded());
   EXPECT_EQ(1, mock_client_.set_full_root_layer_damage_count());
 
   renderer_.SetVisible(true);
-  renderer_.DrawFrame(*mock_client_.render_passes_in_draw_order());
+  renderer_.DrawFrame(mock_client_.render_passes_in_draw_order());
   EXPECT_FALSE(renderer_.IsBackbufferDiscarded());
 
   SwapBuffers();
   EXPECT_EQ(1, context()->frame_count());
 }
 
 TEST_F(GLRendererTest, FramebufferDiscardedAfterReadbackWhenNotVisible) {
   renderer_.SetVisible(false);
   context()->SetMemoryAllocation(suggest_have_backbuffer_no_);
   EXPECT_TRUE(renderer_.IsBackbufferDiscarded());
   EXPECT_EQ(1, mock_client_.set_full_root_layer_damage_count());
 
   char pixels[4];
-  renderer_.DrawFrame(*mock_client_.render_passes_in_draw_order());
+  renderer_.DrawFrame(mock_client_.render_passes_in_draw_order());
   EXPECT_FALSE(renderer_.IsBackbufferDiscarded());
 
   renderer_.GetFramebufferPixels(pixels, gfx::Rect(0, 0, 1, 1));
   EXPECT_TRUE(renderer_.IsBackbufferDiscarded());
   EXPECT_EQ(2, mock_client_.set_full_root_layer_damage_count());
 }
 
 class ForbidSynchronousCallContext : public TestWebGraphicsContext3D {
  public:
   ForbidSynchronousCallContext() {}
 
-  virtual bool getActiveAttrib(WebGLId program, WGC3Duint index, ActiveInfo& info) {
+  virtual bool getActiveAttrib(WebGLId program,
+                               WGC3Duint index,
+                               ActiveInfo& info) {
     ADD_FAILURE();
     return false;
   }
-  virtual bool getActiveUniform(WebGLId program, WGC3Duint index, ActiveInfo& info) {
+  virtual bool getActiveUniform(WebGLId program,
+                                WGC3Duint index,
+                                ActiveInfo& info) {
     ADD_FAILURE();
     return false;
   }
   virtual void getAttachedShaders(WebGLId program,
                                   WGC3Dsizei max_count,
                                   WGC3Dsizei* count,
                                   WebGLId* shaders) {
     ADD_FAILURE();
   }
   virtual WGC3Dint getAttribLocation(WebGLId program, const WGC3Dchar* name) {
@@ skipping 186 matching lines @@
 
   // WebGraphicsContext3D methods.
 
   // This method would normally do a glSwapBuffers under the hood.
   virtual void prepareTexture() {}
   virtual void setMemoryAllocationChangedCallbackCHROMIUM(
       WebGraphicsMemoryAllocationChangedCallbackCHROMIUM* callback) {}
   virtual WebString getString(WebKit::WGC3Denum name) { return WebString(); }
 };
 
-TEST(
-    GLRendererTest2,
-    InitializationWithoutGpuMemoryManagerExtensionSupportShouldDefaultToNonZeroAllocation) {
+TEST(GLRendererTest2,
+     InitializationWithoutGpuMemoryManagerExtensionSupportShouldDefaultToNonZeroAllocation) {
   FakeRendererClient mock_client;
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new ContextThatDoesNotSupportMemoryManagmentExtensions)));
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get()));
   FakeRendererGL renderer(
       &mock_client, output_surface.get(), resource_provider.get());
 
   renderer.Initialize();
@@ skipping 21 matching lines @@
       static_cast<ClearCountingContext*>(output_surface->context3d());
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get()));
   FakeRendererGL renderer(
       &mock_client, output_surface.get(), resource_provider.get());
 
   mock_client.root_render_pass()->has_transparent_background = false;
 
   EXPECT_TRUE(renderer.Initialize());
 
-  renderer.DrawFrame(*mock_client.render_passes_in_draw_order());
+  renderer.DrawFrame(mock_client.render_passes_in_draw_order());
 
 // On DEBUG builds, render passes with opaque background clear to blue to
 // easily see regions that were not drawn on the screen.
 #ifdef NDEBUG
   EXPECT_EQ(0, context->clear_count());
 #else
   EXPECT_EQ(1, context->clear_count());
 #endif
 }
 
 TEST(GLRendererTest2, TransparentBackground) {
   FakeRendererClient mock_client;
   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
       scoped_ptr<WebKit::WebGraphicsContext3D>(new ClearCountingContext)));
   ClearCountingContext* context =
       static_cast<ClearCountingContext*>(output_surface->context3d());
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get()));
   FakeRendererGL renderer(
       &mock_client, output_surface.get(), resource_provider.get());
 
   mock_client.root_render_pass()->has_transparent_background = true;
 
   EXPECT_TRUE(renderer.Initialize());
 
-  renderer.DrawFrame(*mock_client.render_passes_in_draw_order());
+  renderer.DrawFrame(mock_client.render_passes_in_draw_order());
 
   EXPECT_EQ(1, context->clear_count());
 }
 
 class VisibilityChangeIsLastCallTrackingContext :
     public TestWebGraphicsContext3D {
  public:
   VisibilityChangeIsLastCallTrackingContext()
       : last_call_was_set_visibility_(0) {}
 
@@ skipping 24 matching lines @@
   // This method would normally do a glSwapBuffers under the hood.
   virtual WebString getString(WebKit::WGC3Denum name) {
     if (name == GL_EXTENSIONS)
       return WebString(
           "GL_CHROMIUM_set_visibility GL_CHROMIUM_gpu_memory_manager "
           "GL_CHROMIUM_discard_backbuffer");
     return WebString();
   }
 
   // Methods added for test.
-  void set_last_call_was_set_visibility_pointer(bool* last_call_was_set_visibility) {
+  void set_last_call_was_set_visibility_pointer(
+      bool* last_call_was_set_visibility) {
     last_call_was_set_visibility_ = last_call_was_set_visibility;
   }
 
  private:
   bool* last_call_was_set_visibility_;
 };
 
 TEST(GLRendererTest2, VisibilityChangeIsLastCall) {
   FakeRendererClient mock_client;
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(
           new VisibilityChangeIsLastCallTrackingContext)));
   VisibilityChangeIsLastCallTrackingContext* context =
       static_cast<VisibilityChangeIsLastCallTrackingContext*>(
           output_surface->context3d());
   scoped_ptr<ResourceProvider> resource_provider(
       ResourceProvider::Create(output_surface.get()));
   FakeRendererGL renderer(
       &mock_client, output_surface.get(), resource_provider.get());
 
   EXPECT_TRUE(renderer.Initialize());
 
   bool last_call_was_set_visiblity = false;
   // Ensure that the call to setVisibilityCHROMIUM is the last call issue to the
   // GPU process, after glFlush is called, and after the RendererClient's
   // EnforceManagedMemoryPolicy is called. Plumb this tracking between both the
   // RenderClient and the Context by giving them both a pointer to a variable on
   // the stack.
-  context->set_last_call_was_set_visibility_pointer(&last_call_was_set_visiblity);
-  mock_client.set_last_call_was_set_visibility_pointer(&last_call_was_set_visiblity);
+  context->set_last_call_was_set_visibility_pointer(
+      &last_call_was_set_visiblity);
+  mock_client.set_last_call_was_set_visibility_pointer(
+      &last_call_was_set_visiblity);
   renderer.SetVisible(true);
-  renderer.DrawFrame(*mock_client.render_passes_in_draw_order());
+  renderer.DrawFrame(mock_client.render_passes_in_draw_order());
   renderer.SetVisible(false);
   EXPECT_TRUE(last_call_was_set_visiblity);
 }
 
 class TextureStateTrackingContext : public TestWebGraphicsContext3D {
  public:
   TextureStateTrackingContext() : active_texture_(GL_INVALID_ENUM) {}
 
   virtual WebString getString(WGC3Denum name) {
     if (name == GL_EXTENSIONS)
@@ skipping 68 matching lines @@
 
     // scaled_tile_quad also uses GL_LINEAR.
     EXPECT_CALL(*context, drawElements(_, _, _, _));
 
     // The remaining quads also use GL_LINEAR because nearest neighbor
     // filtering is currently only used with tile quads.
     EXPECT_CALL(*context, drawElements(_, _, _, _)).Times(6);
   }
 
   cc::DirectRenderer::DrawingFrame drawing_frame;
-  renderer.BeginDrawingFrame(drawing_frame);
+  renderer.BeginDrawingFrame(&drawing_frame);
   EXPECT_EQ(context->active_texture(), GL_TEXTURE0);
 
   for (cc::QuadList::BackToFrontIterator
            it = pass->quad_list.BackToFrontBegin();
        it != pass->quad_list.BackToFrontEnd();
        ++it) {
-    renderer.DoDrawQuad(drawing_frame, *it);
+    renderer.DoDrawQuad(&drawing_frame, *it);
   }
   renderer.FinishDrawingQuadList();
   EXPECT_EQ(context->active_texture(), GL_TEXTURE0);
   Mock::VerifyAndClearExpectations(context);
 }
 
 class NoClearRootRenderPassFakeClient : public FakeRendererClient {
  public:
   virtual bool ShouldClearRootRenderPass() const OVERRIDE { return false; }
 };
@@ skipping 47 matching lines @@
 
   // The second render pass is the root one, clearing should be prevented.
   EXPECT_CALL(*mock_context, clear(GL_COLOR_BUFFER_BIT)).Times(0)
       .After(first_render_pass);
 
   EXPECT_CALL(*mock_context, drawElements(_, _, _, _)).Times(AnyNumber())
       .After(first_render_pass);
 
   renderer.DecideRenderPassAllocationsForFrame(
       *mock_client.render_passes_in_draw_order());
-  renderer.DrawFrame(*mock_client.render_passes_in_draw_order());
+  renderer.DrawFrame(mock_client.render_passes_in_draw_order());
 
   // In multiple render passes all but the root pass should clear the
   // framebuffer.
   Mock::VerifyAndClearExpectations(&mock_context);
 }
 
 class ScissorTestOnClearCheckingContext : public TestWebGraphicsContext3D {
  public:
   ScissorTestOnClearCheckingContext() : scissor_enabled_(false) {}
 
@@ skipping 26 matching lines @@
   EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
 
   gfx::Rect viewport_rect(mock_client.DeviceViewportSize());
   ScopedPtrVector<RenderPass>& render_passes =
       *mock_client.render_passes_in_draw_order();
   render_passes.clear();
 
   gfx::Rect grand_child_rect(25, 25);
   RenderPass::Id grand_child_pass_id(3, 0);
   TestRenderPass* grand_child_pass = AddRenderPass(
-     & render_passes, grand_child_pass_id, grand_child_rect, gfx::Transform());
+      &render_passes, grand_child_pass_id, grand_child_rect, gfx::Transform());
   AddClippedQuad(grand_child_pass, grand_child_rect, SK_ColorYELLOW);
 
   gfx::Rect child_rect(50, 50);
   RenderPass::Id child_pass_id(2, 0);
-  TestRenderPass* child_pass =
-      AddRenderPass(&render_passes, child_pass_id, child_rect, gfx::Transform());
+  TestRenderPass* child_pass = AddRenderPass(
+      &render_passes, child_pass_id, child_rect, gfx::Transform());
   AddQuad(child_pass, child_rect, SK_ColorBLUE);
 
   RenderPass::Id root_pass_id(1, 0);
   TestRenderPass* root_pass = AddRenderPass(
-     & render_passes, root_pass_id, viewport_rect, gfx::Transform());
+      &render_passes, root_pass_id, viewport_rect, gfx::Transform());
   AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
 
   AddRenderPassQuad(root_pass, child_pass);
   AddRenderPassQuad(child_pass, grand_child_pass);
 
   renderer.DecideRenderPassAllocationsForFrame(
       *mock_client.render_passes_in_draw_order());
-  renderer.DrawFrame(*mock_client.render_passes_in_draw_order());
+  renderer.DrawFrame(mock_client.render_passes_in_draw_order());
 }
 
 class OutputSurfaceMockContext : public TestWebGraphicsContext3D {
  public:
   // Specifically override methods even if they are unused (used in conjunction
   // with StrictMock). We need to make sure that GLRenderer does not issue
   // framebuffer-related GL calls directly. Instead these are supposed to go
   // through the OutputSurface abstraction.
   MOCK_METHOD0(ensureBackbufferCHROMIUM, void());
   MOCK_METHOD0(discardBackbufferCHROMIUM, void());
@@ skipping 51 matching lines @@
     AddQuad(render_pass, viewport_rect, SK_ColorGREEN);
 
     EXPECT_CALL(output_surface_, EnsureBackbuffer()).WillRepeatedly(Return());
 
     EXPECT_CALL(output_surface_, Reshape(_)).Times(1);
 
     EXPECT_CALL(output_surface_, BindFramebuffer()).Times(1);
 
     EXPECT_CALL(*context(), drawElements(_, _, _, _)).Times(1);
 
-    renderer_.DecideRenderPassAllocationsForFrame(*render_passes_in_draw_order());
-    renderer_.DrawFrame(*render_passes_in_draw_order());
+    renderer_.DecideRenderPassAllocationsForFrame(
+        *render_passes_in_draw_order());
+    renderer_.DrawFrame(render_passes_in_draw_order());
   }
 
   OutputSurfaceMockContext* context() {
     return static_cast<OutputSurfaceMockContext*>(output_surface_.context3d());
   }
 
   StrictMock<MockOutputSurface> output_surface_;
   scoped_ptr<ResourceProvider> resource_provider_;
   FakeRendererGL renderer_;
 };
@@ skipping 31 matching lines @@
   }
 };
 
 TEST_F(MockOutputSurfaceTestWithSendCompositorFrame, DrawFrame) {
   EXPECT_CALL(output_surface_, SendFrameToParentCompositor(_)).Times(1);
   DrawFrame();
 }
 
 }  // namespace
 }  // namespace cc