Color: Plumb color profile from ui::Compositor to cc::DirectRenderer

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 <stdint.h>
 
 #include <set>
 
@@ skipping 46 matching lines @@
   gpu::SyncToken other;
   memcpy(&other, arg, sizeof(other));
   return other == sync_token;
 }
 
 class GLRendererTest : public testing::Test {
  protected:
   RenderPass* root_render_pass() {
     return render_passes_in_draw_order_.back().get();
   }
+  void DrawFrame(Renderer* renderer, const gfx::Rect& viewport_rect) {
+    renderer->DrawFrame(&render_passes_in_draw_order_, 1.f, gfx::ColorSpace(),
+                        viewport_rect, viewport_rect, false);
+  }
+  void DrawFrame(Renderer* renderer,
+                 const gfx::Rect& viewport_rect,
+                 const gfx::Rect& clip_rect) {
+    renderer->DrawFrame(&render_passes_in_draw_order_, 1.f, gfx::ColorSpace(),
+                        viewport_rect, clip_rect, false);
+  }
 
   RenderPassList render_passes_in_draw_order_;
 };
 
 #define EXPECT_PROGRAM_VALID(program_binding)      \
   do {                                             \
     EXPECT_TRUE((program_binding)->program());     \
     EXPECT_TRUE((program_binding)->initialized()); \
   } while (false)
 
@@ skipping 456 matching lines @@
   renderer_->SetVisible(false);
   EXPECT_TRUE(renderer_->IsBackbufferDiscarded());
   EXPECT_EQ(1, renderer_client_.set_full_root_layer_damage_count());
 
   AddRenderPass(&render_passes_in_draw_order_,
                 RenderPassId(1, 0),
                 viewport_rect,
                 gfx::Transform());
 
   renderer_->SetVisible(true);
-  renderer_->DrawFrame(&render_passes_in_draw_order_,
-                       1.f,
-                       viewport_rect,
-                       viewport_rect,
-                       false);
+  DrawFrame(renderer_.get(), viewport_rect);
   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);
 
   RenderPass* root_pass =
       AddRenderPass(&render_passes_in_draw_order_, 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);
+  DrawFrame(renderer_.get(), viewport_rect);
   EXPECT_TRUE(renderer_->stencil_enabled());
 }
 
 class ForbidSynchronousCallContext : public TestWebGraphicsContext3D {
  public:
   ForbidSynchronousCallContext() {}
 
   void getAttachedShaders(GLuint program,
                           GLsizei max_count,
                           GLsizei* count,
@@ skipping 186 matching lines @@
   // 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
   EXPECT_CALL(*context, clear(_)).Times(0);
 #else
   EXPECT_CALL(*context, clear(_)).Times(1);
 #endif
-  renderer.DrawFrame(&render_passes_in_draw_order_,
-                     1.f,
-                     viewport_rect,
-                     viewport_rect,
-                     false);
+  DrawFrame(&renderer, viewport_rect);
   Mock::VerifyAndClearExpectations(context);
 }
 
 TEST_F(GLRendererTest, TransparentBackground) {
   std::unique_ptr<ClearCountingContext> context_owned(new ClearCountingContext);
   ClearCountingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(std::move(context_owned)));
@@ skipping 13 matching lines @@
                           resource_provider.get());
 
   gfx::Rect viewport_rect(1, 1);
   RenderPass* root_pass =
       AddRenderPass(&render_passes_in_draw_order_, 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,
-                     false);
+  DrawFrame(&renderer, viewport_rect);
 
   Mock::VerifyAndClearExpectations(context);
 }
 
 TEST_F(GLRendererTest, OffscreenOutputSurface) {
   std::unique_ptr<ClearCountingContext> context_owned(new ClearCountingContext);
   ClearCountingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<OutputSurface> output_surface(
@@ skipping 16 matching lines @@
   gfx::Rect viewport_rect(1, 1);
   AddRenderPass(&render_passes_in_draw_order_,
                 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,
-                     viewport_rect,
-                     false);
+  DrawFrame(&renderer, viewport_rect);
   Mock::VerifyAndClearExpectations(context);
 }
 
 class TextureStateTrackingContext : public TestWebGraphicsContext3D {
  public:
   TextureStateTrackingContext() : active_texture_(GL_INVALID_ENUM) {
     test_capabilities_.egl_image_external = true;
   }
 
   MOCK_METHOD1(waitSyncToken, void(const GLbyte* sync_token));
@@ skipping 76 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(5);
   }
 
   gfx::Rect viewport_rect(100, 100);
-  renderer.DrawFrame(&render_passes_in_draw_order_,
-                     1.f,
-                     viewport_rect,
-                     viewport_rect,
-                     false);
+  DrawFrame(&renderer, viewport_rect);
   Mock::VerifyAndClearExpectations(context);
 }
 
 class NoClearRootRenderPassMockContext : public TestWebGraphicsContext3D {
  public:
   MOCK_METHOD1(clear, void(GLbitfield mask));
   MOCK_METHOD4(drawElements,
                void(GLenum mode, GLsizei count, GLenum type, GLintptr offset));
 };
 
