Remove SetDrawViewport

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 <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 399 matching lines @@
   GLenum attachments[] = {static_cast<GLenum>(
       using_default_framebuffer ? GL_COLOR_EXT : GL_COLOR_ATTACHMENT0_EXT)};
   gl_->DiscardFramebufferEXT(
       GL_FRAMEBUFFER, arraysize(attachments), attachments);
 }
 
 void GLRenderer::PrepareSurfaceForPass(
     DrawingFrame* frame,
     SurfaceInitializationMode initialization_mode,
     const gfx::Rect& render_pass_scissor) {
+  SetViewport();
+
   switch (initialization_mode) {
     case SURFACE_INITIALIZATION_MODE_PRESERVE:
       EnsureScissorTestDisabled();
       return;
     case SURFACE_INITIALIZATION_MODE_FULL_SURFACE_CLEAR:
       EnsureScissorTestDisabled();
       DiscardPixels();
       ClearFramebuffer(frame);
       break;
     case SURFACE_INITIALIZATION_MODE_SCISSORED_CLEAR:
@@ skipping 785 matching lines @@
                        mask_uv_rect.width() / tex_scale_x,
                        -mask_uv_rect.height() / tex_scale_y));
 
     last_texture_unit = 1;
   }
 
   if (locations.edge != -1)
     GLC(gl_, gl_->Uniform3fv(locations.edge, 8, edge));
 
   if (locations.viewport != -1) {
-    float viewport[4] = {static_cast<float>(viewport_.x()),
-                         static_cast<float>(viewport_.y()),
-                         static_cast<float>(viewport_.width()),
-                         static_cast<float>(viewport_.height()), };
+    float viewport[4] = {
+        static_cast<float>(current_window_space_viewport_.x()),
+        static_cast<float>(current_window_space_viewport_.y()),
+        static_cast<float>(current_window_space_viewport_.width()),
+        static_cast<float>(current_window_space_viewport_.height()),
+    };
     GLC(gl_, gl_->Uniform4fv(locations.viewport, 1, viewport));
   }
 
   if (locations.color_matrix != -1) {
     float matrix[16];
     for (int i = 0; i < 4; ++i) {
       for (int j = 0; j < 4; ++j)
         matrix[i * 4 + j] = SkScalarToFloat(color_matrix[j * 5 + i]);
     }
     GLC(gl_,
@@ skipping 364 matching lines @@
   }
   SetUseProgram(uniforms.program);
 
   GLC(gl_,
       gl_->Uniform4f(uniforms.color_location,
                      (SkColorGetR(color) * (1.0f / 255.0f)) * alpha,
                      (SkColorGetG(color) * (1.0f / 255.0f)) * alpha,
                      (SkColorGetB(color) * (1.0f / 255.0f)) * alpha,
                      alpha));
   if (use_aa) {
-    float viewport[4] = {static_cast<float>(viewport_.x()),
-                         static_cast<float>(viewport_.y()),
-                         static_cast<float>(viewport_.width()),
-                         static_cast<float>(viewport_.height()), };
+    float viewport[4] = {
+        static_cast<float>(current_window_space_viewport_.x()),
+        static_cast<float>(current_window_space_viewport_.y()),
+        static_cast<float>(current_window_space_viewport_.width()),
+        static_cast<float>(current_window_space_viewport_.height()),
+    };
     GLC(gl_, gl_->Uniform4fv(uniforms.viewport_location, 1, viewport));
     GLC(gl_, gl_->Uniform3fv(uniforms.edge_location, 8, edge));
   }
 
   // Enable blending when the quad properties require it or if we decided
   // to use antialiasing.
   SetBlendEnabled(quad->ShouldDrawWithBlending() || use_aa);
 
   // Normalize to tile_rect.
   local_quad.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());
@@ skipping 143 matching lines @@
                         &uniforms);
   } else {
     TileUniformLocation(GetTileProgramAA(tex_coord_precision, sampler),
                         &uniforms);
   }
 
   SetUseProgram(uniforms.program);
   GLC(gl_, gl_->Uniform1i(uniforms.sampler_location, 0));
 
   float viewport[4] = {
-      static_cast<float>(viewport_.x()),
-      static_cast<float>(viewport_.y()),
-      static_cast<float>(viewport_.width()),
-      static_cast<float>(viewport_.height()),
+      static_cast<float>(current_window_space_viewport_.x()),
+      static_cast<float>(current_window_space_viewport_.y()),
+      static_cast<float>(current_window_space_viewport_.width()),
+      static_cast<float>(current_window_space_viewport_.height()),
   };
   GLC(gl_, gl_->Uniform4fv(uniforms.viewport_location, 1, viewport));
   GLC(gl_, gl_->Uniform3fv(uniforms.edge_location, 8, edge));
 
   GLC(gl_,
       gl_->Uniform4f(uniforms.vertex_tex_transform_location,
                      vertex_tex_translate_x,
                      vertex_tex_translate_y,
                      vertex_tex_scale_x,
                      vertex_tex_scale_y));
@@ skipping 1151 matching lines @@
   FlushTextureQuadCache(SHARED_BINDING);
   GLC(gl_,
       gl_->Scissor(scissor_rect.x(),
                    scissor_rect.y(),
                    scissor_rect.width(),
                    scissor_rect.height()));
 
   scissor_rect_needs_reset_ = false;
 }
 
-void GLRenderer::SetDrawViewport(const gfx::Rect& window_space_viewport) {
-  viewport_ = window_space_viewport;
-  GLC(gl_,
-      gl_->Viewport(window_space_viewport.x(),
-                    window_space_viewport.y(),
-                    window_space_viewport.width(),
-                    window_space_viewport.height()));
+void GLRenderer::SetViewport() {
+  GLC(gl_, gl_->Viewport(current_window_space_viewport_.x(),
+                         current_window_space_viewport_.y(),
+                         current_window_space_viewport_.width(),
+                         current_window_space_viewport_.height()));
 }
 
 void GLRenderer::InitializeSharedObjects() {
   TRACE_EVENT0("cc", "GLRenderer::InitializeSharedObjects");
 
   // Create an FBO for doing offscreen rendering.
   GLC(gl_, gl_->GenFramebuffers(1, &offscreen_framebuffer_id_));
 
   shared_geometry_ =
       make_scoped_ptr(new StaticGeometryBinding(gl_, QuadVertexRect()));
@@ skipping 524 matching lines @@
                      scissor_rect_.y(),
                      scissor_rect_.width(),
                      scissor_rect_.height()));
   } else {
     GLC(gl_, gl_->Disable(GL_SCISSOR_TEST));
   }
 }
 
 void GLRenderer::RestoreFramebuffer(DrawingFrame* frame) {
   UseRenderPass(frame, frame->current_render_pass);
+
+  // Call SetViewport directly, rather than through PrepareSurfaceForPass.
+  // PrepareSurfaceForPass also clears the surface, which is not desired when
+  // restoring.
+  SetViewport();
 }
 
 bool GLRenderer::IsContextLost() {
   return output_surface_->context_provider()->IsContextLost();
 }
 
 void GLRenderer::ScheduleOverlays(DrawingFrame* frame) {
   if (!frame->overlay_list.size())
     return;
 
@@ skipping 13 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         overlay.display_rect,
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc