Revert 221023 "Reland after fix: Improve <webview> autosize:"

trunk/src/content/renderer/browser_plugin/browser_plugin.cc

 // Copyright 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/browser_plugin/browser_plugin.h"
 
 #include "base/command_line.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 58 matching lines @@
 BrowserPlugin::BrowserPlugin(
     RenderViewImpl* render_view,
     WebKit::WebFrame* frame,
     const WebPluginParams& params)
     : guest_instance_id_(browser_plugin::kInstanceIDNone),
       attached_(false),
       render_view_(render_view->AsWeakPtr()),
       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),
       plugin_focused_(false),
       visible_(true),
       before_first_navigation_(true),
       mouse_locked_(false),
       browser_plugin_manager_(render_view->GetBrowserPluginManager()),
       compositing_enabled_(false),
       weak_ptr_factory_(this) {
@@ skipping 194 matching lines @@
   }
 
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_NavigateGuest(render_view_routing_id_,
                                              guest_instance_id_,
                                              src));
   return true;
 }
 
 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_,
                                            auto_size_params,
                                            resize_guest_params));
 }
 
 // static
 bool BrowserPlugin::UsesDamageBuffer(
     const BrowserPluginMsg_UpdateRect_Params& params) {
@@ skipping 21 matching lines @@
 
 void BrowserPlugin::Attach(scoped_ptr<base::DictionaryValue> extra_params) {
   BrowserPluginHostMsg_Attach_Params attach_params;
   attach_params.focused = ShouldGuestBeFocused();
   attach_params.visible = visible_;
   attach_params.name = GetNameAttribute();
   attach_params.storage_partition_id = storage_partition_id_;
   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_,
                                       guest_instance_id_, attach_params,
                                       *extra_params));
 }
 
 void BrowserPlugin::DidCommitCompositorFrame() {
   if (compositing_helper_.get())
     compositing_helper_->DidCommitCompositorFrame();
@@ skipping 112 matching lines @@
   // damage buffer then we know the guest will no longer use the current
   // damage buffer. At this point, we drop the current damage buffer, and
   // mark the pending damage buffer as the current damage buffer.
   if (UsesPendingDamageBuffer(params)) {
     SwapDamageBuffers();
     use_new_damage_buffer = true;
   }
 
   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.
     if (!params.needs_ack) {
       UpdateGuestAutoSizeState(auto_size);
       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)
         PopulateAutoSizeParameters(&auto_size_params, auto_size);
     } else {
       // If we have no pending damage buffer, then the guest has not caught up
       // with the BrowserPlugin container. We now tell the guest about the new
       // 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(
         render_view_routing_id_,
         guest_instance_id_,
         true,
         auto_size_params,
         resize_guest_params));
     return;
   }
@@ skipping 48 matching lines @@
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_UpdateRect_ACK(
       render_view_routing_id_,
       guest_instance_id_,
       UsesDamageBuffer(params),
       auto_size_params,
       resize_guest_params));
 }
 
 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 {
   return size.width() <= GetAdjustedMaxWidth() &&
       size.height() <= GetAdjustedMaxHeight();
 }
 
 NPObject* BrowserPlugin::GetContentWindow() const {
   if (content_window_routing_id_ == MSG_ROUTING_NONE)
     return NULL;
@@ skipping 124 matching lines @@
   ParseSrcAttribute(&error);
 }
 
 float BrowserPlugin::GetDeviceScaleFactor() const {
   if (!render_view_.get())
     return 1.0f;
   return render_view_->GetWebView()->deviceScaleFactor();
 }
 
 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_,
       params));
 }
 
 void BrowserPlugin::TriggerEvent(const std::string& event_name,
                                  std::map<std::string, base::Value*>* props) {
   if (!container())
     return;
@@ skipping 88 matching lines @@
       compositing_helper_ =
           new BrowserPluginCompositingHelper(container_,
                                              browser_plugin_manager(),
                                              guest_instance_id_,
                                              render_view_routing_id_);
     }
   } else {
     // 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_,
         params));
   }
   compositing_helper_->EnableCompositing(enable);
 }
 
 void BrowserPlugin::destroy() {
   // If the plugin was initialized then it has a valid |npp_| identifier, and
@@ skipping 123 matching lines @@
     const WebRect& clip_rect,
     const WebVector<WebRect>& cut_outs_rects,
     bool is_visible) {
   int old_width = width();
   int old_height = height();
   plugin_rect_ = window_rect;
   if (!attached())
     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.
     browser_plugin_manager()->Send(new BrowserPluginHostMsg_UpdateGeometry(
         render_view_routing_id_, guest_instance_id_, plugin_rect_));
     return;
   }
 
   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_,
       params));
 }
 
 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;
     last_device_scale_factor_ = params->scale_factor;
   }
 
   // In HW compositing mode, we do not need a damage buffer.
   if (compositing_enabled_)
     return;
 
@@ skipping 10 matching lines @@
   params->damage_buffer_size = size;
   pending_damage_buffer_.reset(
       CreateDamageBuffer(size, &params->damage_buffer_handle));
   if (!pending_damage_buffer_)
     NOTREACHED();
   params->damage_buffer_sequence_id = ++damage_buffer_sequence_id_;
 }
 
 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)
 base::SharedMemory* BrowserPlugin::CreateDamageBuffer(
     const size_t size,
     base::SharedMemoryHandle* damage_buffer_handle) {
   scoped_ptr<base::SharedMemory> shared_buf(
       content::RenderThread::Get()->HostAllocateSharedMemoryBuffer(
           size).release());
 
@@ skipping 185 matching lines @@
     const WebKit::WebMouseEvent& event) {
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_HandleInputEvent(render_view_routing_id_,
                                                 guest_instance_id_,
                                                 plugin_rect_,
                                                 &event));
   return true;
 }
 
 }  // namespace content