@@ skipping 52 matching lines @@
       EXPECT_CALL(*mock_context, drawElements(_, _, _, _)).Times(1);
 
   // The second render pass is the root one, clearing should be prevented.
   EXPECT_CALL(*mock_context, clear(clear_bits)).Times(0).After(
       first_render_pass);
 
   EXPECT_CALL(*mock_context, drawElements(_, _, _, _)).Times(AnyNumber()).After(
       first_render_pass);
 
   renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
-  renderer.DrawFrame(&render_passes_in_draw_order_,
-                     1.f,
-                     viewport_rect,
-                     viewport_rect,
-                     false);
+  DrawFrame(&renderer, viewport_rect);
 
   // 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 55 matching lines @@
   RenderPassId root_pass_id(1, 0);
   RenderPass* 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_);
-  renderer.DrawFrame(&render_passes_in_draw_order_,
-                     1.f,
-                     viewport_rect,
-                     viewport_rect,
-                     false);
+  DrawFrame(&renderer, viewport_rect);
 }
 
 class DiscardCheckingContext : public TestWebGraphicsContext3D {
  public:
   DiscardCheckingContext() : discarded_(0) {
     set_have_post_sub_buffer(true);
     set_have_discard_framebuffer(true);
   }
 
   void discardFramebufferEXT(GLenum target,
@@ skipping 13 matching lines @@
  public:
   explicit NonReshapableOutputSurface(
       std::unique_ptr<TestWebGraphicsContext3D> context3d)
       : FakeOutputSurface(TestContextProvider::Create(std::move(context3d)),
                           nullptr,
                           false) {
     surface_size_ = gfx::Size(500, 500);
   }
   void Reshape(const gfx::Size& size,
                float scale_factor,
+               const gfx::ColorSpace& color_space,
                bool has_alpha) override {}
   void set_fixed_size(const gfx::Size& size) { surface_size_ = size; }
 };
 
 TEST_F(GLRendererTest, NoDiscardOnPartialUpdates) {
   std::unique_ptr<DiscardCheckingContext> context_owned(
       new DiscardCheckingContext);
   DiscardCheckingContext* context = context_owned.get();
 
   FakeOutputSurfaceClient output_surface_client;
@@ skipping 23 matching lines @@
   {
     // Partial frame, should not discard.
     RenderPassId root_pass_id(1, 0);
     RenderPass* 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);
+    DrawFrame(&renderer, viewport_rect, clip_rect);
     EXPECT_EQ(0, context->discarded());
     context->reset();
   }
   {
     // Full frame, should discard.
     RenderPassId root_pass_id(1, 0);
     RenderPass* 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);
+    DrawFrame(&renderer, viewport_rect, clip_rect);
     EXPECT_EQ(1, context->discarded());
     context->reset();
   }
   {
     // Full frame, external scissor is set, should not discard.
     output_surface->set_has_external_stencil_test(true);
     RenderPassId root_pass_id(1, 0);
     RenderPass* 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);
+    DrawFrame(&renderer, viewport_rect, clip_rect);
     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);
     RenderPassId root_pass_id(1, 0);
     RenderPass* 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);
+    DrawFrame(&renderer, viewport_rect, clip_rect);
     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);
     RenderPassId root_pass_id(1, 0);
     RenderPass* 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);
+    DrawFrame(&renderer, viewport_rect, clip_rect);
     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);
     RenderPassId root_pass_id(1, 0);
     RenderPass* 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);
