Revert 287732 "<webview>: Move autosize from content to chrome."

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/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 36 matching lines @@
                              bool auto_navigate)
     : guest_instance_id_(browser_plugin::kInstanceIDNone),
       attached_(false),
       render_view_(render_view->AsWeakPtr()),
       render_view_routing_id_(render_view->GetRoutingID()),
       container_(NULL),
       paint_ack_received_(true),
       last_device_scale_factor_(GetDeviceScaleFactor()),
       sad_guest_(NULL),
       guest_crashed_(false),
+      is_auto_size_state_dirty_(false),
       content_window_routing_id_(MSG_ROUTING_NONE),
       plugin_focused_(false),
       visible_(true),
       auto_navigate_(auto_navigate),
       mouse_locked_(false),
       browser_plugin_manager_(render_view->GetBrowserPluginManager()),
       weak_ptr_factory_(this) {
 }
 
 BrowserPlugin::~BrowserPlugin() {
@@ skipping 69 matching lines @@
     return false;
 
   return container()->element().hasAttribute(
       blink::WebString::fromUTF8(attribute_name));
 }
 
 bool BrowserPlugin::GetAllowTransparencyAttribute() const {
   return HasDOMAttribute(browser_plugin::kAttributeAllowTransparency);
 }
 
+bool BrowserPlugin::GetAutoSizeAttribute() const {
+  return HasDOMAttribute(browser_plugin::kAttributeAutoSize);
+}
+
+int BrowserPlugin::GetMaxHeightAttribute() const {
+  int max_height;
+  base::StringToInt(GetDOMAttributeValue(browser_plugin::kAttributeMaxHeight),
+                    &max_height);
+  return max_height;
+}
+
+int BrowserPlugin::GetMaxWidthAttribute() const {
+  int max_width;
+  base::StringToInt(GetDOMAttributeValue(browser_plugin::kAttributeMaxWidth),
+                    &max_width);
+  return max_width;
+}
+
+int BrowserPlugin::GetMinHeightAttribute() const {
+  int min_height;
+  base::StringToInt(GetDOMAttributeValue(browser_plugin::kAttributeMinHeight),
+                    &min_height);
+  return min_height;
+}
+
+int BrowserPlugin::GetMinWidthAttribute() const {
+  int min_width;
+  base::StringToInt(GetDOMAttributeValue(browser_plugin::kAttributeMinWidth),
+                    &min_width);
+  return min_width;
+}
+
+int BrowserPlugin::GetAdjustedMaxHeight() const {
+  int max_height = GetMaxHeightAttribute();
+  return max_height ? max_height : height();
+}
+
+int BrowserPlugin::GetAdjustedMaxWidth() const {
+  int max_width = GetMaxWidthAttribute();
+  return max_width ? max_width : width();
+}
+
+int BrowserPlugin::GetAdjustedMinHeight() const {
+  int min_height = GetMinHeightAttribute();
+  // FrameView.cpp does not allow this value to be <= 0, so when the value is
+  // unset (or set to 0), we set it to the container size.
+  min_height = min_height ? min_height : height();
+  // For autosize, minHeight should not be bigger than maxHeight.
+  return std::min(min_height, GetAdjustedMaxHeight());
+}
+
+int BrowserPlugin::GetAdjustedMinWidth() const {
+  int min_width = GetMinWidthAttribute();
+  // FrameView.cpp does not allow this value to be <= 0, so when the value is
+  // unset (or set to 0), we set it to the container size.
+  min_width = min_width ? min_width : width();
+  // For autosize, minWidth should not be bigger than maxWidth.
+  return std::min(min_width, GetAdjustedMaxWidth());
+}
+
 void BrowserPlugin::ParseAllowTransparencyAttribute() {
   if (!HasGuestInstanceID())
     return;
 
   bool opaque = !GetAllowTransparencyAttribute();
 
   if (compositing_helper_)
     compositing_helper_->SetContentsOpaque(opaque);
 
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_SetContentsOpaque(
         render_view_routing_id_,
         guest_instance_id_,
         opaque));
 }
 
