Reset GL state before copying RenderPassDrawQuads to CALayers.

cc/output/gl_renderer.cc

 // Copyright 2010 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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 3846 matching lines @@
 //   3. Fix shader uniforms that were broken by (2).
 //
 // Then:
 //   4. Allocate an IOSurface as the drawing destination.
 //   5. Draw the RPDQ.
 void GLRenderer::CopyRenderPassDrawQuadToOverlayResource(
     const CALayerOverlay* ca_layer_overlay,
     Resource** resource,
     DrawingFrame* external_frame,
     gfx::RectF* new_bounds) {
+  // Don't carry over any GL state from previous RenderPass draw operations.
+  ReinitializeGLState();

[ericrk, 2016/08/24 19:04:50]

This makes sense - so the state was just left over from previous rendering?

Also, I wonder if we should do this higher up the chain (in ScheduleCALayers?)
to avoid re-setting this state unnecessarily a bunch of times?

[erikchen, 2016/08/24 20:04:36]

Yup. Unfortunately, GLRenderer is very stateful.
I considered that. Most of the time, this function never gets called, so that
would be unnecessary. We could add yet more logic to ScheduleCALayers to only
call this once, and only right before CopyRenderPassDrawQuadToOverlayResource().
Then again, we're assuming that none of the drawing operations from this
function modify state that needs to be reset between successive calls to this
function. [This is currently true, but there's no reason it has to be true going
forward.] Overall, reinitializing state here seemed like a good choice,
especially given that the overhead is minimal compared to the cost of actual
drawing operations.

+
   ScopedResource* contents_texture =
       render_pass_textures_[ca_layer_overlay->rpdq->render_pass_id].get();
   DCHECK(contents_texture);
 
   // Configure parameters as if drawing to a framebuffer the size of the
   // screen.
   DrawRenderPassDrawQuadParams params;
   params.quad = ca_layer_overlay->rpdq;
   params.flip_texture = true;
   params.contents_texture = contents_texture;
@@ skipping 83 matching lines @@
 
   gl_->GenFramebuffers(1, &temp_fbo);
   gl_->BindFramebuffer(GL_FRAMEBUFFER, temp_fbo);
   gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                             destination.target(), destination.texture_id(), 0);
   DCHECK(gl_->CheckFramebufferStatus(GL_FRAMEBUFFER) ==
          GL_FRAMEBUFFER_COMPLETE);
 
   // Clear to 0 to ensure the background is transparent.
   gl_->ClearColor(0, 0, 0, 0);
-  if (is_scissor_enabled_)
-    gl_->Disable(GL_SCISSOR_TEST);
   gl_->Clear(GL_COLOR_BUFFER_BIT);
-  if (is_scissor_enabled_)
-    gl_->Enable(GL_SCISSOR_TEST);
 
   UpdateRPDQTexturesForSampling(&params);
   UpdateRPDQBlendMode(&params);
   ChooseRPDQProgram(&params);
   UpdateRPDQUniforms(&params);
 
   // Prior to drawing, set up the destination framebuffer and viewport.
   gl_->BindFramebuffer(GL_FRAMEBUFFER, temp_fbo);
   gl_->Viewport(0, 0, updated_dst_rect.width(), updated_dst_rect.height());
 
@@ skipping 49 matching lines @@
 
   gl_->ScheduleCALayerSharedStateCHROMIUM(
       ca_layer_overlay->shared_state->opacity, is_clipped, clip_rect,
       sorting_context_id, gl_transform);
   gl_->ScheduleCALayerCHROMIUM(
       texture_id, contents_rect, ca_layer_overlay->background_color,
       ca_layer_overlay->edge_aa_mask, bounds_rect, filter);
 }
 
 }  // namespace cc