+    DrawFrame(&renderer, viewport_rect, clip_rect);
     EXPECT_EQ(0, context->discarded());
     context->reset();
   }
 }
 
 class FlippedScissorAndViewportContext : public TestWebGraphicsContext3D {
  public:
   MOCK_METHOD4(viewport, void(GLint x, GLint y, GLsizei width, GLsizei height));
   MOCK_METHOD4(scissor, void(GLint x, GLint y, GLsizei width, GLsizei height));
 };
@@ skipping 35 matching lines @@
   gfx::Rect viewport_rect(device_viewport_rect.size());
   gfx::Rect quad_rect = gfx::Rect(20, 20, 20, 20);
 
   RenderPassId root_pass_id(1, 0);
   RenderPass* 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);
+  DrawFrame(&renderer, device_viewport_rect);
 }
 
 TEST_F(GLRendererTest, DrawFramePreservesFramebuffer) {
   // When using render-to-FBO to display the surface, all rendering is done
   // to a non-zero FBO. Make sure that the framebuffer is always restored to
   // the correct framebuffer during rendering, if changed.
   // Note: there is one path that will set it to 0, but that is after the render
   // has finished.
   FakeOutputSurfaceClient output_surface_client;
   std::unique_ptr<FakeOutputSurface> output_surface(
@@ skipping 22 matching lines @@
                     gfx::Transform());
   AddClippedQuad(root_pass, quad_rect, SK_ColorGREEN);
 
   unsigned fbo;
   gpu::gles2::GLES2Interface* gl =
       output_surface->context_provider()->ContextGL();
   gl->GenFramebuffers(1, &fbo);
   output_surface->set_framebuffer(fbo, GL_RGB);
 
   renderer.DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
-  renderer.DrawFrame(&render_passes_in_draw_order_, 1.f, device_viewport_rect,
-                     device_viewport_rect, false);
+  DrawFrame(&renderer, device_viewport_rect);
 
   int bound_fbo;
   gl->GetIntegerv(GL_FRAMEBUFFER_BINDING, &bound_fbo);
   EXPECT_EQ(static_cast<int>(fbo), bound_fbo);
 }
 
 TEST_F(GLRendererShaderTest, DrawRenderPassQuadShaderPermutations) {
   gfx::Rect viewport_rect(1, 1);
 
   gfx::Rect child_rect(50, 50);
@@ skipping 50 matching lines @@
 
     AddRenderPassQuad(root_pass,
                       child_pass,
                       0,
                       FilterOperations(),
                       gfx::Transform(),
                       xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
-    renderer_->DrawFrame(&render_passes_in_draw_order_,
-                         1.f,
-                         viewport_rect,
-                         viewport_rect,
-                         false);
+    DrawFrame(renderer_.get(), viewport_rect);
     TestRenderPassProgram(TEX_COORD_PRECISION_MEDIUM, blend_mode);
 
     // RenderPassColorMatrixProgram
     render_passes_in_draw_order_.clear();
 
     child_pass = AddRenderPass(&render_passes_in_draw_order_,
                                child_pass_id,
                                child_rect,
                                transform_causing_aa);
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_,
                               root_pass_id,
                               viewport_rect,
                               gfx::Transform());
 
     AddRenderPassQuad(
         root_pass, child_pass, 0, filters, gfx::Transform(), xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
-    renderer_->DrawFrame(&render_passes_in_draw_order_,
-                         1.f,
-                         viewport_rect,
-                         viewport_rect,
-                         false);
+    DrawFrame(renderer_.get(), viewport_rect);
     TestRenderPassColorMatrixProgram(TEX_COORD_PRECISION_MEDIUM, blend_mode);
 
     // RenderPassMaskProgram
     render_passes_in_draw_order_.clear();
 
     child_pass = AddRenderPass(&render_passes_in_draw_order_,
                                child_pass_id,
                                child_rect,
                                gfx::Transform());
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_,
                               root_pass_id,
                               viewport_rect,
                               gfx::Transform());
 
     AddRenderPassQuad(root_pass,
                       child_pass,
                       mask,
                       FilterOperations(),
                       gfx::Transform(),
                       xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
-    renderer_->DrawFrame(&render_passes_in_draw_order_,
-                         1.f,
-                         viewport_rect,
-                         viewport_rect,
-                         false);
+    DrawFrame(renderer_.get(), viewport_rect);
     TestRenderPassMaskProgram(TEX_COORD_PRECISION_MEDIUM, SAMPLER_TYPE_2D,
                               blend_mode);
 
     // RenderPassMaskColorMatrixProgram
     render_passes_in_draw_order_.clear();
 
     child_pass = AddRenderPass(&render_passes_in_draw_order_,
                                child_pass_id,
                                child_rect,
                                gfx::Transform());
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_,
                               root_pass_id,
                               viewport_rect,
                               gfx::Transform());
 
     AddRenderPassQuad(
         root_pass, child_pass, mask, filters, gfx::Transform(), xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
-    renderer_->DrawFrame(&render_passes_in_draw_order_,
-                         1.f,
-                         viewport_rect,
-                         viewport_rect,
-                         false);
+    DrawFrame(renderer_.get(), viewport_rect);
     TestRenderPassMaskColorMatrixProgram(TEX_COORD_PRECISION_MEDIUM,
                                          SAMPLER_TYPE_2D, blend_mode);
 
     // RenderPassProgramAA
     render_passes_in_draw_order_.clear();
 
     child_pass = AddRenderPass(&render_passes_in_draw_order_,
                                child_pass_id,
                                child_rect,
                                transform_causing_aa);
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_,
                               root_pass_id,
                               viewport_rect,
                               gfx::Transform());
 
     AddRenderPassQuad(root_pass,
                       child_pass,
                       0,
                       FilterOperations(),
                       transform_causing_aa,
                       xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
-    renderer_->DrawFrame(&render_passes_in_draw_order_,
-                         1.f,
-                         viewport_rect,
-                         viewport_rect,
-                         false);
+    DrawFrame(renderer_.get(), viewport_rect);
     TestRenderPassProgramAA(TEX_COORD_PRECISION_MEDIUM, blend_mode);
 
     // RenderPassColorMatrixProgramAA
     render_passes_in_draw_order_.clear();
 
     child_pass = AddRenderPass(&render_passes_in_draw_order_,
                                child_pass_id,
                                child_rect,
                                transform_causing_aa);
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_,
                               root_pass_id,
                               viewport_rect,
                               gfx::Transform());
 
     AddRenderPassQuad(
         root_pass, child_pass, 0, filters, transform_causing_aa, xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
-    renderer_->DrawFrame(&render_passes_in_draw_order_,
-                         1.f,
-                         viewport_rect,
-                         viewport_rect,
-                         false);
+    DrawFrame(renderer_.get(), viewport_rect);
     TestRenderPassColorMatrixProgramAA(TEX_COORD_PRECISION_MEDIUM, blend_mode);
 
     // RenderPassMaskProgramAA
     render_passes_in_draw_order_.clear();
 
     child_pass = AddRenderPass(&render_passes_in_draw_order_,
                                child_pass_id,
                                child_rect,
                                transform_causing_aa);
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_,
                               root_pass_id,
                               viewport_rect,
                               gfx::Transform());
 
     AddRenderPassQuad(root_pass,
                       child_pass,
                       mask,
                       FilterOperations(),
                       transform_causing_aa,
                       xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
-    renderer_->DrawFrame(&render_passes_in_draw_order_,
-                         1.f,
-                         viewport_rect,
-                         viewport_rect,
-                         false);
+    DrawFrame(renderer_.get(), viewport_rect);
     TestRenderPassMaskProgramAA(TEX_COORD_PRECISION_MEDIUM, SAMPLER_TYPE_2D,
                                 blend_mode);
 
     // RenderPassMaskColorMatrixProgramAA
     render_passes_in_draw_order_.clear();
 
     child_pass = AddRenderPass(&render_passes_in_draw_order_,
                                child_pass_id,
                                child_rect,
                                transform_causing_aa);
 
     root_pass = AddRenderPass(&render_passes_in_draw_order_,
                               root_pass_id,
                               viewport_rect,
                               transform_causing_aa);
 
     AddRenderPassQuad(
         root_pass, child_pass, mask, filters, transform_causing_aa, xfer_mode);
 
     renderer_->DecideRenderPassAllocationsForFrame(
         render_passes_in_draw_order_);
-    renderer_->DrawFrame(&render_passes_in_draw_order_,
-                         1.f,
-                         viewport_rect,
-                         viewport_rect,
-                         false);
+    DrawFrame(renderer_.get(), viewport_rect);
     TestRenderPassMaskColorMatrixProgramAA(TEX_COORD_PRECISION_MEDIUM,
                                            SAMPLER_TYPE_2D, blend_mode);
   }
 }
 
 // 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);
   RenderPassId child_pass_id(2, 0);
