Make RenderPass::Id an isolated class

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 <set>
 
 #include "cc/base/math_util.h"
 #include "cc/output/compositor_frame_metadata.h"
@@ skipping 296 matching lines @@
 // Begin drawing a frame while a framebuffer is discarded.
 // Expected: will recreate framebuffer.
 TEST_F(GLRendererWithDefaultHarnessTest,
        DiscardedBackbufferIsRecreatedForScopeDuration) {
   gfx::Rect viewport_rect(1, 1);
   renderer_->SetVisible(false);
   EXPECT_TRUE(renderer_->IsBackbufferDiscarded());
   EXPECT_EQ(1, renderer_client_.set_full_root_layer_damage_count());
 
   AddRenderPass(&render_passes_in_draw_order_,
-                RenderPass::Id(1, 0),
+                RenderPassId(1, 0),
                 viewport_rect,
                 gfx::Transform());
 
   renderer_->SetVisible(true);
   renderer_->DrawFrame(&render_passes_in_draw_order_,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
   EXPECT_FALSE(renderer_->IsBackbufferDiscarded());
 
   SwapBuffers();
   EXPECT_EQ(1u, output_surface_->num_sent_frames());
 }
 
 TEST_F(GLRendererWithDefaultHarnessTest, ExternalStencil) {
   gfx::Rect viewport_rect(1, 1);
   EXPECT_FALSE(renderer_->stencil_enabled());
 
   output_surface_->set_has_external_stencil_test(true);
 
   TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
-                                            RenderPass::Id(1, 0),
+                                            RenderPassId(1, 0),
                                             viewport_rect,
                                             gfx::Transform());
   root_pass->has_transparent_background = false;
 
   renderer_->DrawFrame(&render_passes_in_draw_order_,
                        1.f,
                        viewport_rect,
                        viewport_rect,
                        false);
   EXPECT_TRUE(renderer_->stencil_enabled());
@@ skipping 198 matching lines @@
 
   LayerTreeSettings settings;
   FakeRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
 
   gfx::Rect viewport_rect(1, 1);
   TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
-                                            RenderPass::Id(1, 0),
+                                            RenderPassId(1, 0),
                                             viewport_rect,
                                             gfx::Transform());
   root_pass->has_transparent_background = false;
 
   // On DEBUG builds, render passes with opaque background clear to blue to
   // easily see regions that were not drawn on the screen.
   EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, _, _))
       .With(Args<2, 1>(ElementsAre(GL_COLOR_EXT)))
       .Times(1);
 #ifdef NDEBUG
@@ skipping 25 matching lines @@
 
   LayerTreeSettings settings;
   FakeRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
 
   gfx::Rect viewport_rect(1, 1);
   TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
