cc: Convert non-const reference arguments to pointers.

cc/trees/layer_tree_host_impl_unittest.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/trees/layer_tree_host_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 4263 matching lines @@
                Proxy* proxy)
       : GLRenderer(this, output_surface, resource_provider) {}
 
  private:
   LayerTreeSettings settings_;
   gfx::Size viewport_size_;
   base::hash_set<RenderPass::Id> textures_;
 };
 
 static void ConfigureRenderPassTestData(const char* test_script,
-                                        RenderPassRemovalTestData& test_data,
+                                        RenderPassRemovalTestData* test_data,
                                         TestRenderer* renderer) {
   renderer->ClearCachedTextures();
 
   // One shared state for all quads - we don't need the correct details
-  test_data.shared_quad_state = SharedQuadState::Create();
-  test_data.shared_quad_state->SetAll(gfx::Transform(),
-                                      gfx::Size(),
-                                      gfx::Rect(),
-                                      gfx::Rect(),
-                                      false,
-                                      1.f);
+  test_data->shared_quad_state = SharedQuadState::Create();
+  test_data->shared_quad_state->SetAll(gfx::Transform(),
+                                       gfx::Size(),
+                                       gfx::Rect(),
+                                       gfx::Rect(),
+                                       false,
+                                       1.f);
 
   const char* current_char = test_script;
 
   // Pre-create root pass
   RenderPass::Id root_render_pass_id =
       RenderPass::Id(test_script[0], test_script[1]);
   scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
   pass->SetNew(root_render_pass_id, gfx::Rect(), gfx::Rect(), gfx::Transform());
-  test_data.render_pass_cache.add(root_render_pass_id, pass.Pass());
+  test_data->render_pass_cache.add(root_render_pass_id, pass.Pass());
   while (*current_char) {
     int layer_id = *current_char;
     current_char++;
     ASSERT_TRUE(current_char);
     int index = *current_char;
     current_char++;
 
     RenderPass::Id render_pass_id = RenderPass::Id(layer_id, index);
 
     bool is_replica = false;
-    if (!test_data.render_pass_cache.contains(render_pass_id))
+    if (!test_data->render_pass_cache.contains(render_pass_id))
       is_replica = true;
 
     scoped_ptr<TestRenderPass> render_pass =
-        test_data.render_pass_cache.take(render_pass_id);
+        test_data->render_pass_cache.take(render_pass_id);
 
     // Cycle through quad data and create all quads.
     while (*current_char && *current_char != '\n') {
       if (*current_char == 's') {
         // Solid color draw quad.
         scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
-        quad->SetNew(test_data.shared_quad_state.get(),
+        quad->SetNew(test_data->shared_quad_state.get(),
                      gfx::Rect(0, 0, 10, 10),
                      SK_ColorWHITE);
 
         render_pass->AppendQuad(quad.PassAs<DrawQuad>());
         current_char++;
       } else if ((*current_char >= 'A') && (*current_char <= 'Z')) {
         // RenderPass draw quad.
         int layer_id = *current_char;
         current_char++;
         ASSERT_TRUE(current_char);
@@ skipping 14 matching lines @@
               case 't':
                 has_texture = true;
                 break;
             }
             current_char++;
           }
           if (*current_char == ']')
             current_char++;
         }
 
-        if (test_data.render_pass_cache.find(new_render_pass_id) ==
-            test_data.render_pass_cache.end()) {
+        if (test_data->render_pass_cache.find(new_render_pass_id) ==
+            test_data->render_pass_cache.end()) {
           if (has_texture)
             renderer->SetHaveCachedResourcesForRenderPassId(new_render_pass_id);
 
           scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
           pass->SetNew(new_render_pass_id,
                        gfx::Rect(),
                        gfx::Rect(),
                        gfx::Transform());
-          test_data.render_pass_cache.add(new_render_pass_id, pass.Pass());
+          test_data->render_pass_cache.add(new_render_pass_id, pass.Pass());
         }
 
         gfx::Rect quad_rect = gfx::Rect(0, 0, 1, 1);
         gfx::Rect contents_changed_rect =
             contents_changed ? quad_rect : gfx::Rect();
         scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
-        quad->SetNew(test_data.shared_quad_state.get(),
+        quad->SetNew(test_data->shared_quad_state.get(),
                      quad_rect,
                      new_render_pass_id,
                      is_replica,
                      1,
                      contents_changed_rect,
                      gfx::RectF(0.f, 0.f, 1.f, 1.f),
                      WebKit::WebFilterOperations(),
                      skia::RefPtr<SkImageFilter>(),
                      WebKit::WebFilterOperations());
         render_pass->AppendQuad(quad.PassAs<DrawQuad>());
       }
     }
-    test_data.render_passes_by_id[render_pass_id] = render_pass.get();
-    test_data.render_passes.insert(test_data.render_passes.begin(),
-                                   render_pass.PassAs<RenderPass>());
+    test_data->render_passes_by_id[render_pass_id] = render_pass.get();
+    test_data->render_passes.insert(test_data->render_passes.begin(),
+                                    render_pass.PassAs<RenderPass>());
     if (*current_char)
       current_char++;
   }
 }
 
 void DumpRenderPassTestData(const RenderPassRemovalTestData& test_data,
                             char* buffer) {
   char* pos = buffer;
   for (RenderPassList::const_reverse_iterator it =
            test_data.render_passes.rbegin();
@@ skipping 195 matching lines @@
   scoped_ptr<TestRenderer> renderer =
       TestRenderer::Create(resource_provider.get(),
                            output_surface.get(),
                            &proxy_);
 
   int test_case_index = 0;
   while (remove_render_passes_cases[test_case_index].name) {
     RenderPassRemovalTestData test_data;
     ConfigureRenderPassTestData(
         remove_render_passes_cases[test_case_index].init_script,
-        test_data,
+        &test_data,
         renderer.get());
     LayerTreeHostImpl::RemoveRenderPasses(
         LayerTreeHostImpl::CullRenderPassesWithCachedTextures(renderer.get()),
         &test_data);
     VerifyRenderPassTestData(remove_render_passes_cases[test_case_index],
                              test_data);
     test_case_index++;
   }
 }
 
@@ skipping 334 matching lines @@
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               render_pass_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 }
 
 }  // namespace
 }  // namespace cc