Change output surface opacity to match root render pass.

This allows windows that don't need opacity to be presented more efficiently (e.g. with no blending with the contents underneath them).

BUG=561185
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1501513004

Cr-Commit-Position: refs/heads/master@{#365315}

7 files changed, 41 insertions, 20 deletions

diff --git a/cc/output/direct_renderer.cc b/cc/output/direct_renderer.cc
index a55564f..d22d7e4 100644
--- a/cc/output/direct_renderer.cc
+++ b/cc/output/direct_renderer.cc
@@ -218,7 +218,8 @@ void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
   // Only reshape when we know we are going to draw. Otherwise, the reshape
   // can leave the window at the wrong size if we never draw and the proper
   // viewport size is never set.
-  output_surface_->Reshape(device_viewport_rect.size(), device_scale_factor);
+  output_surface_->Reshape(device_viewport_rect.size(), device_scale_factor,
+                           frame.root_render_pass->has_transparent_background);
 
   BeginDrawingFrame(&frame);
 
diff --git a/cc/output/gl_renderer_unittest.cc b/cc/output/gl_renderer_unittest.cc
index 97bd2d9..3e8535e 100644
--- a/cc/output/gl_renderer_unittest.cc
+++ b/cc/output/gl_renderer_unittest.cc
@@ -1132,7 +1132,9 @@ class NonReshapableOutputSurface : public FakeOutputSurface {
                           false) {
     surface_size_ = gfx::Size(500, 500);
   }
-  void Reshape(const gfx::Size& size, float scale_factor) override {}
+  void Reshape(const gfx::Size& size,
+               float scale_factor,
+               bool has_alpha) override {}
   void set_fixed_size(const gfx::Size& size) { surface_size_ = size; }
 };
 
@@ -1756,7 +1758,8 @@ class MockOutputSurface : public OutputSurface {
 
   MOCK_METHOD0(EnsureBackbuffer, void());
   MOCK_METHOD0(DiscardBackbuffer, void());
-  MOCK_METHOD2(Reshape, void(const gfx::Size& size, float scale_factor));
+  MOCK_METHOD3(Reshape,
+               void(const gfx::Size& size, float scale_factor, bool has_alpha));
   MOCK_METHOD0(BindFramebuffer, void());
   MOCK_METHOD1(SwapBuffers, void(CompositorFrame* frame));
 };
@@ -1780,17 +1783,19 @@ class MockOutputSurfaceTest : public GLRendererTest {
   void SwapBuffers() { renderer_->SwapBuffers(CompositorFrameMetadata()); }
 
   void DrawFrame(float device_scale_factor,
-                 const gfx::Rect& device_viewport_rect) {
+                 const gfx::Rect& device_viewport_rect,
+                 bool transparent) {
     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))
+    EXPECT_CALL(output_surface_, Reshape(device_viewport_rect.size(),
+                                         device_scale_factor, transparent))
         .Times(1);
 
     EXPECT_CALL(output_surface_, BindFramebuffer()).Times(1);
@@ -1823,7 +1828,15 @@ class MockOutputSurfaceTest : public GLRendererTest {
 
 TEST_F(MockOutputSurfaceTest, DrawFrameAndSwap) {
   gfx::Rect device_viewport_rect(1, 1);
-  DrawFrame(1.f, device_viewport_rect);
+  DrawFrame(1.f, device_viewport_rect, true);
+
+  EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);
+  renderer_->SwapBuffers(CompositorFrameMetadata());
+}
+
+TEST_F(MockOutputSurfaceTest, DrawOpaqueFrameAndSwap) {
+  gfx::Rect device_viewport_rect(1, 1);
+  DrawFrame(1.f, device_viewport_rect, false);
 
   EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);
   renderer_->SwapBuffers(CompositorFrameMetadata());
@@ -1832,23 +1845,23 @@ TEST_F(MockOutputSurfaceTest, DrawFrameAndSwap) {
 TEST_F(MockOutputSurfaceTest, DrawFrameAndResizeAndSwap) {
   gfx::Rect device_viewport_rect(1, 1);
 
-  DrawFrame(1.f, device_viewport_rect);
+  DrawFrame(1.f, device_viewport_rect, true);
   EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);
   renderer_->SwapBuffers(CompositorFrameMetadata());
 
   device_viewport_rect = gfx::Rect(2, 2);
 
-  DrawFrame(2.f, device_viewport_rect);
+  DrawFrame(2.f, device_viewport_rect, true);
   EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);
   renderer_->SwapBuffers(CompositorFrameMetadata());
 
-  DrawFrame(2.f, device_viewport_rect);
+  DrawFrame(2.f, device_viewport_rect, true);
   EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);
   renderer_->SwapBuffers(CompositorFrameMetadata());
 
   device_viewport_rect = gfx::Rect(1, 1);
 
-  DrawFrame(1.f, device_viewport_rect);
+  DrawFrame(1.f, device_viewport_rect, true);
   EXPECT_CALL(output_surface_, SwapBuffers(_)).Times(1);
   renderer_->SwapBuffers(CompositorFrameMetadata());
 }
