2 files changed, 43 insertions, 71 deletions

diff --git a/content/renderer/browser_plugin/browser_plugin.cc b/content/renderer/browser_plugin/browser_plugin.cc
index b7d42e0..23537a5 100644
--- a/content/renderer/browser_plugin/browser_plugin.cc
+++ b/content/renderer/browser_plugin/browser_plugin.cc
@@ -76,11 +76,11 @@ BrowserPlugin::BrowserPlugin(
       render_view_routing_id_(render_view->GetRoutingID()),
       container_(NULL),
       damage_buffer_sequence_id_(0),
-      paint_ack_received_(true),
+      resize_ack_received_(true),
       last_device_scale_factor_(1.0f),
       sad_guest_(NULL),
       guest_crashed_(false),
-      is_auto_size_state_dirty_(false),
+      auto_size_ack_pending_(false),
       persist_storage_(false),
       valid_partition_id_(true),
       content_window_routing_id_(MSG_ROUTING_NONE),
@@ -295,45 +295,35 @@ bool BrowserPlugin::ParseSrcAttribute(std::string* error_message) {
 }
 
 void BrowserPlugin::ParseAutoSizeAttribute() {
+  auto_size_ack_pending_ = true;
   last_view_size_ = plugin_rect_.size();
-  is_auto_size_state_dirty_ = true;
   UpdateGuestAutoSizeState(GetAutoSizeAttribute());
 }
 
 void BrowserPlugin::PopulateAutoSizeParameters(
-    BrowserPluginHostMsg_AutoSize_Params* params, bool auto_size_enabled) {
-  params->enable = auto_size_enabled;
+    BrowserPluginHostMsg_AutoSize_Params* params, bool current_auto_size) {
+  params->enable = current_auto_size;
   // No need to populate the params if autosize is off.
-  if (auto_size_enabled) {
+  if (current_auto_size) {
     params->max_size = gfx::Size(GetAdjustedMaxWidth(), GetAdjustedMaxHeight());
     params->min_size = gfx::Size(GetAdjustedMinWidth(), GetAdjustedMinHeight());
-
-    if (max_auto_size_ != params->max_size)
-      is_auto_size_state_dirty_ = true;
-
-    max_auto_size_ = params->max_size;
-  } else {
-    max_auto_size_ = gfx::Size();
   }
 }
 
-void BrowserPlugin::UpdateGuestAutoSizeState(bool auto_size_enabled) {
+void BrowserPlugin::UpdateGuestAutoSizeState(bool current_auto_size) {
   // If we haven't yet heard back from the guest about the last resize request,
   // then we don't issue another request until we do in
   // BrowserPlugin::UpdateRect.
-  if (!HasGuestInstanceID() || !paint_ack_received_)
+  if (!HasGuestInstanceID() || !resize_ack_received_)
     return;
-
   BrowserPluginHostMsg_AutoSize_Params auto_size_params;
   BrowserPluginHostMsg_ResizeGuest_Params resize_guest_params;
-  if (auto_size_enabled) {
-    GetDamageBufferWithSizeParams(&auto_size_params,
-                                  &resize_guest_params,
-                                  true);
+  if (current_auto_size) {
+    GetDamageBufferWithSizeParams(&auto_size_params, &resize_guest_params);
   } else {
-    GetDamageBufferWithSizeParams(NULL, &resize_guest_params, true);
+    GetDamageBufferWithSizeParams(NULL, &resize_guest_params);
   }
-  paint_ack_received_ = false;
+  resize_ack_received_ = false;
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_SetAutoSize(render_view_routing_id_,
                                            guest_instance_id_,
@@ -375,8 +365,7 @@ void BrowserPlugin::Attach(scoped_ptr<base::DictionaryValue> extra_params) {
   attach_params.persist_storage = persist_storage_;
   attach_params.src = GetSrcAttribute();
   GetDamageBufferWithSizeParams(&attach_params.auto_size_params,
-                                &attach_params.resize_guest_params,
-                                false);
+                                &attach_params.resize_guest_params);
 
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_Attach(render_view_routing_id_,
@@ -509,20 +498,19 @@ void BrowserPlugin::OnUpdateRect(
 
   bool auto_size = GetAutoSizeAttribute();
   // We receive a resize ACK in regular mode, but not in autosize.
-  // In SW, |paint_ack_received_| is reset in SwapDamageBuffers().
+  // In SW, |resize_ack_received_| is reset in SwapDamageBuffers().
   // In HW mode, we need to do it here so we can continue sending
   // resize messages when needed.
   if (params.is_resize_ack ||
-      (!params.needs_ack && (auto_size || is_auto_size_state_dirty_))) {
-    paint_ack_received_ = true;
+      (!params.needs_ack && (auto_size || auto_size_ack_pending_))) {
+    resize_ack_received_ = true;
   }
 
-  bool was_auto_size_state_dirty = auto_size && is_auto_size_state_dirty_;
-  is_auto_size_state_dirty_ = false;
+  auto_size_ack_pending_ = false;
 
   if ((!auto_size && (width() != params.view_size.width() ||
                       height() != params.view_size.height())) ||
-      (auto_size && was_auto_size_state_dirty) ||
+      (auto_size && (!InAutoSizeBounds(params.view_size))) ||
       GetDeviceScaleFactor() != params.scale_factor) {
     // We are HW accelerated, render widget does not expect an ack,
     // but we still need to update the size.
@@ -531,7 +519,7 @@ void BrowserPlugin::OnUpdateRect(
       return;
     }
 
-    if (!paint_ack_received_) {
+    if (!resize_ack_received_) {
       // The guest has not yet responded to the last resize request, and
       // so we don't want to do anything at this point other than ACK the guest.
       if (auto_size)
@@ -542,12 +530,9 @@ void BrowserPlugin::OnUpdateRect(
       // container size.
       if (auto_size) {
         GetDamageBufferWithSizeParams(&auto_size_params,
-                                      &resize_guest_params,
-                                      was_auto_size_state_dirty);
+                                      &resize_guest_params);
       } else {
-        GetDamageBufferWithSizeParams(NULL,
-                                      &resize_guest_params,
-                                      was_auto_size_state_dirty);
+        GetDamageBufferWithSizeParams(NULL, &resize_guest_params);
       }
     }
     browser_plugin_manager()->Send(new BrowserPluginHostMsg_UpdateRect_ACK(
@@ -616,10 +601,8 @@ void BrowserPlugin::OnUpdateRect(
 
 void BrowserPlugin::ParseSizeContraintsChanged() {
   bool auto_size = GetAutoSizeAttribute();
-  if (auto_size) {
-    is_auto_size_state_dirty_ = true;
+  if (auto_size)
     UpdateGuestAutoSizeState(true);
-  }
 }
 
 bool BrowserPlugin::InAutoSizeBounds(const gfx::Size& size) const {
@@ -764,11 +747,11 @@ float BrowserPlugin::GetDeviceScaleFactor() const {
 }
 
 void BrowserPlugin::UpdateDeviceScaleFactor(float device_scale_factor) {
-  if (last_device_scale_factor_ == device_scale_factor || !paint_ack_received_)
+  if (last_device_scale_factor_ == device_scale_factor || !resize_ack_received_)
     return;
 
   BrowserPluginHostMsg_ResizeGuest_Params params;
-  PopulateResizeGuestParameters(&params, plugin_rect(), false);
+  PopulateResizeGuestParameters(&params, plugin_rect());
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_ResizeGuest(
       render_view_routing_id_,
       guest_instance_id_,
@@ -877,12 +860,11 @@ void BrowserPlugin::EnableCompositing(bool enable) {
     // We're switching back to the software path. We create a new damage
     // buffer that can accommodate the current size of the container.
     BrowserPluginHostMsg_ResizeGuest_Params params;
+    PopulateResizeGuestParameters(&params, plugin_rect());
     // Request a full repaint from the guest even if its size is not actually
     // changing.
-    PopulateResizeGuestParameters(&params,
-                                  plugin_rect(),
-                                  true /* needs_repaint */);
-    paint_ack_received_ = false;
+    params.repaint = true;
+    resize_ack_received_ = false;
     browser_plugin_manager()->Send(new BrowserPluginHostMsg_ResizeGuest(
         render_view_routing_id_,
         guest_instance_id_,
@@ -1026,12 +1008,12 @@ void BrowserPlugin::updateGeometry(
     return;
 
   // In AutoSize mode, guests don't care when the BrowserPlugin container is
-  // resized. If |!paint_ack_received_|, then we are still waiting on a
+  // resized. If |!resize_ack_received_|, then we are still waiting on a
   // previous resize to be ACK'ed and so we don't issue additional resizes
   // until the previous one is ACK'ed.
   // TODO(mthiesse): Assess the performance of calling GetAutoSizeAttribute() on
   // resize.
-  if (!paint_ack_received_ ||
+  if (!resize_ack_received_ ||
       (old_width == window_rect.width && old_height == window_rect.height) ||
       GetAutoSizeAttribute()) {
     // Let the browser know about the updated view rect.
@@ -1041,8 +1023,8 @@ void BrowserPlugin::updateGeometry(
   }
 
   BrowserPluginHostMsg_ResizeGuest_Params params;
-  PopulateResizeGuestParameters(&params, plugin_rect(), false);
-  paint_ack_received_ = false;
+  PopulateResizeGuestParameters(&params, plugin_rect());
+  resize_ack_received_ = false;
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_ResizeGuest(
       render_view_routing_id_,
       guest_instance_id_,
@@ -1051,16 +1033,14 @@ void BrowserPlugin::updateGeometry(
 
 void BrowserPlugin::SwapDamageBuffers() {
   current_damage_buffer_.reset(pending_damage_buffer_.release());
-  paint_ack_received_ = true;
+  resize_ack_received_ = true;
 }
 
 void BrowserPlugin::PopulateResizeGuestParameters(
     BrowserPluginHostMsg_ResizeGuest_Params* params,
-    const gfx::Rect& view_rect,
-    bool needs_repaint) {
+    const gfx::Rect& view_rect) {
   params->size_changed = true;
   params->view_rect = view_rect;
-  params->repaint = needs_repaint;
   params->scale_factor = GetDeviceScaleFactor();
   if (last_device_scale_factor_ != params->scale_factor){
     params->repaint = true;
@@ -1091,20 +1071,16 @@ void BrowserPlugin::PopulateResizeGuestParameters(
 
 void BrowserPlugin::GetDamageBufferWithSizeParams(
     BrowserPluginHostMsg_AutoSize_Params* auto_size_params,
-    BrowserPluginHostMsg_ResizeGuest_Params* resize_guest_params,
-    bool needs_repaint) {
-  if (auto_size_params) {
+    BrowserPluginHostMsg_ResizeGuest_Params* resize_guest_params) {
+  if (auto_size_params)
     PopulateAutoSizeParameters(auto_size_params, GetAutoSizeAttribute());
-  } else {
-    max_auto_size_ = gfx::Size();
-  }
   gfx::Size view_size = (auto_size_params && auto_size_params->enable) ?
       auto_size_params->max_size : gfx::Size(width(), height());
   if (view_size.IsEmpty())
     return;
-  paint_ack_received_ = false;
+  resize_ack_received_ = false;
   gfx::Rect view_rect = gfx::Rect(plugin_rect_.origin(), view_size);
-  PopulateResizeGuestParameters(resize_guest_params, view_rect, needs_repaint);
+  PopulateResizeGuestParameters(resize_guest_params, view_rect);
 }
 
 #if defined(OS_POSIX)
diff --git a/content/renderer/browser_plugin/browser_plugin.h b/content/renderer/browser_plugin/browser_plugin.h
index ba30ac9..001f2d7 100644
--- a/content/renderer/browser_plugin/browser_plugin.h
+++ b/content/renderer/browser_plugin/browser_plugin.h
@@ -252,22 +252,20 @@ class CONTENT_EXPORT BrowserPlugin :
   // allocates a new |pending_damage_buffer_| if in software rendering mode.
   void PopulateResizeGuestParameters(
       BrowserPluginHostMsg_ResizeGuest_Params* params,
-      const gfx::Rect& view_size,
-      bool needs_repaint);
+      const gfx::Rect& view_size);
 
   // Populates BrowserPluginHostMsg_AutoSize_Params object with autosize state.
   void PopulateAutoSizeParameters(
-      BrowserPluginHostMsg_AutoSize_Params* params, bool auto_size_enabled);
+      BrowserPluginHostMsg_AutoSize_Params* params, bool current_auto_size);
 
   // Populates both AutoSize and ResizeGuest parameters based on the current
   // autosize state.
   void GetDamageBufferWithSizeParams(
       BrowserPluginHostMsg_AutoSize_Params* auto_size_params,
-      BrowserPluginHostMsg_ResizeGuest_Params* resize_guest_params,
-      bool needs_repaint);
+      BrowserPluginHostMsg_ResizeGuest_Params* resize_guest_params);
 
   // Informs the guest of an updated autosize state.
-  void UpdateGuestAutoSizeState(bool auto_size_enabled);
+  void UpdateGuestAutoSizeState(bool current_auto_size);
 
   // Indicates whether a damage buffer was used by the guest process for the
   // provided |params|.
@@ -314,16 +312,14 @@ class CONTENT_EXPORT BrowserPlugin :
   scoped_ptr<base::SharedMemory> current_damage_buffer_;
   scoped_ptr<base::SharedMemory> pending_damage_buffer_;
   uint32 damage_buffer_sequence_id_;
-  bool paint_ack_received_;
+  bool resize_ack_received_;
   gfx::Rect plugin_rect_;
   float last_device_scale_factor_;
   // Bitmap for crashed plugin. Lazily initialized, non-owning pointer.
   SkBitmap* sad_guest_;
   bool guest_crashed_;
   scoped_ptr<BrowserPluginHostMsg_ResizeGuest_Params> pending_resize_params_;
-  bool is_auto_size_state_dirty_;
-  // Maximum size constraint for autosize.
-  gfx::Size max_auto_size_;
+  bool auto_size_ack_pending_;
   std::string storage_partition_id_;
   bool persist_storage_;
   bool valid_partition_id_;