Change grow box computation back to a method on BrowserWindow

content/browser/renderer_host/render_widget_host.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/browser/renderer_host/render_widget_host.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 329 matching lines @@
   WasResized();
 }
 
 void RenderWidgetHost::WasResized() {
   if (resize_ack_pending_ || !process_->HasConnection() || !view_ ||
       !renderer_initialized_ || should_auto_resize_) {
     return;
   }
 
 #if !defined(OS_MACOSX)
-  gfx::Size new_size = view_->GetViewBounds().size();
+  gfx::Rect view_bounds = view_->GetViewBounds();
 #else
   // When UI scaling is enabled on OS X, allocate a smaller bitmap and
   // pixel-scale it up.
   // TODO(thakis): Use pixel size on mac and set UI scale in renderer.
   // http://crbug.com/31960
-  gfx::Size new_size(view_->GetViewCocoaBounds().size());
+  gfx::Rect view_bounds(view_->GetViewCocoaBounds().size());
 #endif
-  gfx::Rect reserved_rect = view_->reserved_contents_rect();
+  gfx::Size new_size(view_bounds.size());
 
   // Avoid asking the RenderWidget to resize to its current size, since it
-  // won't send us a PaintRect message in that case, unless reserved area is
-  // changed, but even in this case PaintRect message won't be sent.
-  if (new_size == current_size_ && reserved_rect == current_reserved_rect_)
+  // won't send us a PaintRect message in that case.
+  if (new_size == current_size_)
     return;
 
-  if (in_flight_size_ != gfx::Size() && new_size == in_flight_size_ &&
-      in_flight_reserved_rect_ == reserved_rect) {
+  if (in_flight_size_ != gfx::Size() && new_size == in_flight_size_) {
     return;
   }
 
-  // We don't expect to receive an ACK when the requested size is empty or
-  // only reserved area is changed.
-  resize_ack_pending_ = !new_size.IsEmpty() && new_size != current_size_;
+  // We don't expect to receive an ACK when the requested size is empty.
+  if (!new_size.IsEmpty())
+    resize_ack_pending_ = true;
 
-  if (!Send(new ViewMsg_Resize(routing_id_, new_size, reserved_rect,
-                               IsFullscreen()))) {
+  if (!Send(new ViewMsg_Resize(routing_id_, new_size,
+          GetRootWindowResizerRect(), IsFullscreen()))) {
     resize_ack_pending_ = false;
   } else {
-    if (resize_ack_pending_) {
-      in_flight_size_ = new_size;
-      in_flight_reserved_rect_ = reserved_rect;
-    } else {
-      // Message was sent successfully, but we do not expect to receive an ACK,
-      // so update current values right away.
-      current_size_ = new_size;
-      // TODO(alekseys): send a message from renderer to ack a reserved rect
-      // changes only.
-      current_reserved_rect_ = reserved_rect;
-    }
+    in_flight_size_ = new_size;
   }
 }
 
 void RenderWidgetHost::GotFocus() {
   Focus();
 }
 
 void RenderWidgetHost::Focus() {
   Send(new ViewMsg_SetFocus(routing_id_, true));
 }
@@ skipping 371 matching lines @@
 
   // Must reset these to ensure that keyboard events work with a new renderer.
   key_queue_.clear();
   suppress_next_char_events_ = false;
 
   // Reset some fields in preparation for recovering from a crash.
   resize_ack_pending_ = false;
   repaint_ack_pending_ = false;
 
   in_flight_size_.SetSize(0, 0);
-  in_flight_reserved_rect_.SetRect(0, 0, 0, 0);
   current_size_.SetSize(0, 0);
-  current_reserved_rect_.SetRect(0, 0, 0, 0);
   is_hidden_ = false;
   is_accelerated_compositing_active_ = false;
 
   if (view_) {
     view_->RenderViewGone(status, exit_code);
     view_ = NULL;  // The View should be deleted by RenderViewGone.
   }
 
   BackingStoreManager::RemoveBackingStore(this);
 }
@@ skipping 42 matching lines @@
 
 void RenderWidgetHost::ImeConfirmComposition() {
   ImeConfirmComposition(string16());
 }
 
 void RenderWidgetHost::ImeCancelComposition() {
   Send(new ViewMsg_ImeSetComposition(routing_id(), string16(),
             std::vector<WebKit::WebCompositionUnderline>(), 0, 0));
 }
 
+gfx::Rect RenderWidgetHost::GetRootWindowResizerRect() const {
+  return gfx::Rect();
+}
+
 void RenderWidgetHost::RequestToLockMouse() {
   // Directly reject to lock the mouse. Subclass can override this method to
   // decide whether to allow mouse lock or not.
   GotResponseToLockMouseRequest(false);
 }
 
 void RenderWidgetHost::RejectMouseLockOrUnlockIfNecessary() {
   DCHECK(!pending_mouse_lock_request_ || !IsMouseLocked());
   if (pending_mouse_lock_request_) {
     pending_mouse_lock_request_ = false;
@@ skipping 146 matching lines @@
   bool is_resize_ack =
       ViewHostMsg_UpdateRect_Flags::is_resize_ack(params.flags);
 
   // resize_ack_pending_ needs to be cleared before we call DidPaintRect, since
   // that will end up reaching GetBackingStore.
   if (is_resize_ack || should_auto_resize_) {
     if (is_resize_ack) {
       DCHECK(resize_ack_pending_);
       resize_ack_pending_ = false;
       in_flight_size_.SetSize(0, 0);
-      in_flight_reserved_rect_.SetRect(0, 0, 0, 0);
     }
-    // Update our knowledge of the RenderWidget's resizer rect.
-    // ViewMsg_Resize is acknowledged only when view size is actually changed,
-    // otherwise current_reserved_rect_ is updated immediately after sending
-    // ViewMsg_Resize to the RenderWidget and can be clobbered by
-    // OnMsgUpdateRect called for a paint that was initiated before the resize
-    // message was sent.
-    current_reserved_rect_ = params.resizer_rect;
   }
 
   bool is_repaint_ack =
       ViewHostMsg_UpdateRect_Flags::is_repaint_ack(params.flags);
   if (is_repaint_ack) {
     repaint_ack_pending_ = false;
     TimeDelta delta = TimeTicks::Now() - repaint_start_time_;
     UMA_HISTOGRAM_TIMES("MPArch.RWH_RepaintDelta", delta);
   }
 
@@ skipping 99 matching lines @@
 
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_HOST_DID_PAINT,
       content::Source<RenderWidgetHost>(this),
       content::NotificationService::NoDetails());
 
   // If we got a resize ack, then perhaps we have another resize to send?
   bool is_resize_ack =
       ViewHostMsg_UpdateRect_Flags::is_resize_ack(params.flags);
   if (is_resize_ack && view_) {
-    // WasResized checks the current size and sends the resize update only
-    // when something was actually changed.
-    WasResized();
+    gfx::Rect view_bounds = view_->GetViewBounds();
+    if (current_size_ != view_bounds.size())
+      WasResized();
   }
 
   // Log the time delta for processing a paint message.
   TimeTicks now = TimeTicks::Now();
   TimeDelta delta = now - update_start;
   UMA_HISTOGRAM_TIMES("MPArch.RWH_DidUpdateBackingStore", delta);
 
   // Measures the time from receiving the MsgUpdateRect IPC to completing the
   // DidUpdateBackingStore() method.  On platforms which have asynchronous
   // painting, such as Linux, this is the sum of MPArch.RWH_OnMsgUpdateRect,
@@ skipping 397 matching lines @@
     ui_shim->Send(new AcceleratedSurfaceMsg_BuffersSwappedACK(route_id));
 }
 
 // static
 void RenderWidgetHost::AcknowledgePostSubBuffer(int32 route_id,
                                                 int gpu_host_id) {
   GpuProcessHostUIShim* ui_shim = GpuProcessHostUIShim::FromID(gpu_host_id);
   if (ui_shim)
     ui_shim->Send(new AcceleratedSurfaceMsg_PostSubBufferACK(route_id));
 }