@@ skipping 26 matching lines @@
                             gfx::Transform());
 
   AddRenderPassQuad(root_pass,
                     child_pass,
                     0,
                     FilterOperations(),
                     transform_preventing_aa,
                     SkXfermode::kSrcOver_Mode);
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
-  renderer_->DrawFrame(&render_passes_in_draw_order_,
-                       1.f,
-                       viewport_rect,
-                       viewport_rect,
-                       false);
+  DrawFrame(renderer_.get(), viewport_rect);
 
   // If use_aa incorrectly ignores clipping, it will use the
   // RenderPassProgramAA shader instead of the RenderPassProgram.
   TestRenderPassProgram(TEX_COORD_PRECISION_MEDIUM, BLEND_MODE_NONE);
 }
 
 TEST_F(GLRendererShaderTest, DrawSolidColorShader) {
   gfx::Rect viewport_rect(1, 1);
   RenderPassId root_pass_id(1, 0);
   RenderPass* 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());
   AddTransformedQuad(root_pass,
                      viewport_rect,
                      SK_ColorYELLOW,
                      pixel_aligned_transform_causing_aa);
 
   renderer_->DecideRenderPassAllocationsForFrame(render_passes_in_draw_order_);
-  renderer_->DrawFrame(&render_passes_in_draw_order_,
-                       1.f,
-                       viewport_rect,
-                       viewport_rect,
-                       false);
+  DrawFrame(renderer_.get(), viewport_rect);
 
   TestSolidColorProgramAA();
 }
 
 class OutputSurfaceMockContext : public TestWebGraphicsContext3D {
  public:
   OutputSurfaceMockContext() { test_capabilities_.post_sub_buffer = true; }
 
   // Specifically override methods even if they are unused (used in conjunction
   // with StrictMock). We need to make sure that GLRenderer does not issue
@@ skipping 13 matching lines @@
             TestContextProvider::Create(
                 base::MakeUnique<StrictMock<OutputSurfaceMockContext>>()),
             nullptr,
             nullptr) {
     surface_size_ = gfx::Size(100, 100);
   }
   virtual ~MockOutputSurface() {}
 
   MOCK_METHOD0(EnsureBackbuffer, void());
   MOCK_METHOD0(DiscardBackbuffer, void());