+void BrowserPlugin::ParseAutoSizeAttribute() {
+  last_view_size_ = plugin_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;
+  // No need to populate the params if autosize is off.
+  if (auto_size_enabled) {
+    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) {
+  // 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::OnUpdateRect.
+  if (!HasGuestInstanceID() || !paint_ack_received_)
+    return;
+
+  BrowserPluginHostMsg_AutoSize_Params auto_size_params;
+  BrowserPluginHostMsg_ResizeGuest_Params resize_guest_params;
+  if (auto_size_enabled) {
+    GetSizeParams(&auto_size_params, &resize_guest_params, true);
+  } else {
+    GetSizeParams(NULL, &resize_guest_params, true);
+  }
+  paint_ack_received_ = false;
+  browser_plugin_manager()->Send(
+      new BrowserPluginHostMsg_SetAutoSize(render_view_routing_id_,
+                                           guest_instance_id_,
+                                           auto_size_params,
+                                           resize_guest_params));
+}
+
 void BrowserPlugin::Attach(int guest_instance_id,
                            scoped_ptr<base::DictionaryValue> extra_params) {
   CHECK(guest_instance_id != browser_plugin::kInstanceIDNone);
 
   // If this BrowserPlugin is already attached to a guest, then kill the guest.
   if (HasGuestInstanceID()) {
     if (guest_instance_id == guest_instance_id_)
       return;
     guest_crashed_ = false;
     EnableCompositing(false);
     if (compositing_helper_) {
       compositing_helper_->OnContainerDestroy();
       compositing_helper_ = NULL;
     }
     browser_plugin_manager()->RemoveBrowserPlugin(guest_instance_id_);
     browser_plugin_manager()->Send(new BrowserPluginHostMsg_PluginDestroyed(
         render_view_routing_id_, guest_instance_id_));
   }
 
   // This API may be called directly without setting the src attribute.
   // In that case, we need to make sure we don't allocate another instance ID.
   guest_instance_id_ = guest_instance_id;
   browser_plugin_manager()->AddBrowserPlugin(guest_instance_id, this);
 
   BrowserPluginHostMsg_Attach_Params attach_params;
   attach_params.focused = ShouldGuestBeFocused();
   attach_params.visible = visible_;
   attach_params.opaque = !GetAllowTransparencyAttribute();
   attach_params.origin = plugin_rect().origin();
-  GetSizeParams(&attach_params.resize_guest_params, false);
+  GetSizeParams(&attach_params.auto_size_params,
+                &attach_params.resize_guest_params,
+                false);
 
   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 104 matching lines @@
   }
 }
 
 void BrowserPlugin::OnUpdateRect(
     int guest_instance_id,
     const BrowserPluginMsg_UpdateRect_Params& params) {
   // Note that there is no need to send ACK for this message.
   // If the guest has updated pixels then it is no longer crashed.
   guest_crashed_ = false;
 
+  bool auto_size = GetAutoSizeAttribute();
   // We receive a resize ACK in regular mode, but not in autosize.
   // In Compositing mode, we need to do it here so we can continue sending
   // resize messages when needed.
-  if (params.is_resize_ack)
+  if (params.is_resize_ack || (auto_size || is_auto_size_state_dirty_))
     paint_ack_received_ = true;
 
-  if (params.view_size.width() == width() &&
-      params.view_size.height() == height()) {
+  bool was_auto_size_state_dirty = auto_size && is_auto_size_state_dirty_;
+  is_auto_size_state_dirty_ = false;
+
+  if ((!auto_size && (width() != params.view_size.width() ||
+                      height() != params.view_size.height())) ||
+      (auto_size && was_auto_size_state_dirty) ||
+      GetDeviceScaleFactor() != params.scale_factor) {
+    UpdateGuestAutoSizeState(auto_size);
     return;
   }
 
-  BrowserPluginHostMsg_ResizeGuest_Params resize_params;
-  PopulateResizeGuestParameters(&resize_params, plugin_size(), false);
-  paint_ack_received_ = false;
-  browser_plugin_manager()->Send(new BrowserPluginHostMsg_ResizeGuest(
-      render_view_routing_id_,
-      guest_instance_id_,
-      resize_params));
+  if (auto_size && (params.view_size != last_view_size_))
+    last_view_size_ = params.view_size;
+
+  BrowserPluginHostMsg_AutoSize_Params auto_size_params;
+  BrowserPluginHostMsg_ResizeGuest_Params resize_guest_params;
+
+  // BrowserPluginHostMsg_UpdateRect_ACK is used by both the compositing and
+  // software paths to piggyback updated autosize parameters.
+  if (auto_size)
+    PopulateAutoSizeParameters(&auto_size_params, auto_size);
+
+  browser_plugin_manager()->Send(
+      new BrowserPluginHostMsg_SetAutoSize(render_view_routing_id_,
+                                           guest_instance_id_,
+                                           auto_size_params,
+                                           resize_guest_params));
+}
+
+void BrowserPlugin::ParseSizeContraintsChanged() {
+  bool auto_size = GetAutoSizeAttribute();
+  if (auto_size) {
+    is_auto_size_state_dirty_ = true;
+    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;
   RenderViewImpl* guest_render_view = RenderViewImpl::FromRoutingID(
       content_window_routing_id_);
   if (!guest_render_view)
     return NULL;
   blink::WebFrame* guest_frame = guest_render_view->GetWebView()->mainFrame();
@@ skipping 197 matching lines @@
   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
   // 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_ ||
-      (old_width == window_rect.width && old_height == window_rect.height)) {
+      (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_size(), false);
   paint_ack_received_ = false;
   browser_plugin_manager()->Send(new BrowserPluginHostMsg_ResizeGuest(
       render_view_routing_id_,
       guest_instance_id_,
       params));
 }
 
 void BrowserPlugin::PopulateResizeGuestParameters(
     BrowserPluginHostMsg_ResizeGuest_Params* params,
     const gfx::Size& view_size,
     bool needs_repaint) {
   params->size_changed = true;
   params->view_size = view_size;
   params->repaint = needs_repaint;
   params->scale_factor = GetDeviceScaleFactor();
-  if (last_device_scale_factor_ != params->scale_factor) {
+  if (last_device_scale_factor_ != params->scale_factor){
     DCHECK(params->repaint);
     last_device_scale_factor_ = params->scale_factor;
   }
 }
 
 void BrowserPlugin::GetSizeParams(
+    BrowserPluginHostMsg_AutoSize_Params* auto_size_params,
     BrowserPluginHostMsg_ResizeGuest_Params* resize_guest_params,
     bool needs_repaint) {
-  gfx::Size view_size(width(), height());
+  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;
   PopulateResizeGuestParameters(resize_guest_params, view_size, needs_repaint);
 }
 
 void BrowserPlugin::updateFocus(bool focused) {
   plugin_focused_ = focused;
   UpdateGuestFocusState();
 }
@@ skipping 222 matching lines @@
     const blink::WebMouseEvent& event) {
   browser_plugin_manager()->Send(
       new BrowserPluginHostMsg_HandleInputEvent(render_view_routing_id_,
                                                 guest_instance_id_,
                                                 plugin_rect_,
                                                 &event));
   return true;
 }
 
 }  // namespace content