When short-circuiting resize requests, keep track what the browser thinks the current size is

content/renderer/render_widget.cc

 // Copyright (c) 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 "content/renderer/render_widget.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 392 matching lines @@
     paint_aggregator_.ClearPendingUpdate();
 
     // When resizing, we want to wait to paint before ACK'ing the resize.  This
     // ensures that we only resize as fast as we can paint.  We only need to
     // send an ACK if we are resized to a non-empty rect.
     webwidget_->resize(new_size);
 
     // Resize should have caused an invalidation of the entire view.
     DCHECK(new_size.IsEmpty() || is_accelerated_compositing_active_ ||
            paint_aggregator_.HasPendingUpdate());
-  } else if (!RenderThreadImpl::current() ||  // Will be NULL during unit tests.
-             !RenderThreadImpl::current()->short_circuit_size_updates()) {
+  } else if (size_browser_expects_ == new_size) {
     resize_ack = NO_RESIZE_ACK;
   }
 
   if (new_size.IsEmpty() || physical_backing_size.IsEmpty()) {
     // For empty size or empty physical_backing_size, there is no next paint
     // (along with which to send the ack) until they are set to non-empty.
     resize_ack = NO_RESIZE_ACK;
   }
 
   // Send the Resize_ACK flag once we paint again if requested.
@@ skipping 37 matching lines @@
   CompleteInit();
 }
 
 void RenderWidget::OnResize(const gfx::Size& new_size,
                             const gfx::Size& physical_backing_size,
                             float overdraw_bottom_height,
                             const gfx::Rect& resizer_rect,
                             bool is_fullscreen) {
   Resize(new_size, physical_backing_size, overdraw_bottom_height, resizer_rect,
          is_fullscreen, SEND_RESIZE_ACK);
+  size_browser_expects_ = new_size;
 }
 
 void RenderWidget::OnChangeResizeRect(const gfx::Rect& resizer_rect) {
   if (resizer_rect_ != resizer_rect) {
     gfx::Rect view_rect(size_);
 
     gfx::Rect old_damage_rect = gfx::IntersectRects(view_rect, resizer_rect_);
     if (!old_damage_rect.IsEmpty())
       paint_aggregator_.InvalidateRect(old_damage_rect);
 
@@ skipping 49 matching lines @@
 
 void RenderWidget::OnRequestMoveAck() {
   DCHECK(pending_window_rect_count_);
   pending_window_rect_count_--;
 }
 
 void RenderWidget::OnUpdateRectAck() {
   TRACE_EVENT0("renderer", "RenderWidget::OnUpdateRectAck");
   DCHECK(update_reply_pending_);
   update_reply_pending_ = false;
+  size_browser_expects_ = size_;
 
   // If we sent an UpdateRect message with a zero-sized bitmap, then we should
   // have no current paint buffer.
   if (current_paint_buf_) {
     RenderProcess::current()->ReleaseTransportDIB(current_paint_buf_);
     current_paint_buf_ = NULL;
   }
 
   // If swapbuffers is still pending, then defer the update until the
   // swapbuffers occurs.
@@ skipping 1811 matching lines @@
 
   if (!context->Initialize(
           attributes,
           false /* bind generates resources */,
           CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE))
     return NULL;
   return context.release();
 }
 
 }  // namespace content