-  MOCK_METHOD3(Reshape,
-               void(const gfx::Size& size, float scale_factor, bool has_alpha));
+  MOCK_METHOD4(Reshape,
+               void(const gfx::Size& size,
+                    float scale_factor,
+                    const gfx::ColorSpace& color_space,
+                    bool has_alpha));
   MOCK_METHOD0(BindFramebuffer, void());
   MOCK_METHOD0(GetFramebufferCopyTextureFormat, GLenum());
   MOCK_METHOD1(SwapBuffers_, void(CompositorFrame& frame));
   void SwapBuffers(CompositorFrame frame) override { SwapBuffers_(frame); }
 };
 
 class MockOutputSurfaceTest : public GLRendererTest {
  protected:
   virtual void SetUp() {
     FakeOutputSurfaceClient output_surface_client_;
@@ skipping 17 matching lines @@
     RenderPassId render_pass_id(1, 0);
     RenderPass* render_pass =
         AddRenderPass(&render_passes_in_draw_order_, render_pass_id,
                       device_viewport_rect, gfx::Transform());
     AddQuad(render_pass, device_viewport_rect, SK_ColorGREEN);
     render_pass->has_transparent_background = transparent;
 
     EXPECT_CALL(output_surface_, EnsureBackbuffer()).WillRepeatedly(Return());
 
     EXPECT_CALL(output_surface_, Reshape(device_viewport_rect.size(),
-                                         device_scale_factor, transparent))
+                                         device_scale_factor, _, transparent))
         .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_,
-                         device_scale_factor,
-                         device_viewport_rect,
-                         device_viewport_rect,
-                         false);
+    renderer_->DrawFrame(&render_passes_in_draw_order_, device_scale_factor,
+                         gfx::ColorSpace(), device_viewport_rect,
+                         device_viewport_rect, false);
   }
 
   OutputSurfaceMockContext* Context() {
     return static_cast<OutputSurfaceMockContext*>(
         static_cast<TestContextProvider*>(output_surface_.context_provider())
             ->TestContext3d());
   }
 
   RendererSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