diff --git a/cc/output/output_surface.cc b/cc/output/output_surface.cc
index d8b7962..24ec039 100644
--- a/cc/output/output_surface.cc
+++ b/cc/output/output_surface.cc
@@ -124,6 +124,7 @@ OutputSurface::OutputSurface(
       worker_context_provider_(worker_context_provider),
       software_device_(std::move(software_device)),
       device_scale_factor_(-1),
+      has_alpha_(true),
       external_stencil_test_enabled_(false),
       weak_ptr_factory_(this) {
   client_thread_checker_.DetachFromThread();
@@ -250,15 +251,19 @@ void OutputSurface::DiscardBackbuffer() {
     software_device_->DiscardBackbuffer();
 }
 
-void OutputSurface::Reshape(const gfx::Size& size, float scale_factor) {
-  if (size == surface_size_ && scale_factor == device_scale_factor_)
+void OutputSurface::Reshape(const gfx::Size& size,
+                            float scale_factor,
+                            bool has_alpha) {
+  if (size == surface_size_ && scale_factor == device_scale_factor_ &&
+      has_alpha == has_alpha_)
     return;
 
   surface_size_ = size;
   device_scale_factor_ = scale_factor;
+  has_alpha_ = has_alpha;
   if (context_provider_.get()) {
     context_provider_->ContextGL()->ResizeCHROMIUM(size.width(), size.height(),
-                                                   scale_factor, GL_TRUE);
+                                                   scale_factor, has_alpha);
   }
   if (software_device_)
     software_device_->Resize(size, scale_factor);
diff --git a/cc/output/output_surface.h b/cc/output/output_surface.h
index 2176455..c23702e 100644
--- a/cc/output/output_surface.h
+++ b/cc/output/output_surface.h
@@ -118,7 +118,7 @@ class CC_EXPORT OutputSurface : public base::trace_event::MemoryDumpProvider {
   virtual void EnsureBackbuffer();
   virtual void DiscardBackbuffer();
 
-  virtual void Reshape(const gfx::Size& size, float scale_factor);
+  virtual void Reshape(const gfx::Size& size, float scale_factor, bool alpha);
   gfx::Size SurfaceSize() const { return surface_size_; }
   float device_scale_factor() const { return device_scale_factor_; }
 
@@ -182,6 +182,7 @@ class CC_EXPORT OutputSurface : public base::trace_event::MemoryDumpProvider {
   scoped_ptr<SoftwareOutputDevice> software_device_;
   gfx::Size surface_size_;
   float device_scale_factor_;
+  bool has_alpha_;
   base::ThreadChecker client_thread_checker_;
 
   void CommitVSyncParameters(base::TimeTicks timebase,
diff --git a/cc/output/renderer_pixeltest.cc b/cc/output/renderer_pixeltest.cc
index 110f9fe..1c7f086 100644
--- a/cc/output/renderer_pixeltest.cc
+++ b/cc/output/renderer_pixeltest.cc
@@ -1862,7 +1862,7 @@ class ExternalStencilPixelTest : public GLRendererPixelTest {
   void ClearBackgroundToGreen() {
     GLES2Interface* gl = output_surface_->context_provider()->ContextGL();
     output_surface_->EnsureBackbuffer();
-    output_surface_->Reshape(device_viewport_size_, 1);
+    output_surface_->Reshape(device_viewport_size_, 1, true);
     gl->ClearColor(0.f, 1.f, 0.f, 1.f);
     gl->Clear(GL_COLOR_BUFFER_BIT);
   }
@@ -1871,7 +1871,7 @@ class ExternalStencilPixelTest : public GLRendererPixelTest {
     // Set two quadrants of the stencil buffer to 1.
     GLES2Interface* gl = output_surface_->context_provider()->ContextGL();
     output_surface_->EnsureBackbuffer();
-    output_surface_->Reshape(device_viewport_size_, 1);
+    output_surface_->Reshape(device_viewport_size_, 1, true);
     gl->ClearStencil(0);
     gl->Clear(GL_STENCIL_BUFFER_BIT);
     gl->Enable(GL_SCISSOR_TEST);
diff --git a/cc/test/pixel_test_output_surface.cc b/cc/test/pixel_test_output_surface.cc
index 6d5072c..421afc0 100644
--- a/cc/test/pixel_test_output_surface.cc
+++ b/cc/test/pixel_test_output_surface.cc
@@ -33,10 +33,11 @@ PixelTestOutputSurface::PixelTestOutputSurface(
       external_stencil_test_(false) {}
 
 void PixelTestOutputSurface::Reshape(const gfx::Size& size,
-                                     float scale_factor) {
+                                     float scale_factor,
+                                     bool has_alpha) {
   gfx::Size expanded_size(size.width() + surface_expansion_size_.width(),
                           size.height() + surface_expansion_size_.height());
-  OutputSurface::Reshape(expanded_size, scale_factor);
+  OutputSurface::Reshape(expanded_size, scale_factor, has_alpha);
 }
 
 bool PixelTestOutputSurface::HasExternalStencilTest() const {
diff --git a/cc/test/pixel_test_output_surface.h b/cc/test/pixel_test_output_surface.h
index 27819c1..f2c5f66 100644
--- a/cc/test/pixel_test_output_surface.h
+++ b/cc/test/pixel_test_output_surface.h
@@ -21,7 +21,7 @@ class PixelTestOutputSurface : public OutputSurface {
   explicit PixelTestOutputSurface(
       scoped_ptr<SoftwareOutputDevice> software_device);
 
-  void Reshape(const gfx::Size& size, float scale_factor) override;
+  void Reshape(const gfx::Size& size, float scale_factor, bool alpha) override;
   bool HasExternalStencilTest() const override;
   void SwapBuffers(CompositorFrame* frame) override;