Use a struct for cc::Surface ids for more type safety

cc/surfaces/surface_aggregator_unittest.cc

 // Copyright 2014 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/compositor_frame.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/surfaces/surface.h"
 #include "cc/surfaces/surface_aggregator.h"
 #include "cc/surfaces/surface_aggregator_test_helpers.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/test/render_pass_test_common.h"
 #include "cc/test/render_pass_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkColor.h"
 
 namespace cc {
 namespace {
-const int kInvalidSurfaceId = -1;
+
+SurfaceId InvalidSurfaceId() {
+  static SurfaceId invalid;
+  invalid.id = -1;
+  return invalid;
+}
 
 class SurfaceAggregatorTest : public testing::Test {
  public:
   SurfaceAggregatorTest() : aggregator_(&manager_) {}
 
  protected:
   SurfaceManager manager_;
   SurfaceAggregator aggregator_;
 };
 
 TEST_F(SurfaceAggregatorTest, InvalidSurfaceId) {
-  scoped_ptr<CompositorFrame> frame = aggregator_.Aggregate(kInvalidSurfaceId);
+  scoped_ptr<CompositorFrame> frame = aggregator_.Aggregate(InvalidSurfaceId());
   EXPECT_FALSE(frame);
 }
 
 TEST_F(SurfaceAggregatorTest, ValidSurfaceNoFrame) {
   Surface one(&manager_, NULL, gfx::Size(5, 5));
   scoped_ptr<CompositorFrame> frame = aggregator_.Aggregate(one.surface_id());
   EXPECT_FALSE(frame);
 }
 
 class SurfaceAggregatorValidSurfaceTest : public SurfaceAggregatorTest {
@@ skipping 206 matching lines @@
         RenderPassDrawQuad::MaterialCast(fifth_pass_quad_list.at(1u));
     EXPECT_EQ(actual_pass_ids[3],
               fifth_pass_render_pass_draw_quad->render_pass_id);
   }
 }
 
 // Tests an invalid surface reference in a frame. The surface quad should just
 // be dropped.
 TEST_F(SurfaceAggregatorValidSurfaceTest, InvalidSurfaceReference) {
   test::Quad quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN),
-                        test::Quad::SurfaceQuad(kInvalidSurfaceId),
+                        test::Quad::SurfaceQuad(InvalidSurfaceId()),
                         test::Quad::SolidColorQuad(SK_ColorBLUE)};
   test::Pass passes[] = {test::Pass(quads, arraysize(quads))};
 
   SubmitFrame(passes, arraysize(passes), &root_surface_);
 
   test::Quad expected_quads[] = {test::Quad::SolidColorQuad(SK_ColorGREEN),
                                  test::Quad::SolidColorQuad(SK_ColorBLUE)};
   test::Pass expected_passes[] = {
       test::Pass(expected_quads, arraysize(expected_quads))};
   AggregateAndVerify(expected_passes, arraysize(expected_passes));
@@ skipping 421 matching lines @@
     DrawQuad* quad = aggregated_pass_list[1]->quad_list.at(i);
     EXPECT_EQ(expected_root_pass_quad_transforms[i].ToString(),
               quad->quadTransform().ToString())
         << i;
   }
 }
 
 }  // namespace
 }  // namespace cc