-                                            RenderPass::Id(1, 0),
+                                            RenderPassId(1, 0),
                                             viewport_rect,
                                             gfx::Transform());
   root_pass->has_transparent_background = true;
 
   EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, 1, _)).Times(1);
   EXPECT_CALL(*context, clear(_)).Times(1);
   renderer.DrawFrame(&render_passes_in_draw_order_,
                      1.f,
                      viewport_rect,
                      viewport_rect,
@@ skipping 18 matching lines @@
 
   LayerTreeSettings settings;
   FakeRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
 
   gfx::Rect viewport_rect(1, 1);
   AddRenderPass(&render_passes_in_draw_order_,
-                RenderPass::Id(1, 0),
+                RenderPassId(1, 0),
                 viewport_rect,
                 gfx::Transform());
 
   EXPECT_CALL(*context, discardFramebufferEXT(GL_FRAMEBUFFER, _, _))
       .With(Args<2, 1>(ElementsAre(GL_COLOR_ATTACHMENT0)))
       .Times(1);
   EXPECT_CALL(*context, clear(_)).Times(AnyNumber());
   renderer.DrawFrame(&render_passes_in_draw_order_,
                      1.f,
                      viewport_rect,
@@ skipping 60 matching lines @@
 
   LayerTreeSettings settings;
   FakeRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
 
   gfx::Rect viewport_rect(1, 1);
   AddRenderPass(&render_passes_in_draw_order_,
-                RenderPass::Id(1, 0),
+                RenderPassId(1, 0),
                 viewport_rect,
                 gfx::Transform());
 
   // Ensure that the call to SetSurfaceVisible is the last call issue to the
   // GPU process, after glFlush is called, and after the RendererClient's
   // SetManagedMemoryPolicy is called. Plumb this tracking between both the
   // RenderClient and the Context by giving them both a pointer to a variable on
   // the stack.
   renderer.SetVisible(true);
   renderer.DrawFrame(&render_passes_in_draw_order_,
@@ skipping 45 matching lines @@
   LayerTreeSettings settings;
   FakeRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
 
   // During initialization we are allowed to set any texture parameters.
   EXPECT_CALL(*context, texParameteri(_, _, _)).Times(AnyNumber());
 
-  RenderPass::Id id(1, 1);
+  RenderPassId id(1, 1);
   TestRenderPass* root_pass = AddRenderPass(
       &render_passes_in_draw_order_, id, gfx::Rect(100, 100), gfx::Transform());
   root_pass->AppendOneOfEveryQuadType(resource_provider.get(),
-                                      RenderPass::Id(2, 1));
+                                      RenderPassId(2, 1));
 
   renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
 
   // Set up expected texture filter state transitions that match the quads
   // created in AppendOneOfEveryQuadType().
   Mock::VerifyAndClearExpectations(context);
   {
     InSequence sequence;
 
     // The sync points for all quads are waited on first. This sync point is
@@ skipping 61 matching lines @@
   settings.should_clear_root_render_pass = false;
 
   FakeRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
 
   gfx::Rect viewport_rect(10, 10);
 
-  RenderPass::Id root_pass_id(1, 0);
+  RenderPassId root_pass_id(1, 0);
   TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
                                             root_pass_id,
                                             viewport_rect,
                                             gfx::Transform());
   AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
 
-  RenderPass::Id child_pass_id(2, 0);
+  RenderPassId child_pass_id(2, 0);
   TestRenderPass* child_pass = AddRenderPass(&render_passes_in_draw_order_,
                                              child_pass_id,
                                              viewport_rect,
                                              gfx::Transform());
   AddQuad(child_pass, viewport_rect, SK_ColorBLUE);
 
   AddRenderPassQuad(root_pass, child_pass);
 
 #ifdef NDEBUG
   GLint clear_bits = GL_COLOR_BUFFER_BIT;
@@ skipping 64 matching lines @@
   FakeRendererClient renderer_client;
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
   EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
 
   gfx::Rect viewport_rect(1, 1);
 
   gfx::Rect grand_child_rect(25, 25);
-  RenderPass::Id grand_child_pass_id(3, 0);
+  RenderPassId grand_child_pass_id(3, 0);
   TestRenderPass* grand_child_pass =
       AddRenderPass(&render_passes_in_draw_order_,
                     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);
+  RenderPassId child_pass_id(2, 0);
   TestRenderPass* child_pass = AddRenderPass(&render_passes_in_draw_order_,
                                              child_pass_id,
                                              child_rect,
                                              gfx::Transform());
   AddQuad(child_pass, child_rect, SK_ColorBLUE);
 
-  RenderPass::Id root_pass_id(1, 0);
+  RenderPassId root_pass_id(1, 0);
   TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
                                             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(render_passes_in_draw_order_);
@@ skipping 59 matching lines @@
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
   EXPECT_TRUE(renderer.Capabilities().using_partial_swap);
 
   gfx::Rect viewport_rect(100, 100);
   gfx::Rect clip_rect(100, 100);
 
   {
     // Partial frame, should not discard.
-    RenderPass::Id root_pass_id(1, 0);
+    RenderPassId root_pass_id(1, 0);
     TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
                                               root_pass_id,
                                               viewport_rect,
                                               gfx::Transform());
     AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
     root_pass->damage_rect = gfx::Rect(2, 2, 3, 3);
 
     renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
     renderer.DrawFrame(&render_passes_in_draw_order_,
                        1.f,
                        viewport_rect,
                        clip_rect,
                        false);
     EXPECT_EQ(0, context->discarded());
     context->reset();
   }
   {
     // Full frame, should discard.
-    RenderPass::Id root_pass_id(1, 0);
+    RenderPassId root_pass_id(1, 0);
     TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
                                               root_pass_id,
                                               viewport_rect,
                                               gfx::Transform());
     AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
     root_pass->damage_rect = root_pass->output_rect;
 
     renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
     renderer.DrawFrame(&render_passes_in_draw_order_,
                        1.f,
                        viewport_rect,
                        clip_rect,
                        false);
     EXPECT_EQ(1, context->discarded());
     context->reset();
   }
   {
     // Full frame, external scissor is set, should not discard.
     output_surface->set_has_external_stencil_test(true);
-    RenderPass::Id root_pass_id(1, 0);
+    RenderPassId root_pass_id(1, 0);
     TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
                                               root_pass_id,
                                               viewport_rect,
                                               gfx::Transform());
     AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
     root_pass->damage_rect = root_pass->output_rect;
     root_pass->has_transparent_background = false;
 
     renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
     renderer.DrawFrame(&render_passes_in_draw_order_,
                        1.f,
                        viewport_rect,
                        clip_rect,
                        false);
     EXPECT_EQ(0, context->discarded());
     context->reset();
     output_surface->set_has_external_stencil_test(false);
   }
   {
     // Full frame, clipped, should not discard.
     clip_rect = gfx::Rect(10, 10, 10, 10);
-    RenderPass::Id root_pass_id(1, 0);
+    RenderPassId root_pass_id(1, 0);
     TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
                                               root_pass_id,
                                               viewport_rect,
                                               gfx::Transform());
     AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
     root_pass->damage_rect = root_pass->output_rect;
 
     renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
     renderer.DrawFrame(&render_passes_in_draw_order_,
                        1.f,
                        viewport_rect,
                        clip_rect,
                        false);
     EXPECT_EQ(0, context->discarded());
     context->reset();
   }
   {
     // Full frame, doesn't cover the surface, should not discard.
     viewport_rect = gfx::Rect(10, 10, 10, 10);
-    RenderPass::Id root_pass_id(1, 0);
+    RenderPassId root_pass_id(1, 0);
     TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
                                               root_pass_id,
                                               viewport_rect,
                                               gfx::Transform());
     AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
     root_pass->damage_rect = root_pass->output_rect;
 
     renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
     renderer.DrawFrame(&render_passes_in_draw_order_,
                        1.f,
                        viewport_rect,
                        clip_rect,
                        false);
     EXPECT_EQ(0, context->discarded());
     context->reset();
   }
   {
     // Full frame, doesn't cover the surface (no offset), should not discard.
     clip_rect = gfx::Rect(100, 100);
     viewport_rect = gfx::Rect(50, 50);
-    RenderPass::Id root_pass_id(1, 0);
+    RenderPassId root_pass_id(1, 0);
     TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
                                               root_pass_id,
                                               viewport_rect,
                                               gfx::Transform());
     AddQuad(root_pass, viewport_rect, SK_ColorGREEN);
     root_pass->damage_rect = root_pass->output_rect;
 
     renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
     renderer.DrawFrame(&render_passes_in_draw_order_,
                        1.f,
@@ skipping 60 matching lines @@
   FakeRendererGL renderer(&renderer_client,
                           &settings,
                           output_surface.get(),
                           resource_provider.get());
   EXPECT_FALSE(renderer.Capabilities().using_partial_swap);
 
   gfx::Rect device_viewport_rect(10, 10, 100, 100);
   gfx::Rect viewport_rect(device_viewport_rect.size());
   gfx::Rect quad_rect = gfx::Rect(20, 20, 20, 20);
 
-  RenderPass::Id root_pass_id(1, 0);
+  RenderPassId root_pass_id(1, 0);
   TestRenderPass* root_pass = AddRenderPass(&render_passes_in_draw_order_,
                                             root_pass_id,
                                             viewport_rect,
                                             gfx::Transform());
   AddClippedQuad(root_pass, quad_rect, SK_ColorGREEN);
 
   renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
   renderer.DrawFrame(&render_passes_in_draw_order_,
                      1.f,
                      device_viewport_rect,
                      device_viewport_rect,
                      false);
 }
 
 TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {
   gfx::Rect viewport_rect(1, 1);
 
   gfx::Rect child_rect(50, 50);
-  RenderPass::Id child_pass_id(2, 0);
+  RenderPassId child_pass_id(2, 0);
   TestRenderPass* child_pass;
 
-  RenderPass::Id root_pass_id(1, 0);
+  RenderPassId root_pass_id(1, 0);
   TestRenderPass* root_pass;
 
   ResourceProvider::ResourceId mask = resource_provider_->CreateResource(
       gfx::Size(20, 12),
       GL_CLAMP_TO_EDGE,
       ResourceProvider::TextureUsageAny,
       resource_provider_->best_texture_format());
   resource_provider_->AllocateForTesting(mask);
 
   SkScalar matrix[20];
@@ skipping 206 matching lines @@
                        viewport_rect,
                        viewport_rect,
                        false);
   TestRenderPassMaskColorMatrixProgramAA(TexCoordPrecisionMedium);
 }
 
 // At this time, the AA code path cannot be taken if the surface's rect would
 // project incorrectly by the given transform, because of w<0 clipping.
 TEST_F(GLRendererShaderTest, DrawRenderPassQuadSkipsAAForClippingTransform) {
   gfx::Rect child_rect(50, 50);
-  RenderPass::Id child_pass_id(2, 0);
+  RenderPassId child_pass_id(2, 0);
   TestRenderPass* child_pass;
 
   gfx::Rect viewport_rect(1, 1);
-  RenderPass::Id root_pass_id(1, 0);
+  RenderPassId root_pass_id(1, 0);
   TestRenderPass* root_pass;
 
   gfx::Transform transform_preventing_aa;
   transform_preventing_aa.ApplyPerspectiveDepth(40.0);
   transform_preventing_aa.RotateAboutYAxis(-20.0);
   transform_preventing_aa.Scale(30.0, 1.0);
 
   // Verify that the test transform and test rect actually do cause the clipped
   // flag to trigger. Otherwise we are not testing the intended scenario.
   bool clipped = false;
@@ skipping 20 matching lines @@
                        viewport_rect,
                        false);
 
   // If use_aa incorrectly ignores clipping, it will use the
   // RenderPassProgramAA shader instead of the RenderPassProgram.
   TestRenderPassProgram(TexCoordPrecisionMedium);
 }
 
 TEST_F(GLRendererShaderTest, DrawSolidColorShader) {
   gfx::Rect viewport_rect(1, 1);
-  RenderPass::Id root_pass_id(1, 0);
+  RenderPassId root_pass_id(1, 0);
   TestRenderPass* root_pass;
 
   gfx::Transform pixel_aligned_transform_causing_aa;
   pixel_aligned_transform_causing_aa.Translate(25.5f, 25.5f);
   pixel_aligned_transform_causing_aa.Scale(0.5f, 0.5f);
 
   root_pass = AddRenderPass(&render_passes_in_draw_order_,
                             root_pass_id,
                             viewport_rect,
                             gfx::Transform());
@@ skipping 59 matching lines @@
     renderer_.reset(new FakeRendererGL(&renderer_client_,
                                        &settings_,
                                        &output_surface_,
                                        resource_provider_.get()));
   }
 
   void SwapBuffers() { renderer_->SwapBuffers(CompositorFrameMetadata()); }
 
   void DrawFrame(float device_scale_factor,
                  const gfx::Rect& device_viewport_rect) {
-    RenderPass::Id render_pass_id(1, 0);
+    RenderPassId render_pass_id(1, 0);
     TestRenderPass* render_pass = AddRenderPass(&render_passes_in_draw_order_,
                                                 render_pass_id,
                                                 device_viewport_rect,
                                                 gfx::Transform());
     AddQuad(render_pass, device_viewport_rect, SK_ColorGREEN);
 
     EXPECT_CALL(output_surface_, EnsureBackbuffer()).WillRepeatedly(Return());
 
     EXPECT_CALL(output_surface_,
                 Reshape(device_viewport_rect.size(), device_scale_factor))
@@ skipping 129 matching lines @@
   base::MessageLoop::current()->Run();
 
   // The sync point should have happened.
   EXPECT_EQ(1, sync_point_callback_count);
   EXPECT_EQ(1, other_callback_count);
 }
 #endif  // OS_ANDROID
 
 }  // namespace
 }  // namespace cc