@@ skipping 146 matching lines @@
                        gfx::PointF(1, 1), SK_ColorTRANSPARENT, vertex_opacity,
                        flipped, nearest_neighbor, false);
 
   // DirectRenderer::DrawFrame calls into OverlayProcessor::ProcessForOverlays.
   // Attempt will be called for each strategy in OverlayProcessor. We have
   // added a fake strategy, so checking for Attempt calls checks if there was
   // any attempt to overlay, which there shouldn't be. We can't use the quad
   // list because the render pass is cleaned up by DrawFrame.
   EXPECT_CALL(*processor->strategy_, Attempt(_, _, _)).Times(0);
   EXPECT_CALL(*validator, AllowCALayerOverlays()).Times(0);
-  renderer.DrawFrame(&render_passes_in_draw_order_, 1.f, viewport_rect,
-                     viewport_rect, false);
+  DrawFrame(&renderer, viewport_rect);
   Mock::VerifyAndClearExpectations(processor->strategy_);
   Mock::VerifyAndClearExpectations(validator.get());
 
   // Without a copy request Attempt() should be called once.
   root_pass = AddRenderPass(&render_passes_in_draw_order_, RenderPassId(1, 0),
                             viewport_rect, gfx::Transform());
   root_pass->has_transparent_background = false;
 
   overlay_quad = root_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   overlay_quad->SetNew(root_pass->CreateAndAppendSharedQuadState(),
                        viewport_rect, viewport_rect, viewport_rect, resource_id,
                        premultiplied_alpha, gfx::PointF(0, 0),
                        gfx::PointF(1, 1), SK_ColorTRANSPARENT, vertex_opacity,
                        flipped, nearest_neighbor, false);
   EXPECT_CALL(*validator, AllowCALayerOverlays())
       .Times(1)
       .WillOnce(::testing::Return(false));
   EXPECT_CALL(*processor->strategy_, Attempt(_, _, _)).Times(1);
-  renderer.DrawFrame(&render_passes_in_draw_order_, 1.f, viewport_rect,
-                     viewport_rect, false);
+  DrawFrame(&renderer, viewport_rect);
 
   // If the CALayerOverlay path is taken, then the ordinary overlay path should
   // not be called.
   root_pass = AddRenderPass(&render_passes_in_draw_order_, RenderPassId(1, 0),
                             viewport_rect, gfx::Transform());
   root_pass->has_transparent_background = false;
 
   overlay_quad = root_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   overlay_quad->SetNew(root_pass->CreateAndAppendSharedQuadState(),
                        viewport_rect, viewport_rect, viewport_rect, resource_id,
                        premultiplied_alpha, gfx::PointF(0, 0),
                        gfx::PointF(1, 1), SK_ColorTRANSPARENT, vertex_opacity,
                        flipped, nearest_neighbor, false);
   EXPECT_CALL(*validator, AllowCALayerOverlays())
       .Times(1)
       .WillOnce(::testing::Return(true));
   EXPECT_CALL(*processor->strategy_, Attempt(_, _, _)).Times(0);
-  renderer.DrawFrame(&render_passes_in_draw_order_, 1.f, viewport_rect,
-                     viewport_rect, false);
+  DrawFrame(&renderer, viewport_rect);
 }
 
 class SingleOverlayOnTopProcessor : public OverlayProcessor {
  public:
   class SingleOverlayValidator : public OverlayCandidateValidator {
    public:
     void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
       strategies->push_back(
           base::WrapUnique(new OverlayStrategySingleOnTop(this)));
       strategies->push_back(
@@ skipping 101 matching lines @@
                        uv_top_left, uv_bottom_right, SK_ColorTRANSPARENT,
                        vertex_opacity, flipped, nearest_neighbor, false);
 
   // Verify that overlay_quad actually gets turned into an overlay, and even
   // though it's not drawn, that its sync point is waited on.
   EXPECT_CALL(*context, waitSyncToken(MatchesSyncToken(sync_token))).Times(1);
   EXPECT_CALL(overlay_scheduler,
               Schedule(1, gfx::OVERLAY_TRANSFORM_NONE, _, viewport_rect,
                        BoundingRect(uv_top_left, uv_bottom_right))).Times(1);
 
-  renderer.DrawFrame(&render_passes_in_draw_order_, 1.f, viewport_rect,
-                     viewport_rect, false);
+  DrawFrame(&renderer, viewport_rect);
 }
 
 }  // namespace
 }  // namespace cc