Always set damage rect to output rect if 3D context was reshaped.

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>
 #include <vector>
@@ skipping 2028 matching lines @@
     RendererSettings settings;
     settings.partial_swap_enabled = partial_swap;
     FakeRendererGL renderer(&settings, output_surface.get(),
                             resource_provider.get());
     renderer.Initialize();
     EXPECT_EQ(partial_swap, renderer.use_partial_swap());
     renderer.SetVisible(true);
 
     gfx::Size viewport_size(100, 100);
 
-    {
+    for (int i = 0; i < 2; ++i) {
       int root_pass_id = 1;
       RenderPass* root_pass = AddRenderPass(
           &render_passes_in_draw_order_, root_pass_id, gfx::Rect(viewport_size),
           gfx::Transform(), FilterOperations());
       AddQuad(root_pass, gfx::Rect(viewport_size), SK_ColorGREEN);
 
       testing::Sequence seq;
       // A bunch of initialization that happens.
       EXPECT_CALL(*gl, Disable(GL_DEPTH_TEST)).InSequence(seq);
       EXPECT_CALL(*gl, Disable(GL_CULL_FACE)).InSequence(seq);
       EXPECT_CALL(*gl, Disable(GL_STENCIL_TEST)).InSequence(seq);
       EXPECT_CALL(*gl, Enable(GL_BLEND)).InSequence(seq);
       EXPECT_CALL(*gl, Disable(GL_SCISSOR_TEST)).InSequence(seq);
       EXPECT_CALL(*gl, Scissor(0, 0, 0, 0)).InSequence(seq);
 
       // Partial frame, we should use a scissor to swap only that part when
       // partial swap is enabled.
       root_pass->damage_rect = gfx::Rect(2, 2, 3, 3);
-      gfx::Rect output_rectangle =
-          partial_swap ? root_pass->damage_rect : gfx::Rect(viewport_size);
+      // With SetDrawRectangle the first frame will have its damage expanded
+      // to cover the entire output rect.
+      bool frame_has_partial_damage =
+          partial_swap && (!set_draw_rectangle || (i > 0));
+      gfx::Rect output_rectangle = frame_has_partial_damage
+                                       ? root_pass->damage_rect
+                                       : gfx::Rect(viewport_size);
 
       if (partial_swap || set_draw_rectangle) {
         EXPECT_CALL(*gl, Enable(GL_SCISSOR_TEST)).InSequence(seq);
         // The scissor is flipped, so subtract the y coord and height from the
         // bottom of the GL viewport.
         EXPECT_CALL(
             *gl,
             Scissor(output_rectangle.x(),
                     viewport_size.height() - output_rectangle.y() -
                         output_rectangle.height(),
                     output_rectangle.width(), output_rectangle.height()))
             .InSequence(seq);
       }
 
       // The quad doesn't need blending.
       EXPECT_CALL(*gl, Disable(GL_BLEND)).InSequence(seq);
 
       // Blending is disabled at the end of the frame.
       EXPECT_CALL(*gl, Disable(GL_BLEND)).InSequence(seq);
 
       renderer.DecideRenderPassAllocationsForFrame(
           render_passes_in_draw_order_);
       DrawFrame(&renderer, viewport_size);
       if (set_draw_rectangle) {
         EXPECT_EQ(output_rectangle, output_surface->last_set_draw_rectangle());
       }
+      Mock::VerifyAndClearExpectations(gl);
     }
   }
 };
 
 TEST_F(GLRendererPartialSwapTest, PartialSwap) {
   RunTest(true, false);
 }
 
 TEST_F(GLRendererPartialSwapTest, NoPartialSwap) {
   RunTest(false, false);
@@ skipping 245 matching lines @@
 
 TEST_F(GLRendererSwapWithBoundsTest, NonEmpty) {
   std::vector<gfx::Rect> content_bounds;
   content_bounds.push_back(gfx::Rect(0, 0, 10, 10));
   content_bounds.push_back(gfx::Rect(20, 20, 30, 30));
   RunTest(content_bounds);
 }
 
 }  // namespace
 }  // namespace cc