Add autoresize capability to chromium.

content/browser/renderer_host/render_widget_host.cc

 // Copyright (c) 2011 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 71 matching lines @@
     : renderer_initialized_(false),
       renderer_accessible_(false),
       view_(NULL),
       process_(process),
       routing_id_(routing_id),
       is_loading_(false),
       is_hidden_(false),
       is_accelerated_compositing_active_(false),
       repaint_ack_pending_(false),
       resize_ack_pending_(false),
+      should_auto_size_(false),
       mouse_move_pending_(false),
       mouse_wheel_pending_(false),
       touch_move_pending_(false),
       touch_event_is_queued_(false),
       needs_repainting_on_restore_(false),
       is_unresponsive_(false),
       in_get_backing_store_(false),
       view_being_painted_(false),
       ignore_input_events_(false),
       text_direction_updated_(false),
@@ skipping 222 matching lines @@
   //
   // TODO: ideally ViewMsg_WasRestored would take a size. This way, the renderer
   // could handle both the restore and resize at once. This isn't that big a
   // deal as RenderWidget::WasRestored delays updating, so that the resize from
   // WasResized is usually processed before the renderer is painted.
   WasResized();
 }
 
 void RenderWidgetHost::WasResized() {
   if (resize_ack_pending_ || !process_->HasConnection() || !view_ ||
-      !renderer_initialized_) {
+      !renderer_initialized_ || should_auto_size_) {
     return;
   }
 
 #if !defined(OS_MACOSX)
   gfx::Size new_size = view_->GetViewBounds().size();
 #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
@@ skipping 497 matching lines @@
 }
 
 bool RenderWidgetHost::IsMouseLocked() const {
   return view_ ? view_->mouse_locked() : false;
 }
 
 bool RenderWidgetHost::IsFullscreen() const {
   return false;
 }
 
+void RenderWidgetHost::setShouldAutoSize(bool enable) {
+  // Note if this switches from true to false then one has to verify that the
+  // mechanics about all the messaging works. For example, what happens to a
+  // update message rect that was in progress from the render widget. Perhaps,
+  // on a transition to false, this should do a WasResized, but what if that
+  // will not trigger a resize message...etc. Due to these complications it is
+  // fitting that this method doesn't look like a simple set method.
+  DCHECK(enable);
+
+  // TODO: Change this to enable instead of true when this supports turning
+  // off autosize.
+  should_auto_size_ = true;
+}
+
 void RenderWidgetHost::Destroy() {
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
       content::Source<RenderWidgetHost>(this),
       content::NotificationService::NoDetails());
 
   // Tell the view to die.
   // Note that in the process of the view shutting down, it can call a ton
   // of other messages on us.  So if you do any other deinitialization here,
   // do it after this call to view_->Destroy().
@@ skipping 103 matching lines @@
   // Update our knowledge of the RenderWidget's size.
   current_size_ = params.view_size;
   // Update our knowledge of the RenderWidget's scroll offset.
   last_scroll_offset_ = params.scroll_offset;
 
   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) {
-    DCHECK(resize_ack_pending_);
-    resize_ack_pending_ = false;
-    in_flight_size_.SetSize(0, 0);
-    in_flight_reserved_rect_.SetRect(0, 0, 0, 0);
+  if (is_resize_ack || should_auto_size_) {
+    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 =
@@ skipping 40 matching lines @@
             base::Bind(&RenderWidgetHost::DidUpdateBackingStore,
                        weak_factory_.GetWeakPtr(), params, paint_start));
       }
     }
   }
 
   if (!was_async) {
     DidUpdateBackingStore(params, paint_start);
   }
 
+  if (should_auto_size_) {
+    OnRenderSizeChanged(params.view_size);
+  }
+
   // Log the time delta for processing a paint message. On platforms that don't
   // support asynchronous painting, this is equivalent to
   // MPArch.RWH_TotalPaintTime.
   TimeDelta delta = TimeTicks::Now() - paint_start;
   UMA_HISTOGRAM_TIMES("MPArch.RWH_OnMsgUpdateRect", delta);
 }
 
 void RenderWidgetHost::DidUpdateBackingStore(
     const ViewHostMsg_UpdateRect_Params& params,
     const TimeTicks& paint_start) {
@@ skipping 437 matching lines @@
 }
 
 // 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));
 }
 #endif