Revert of Implemented explicit resizing from guestview.

extensions/browser/guest_view/guest_view_base.cc

 // Copyright 2014 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 "extensions/browser/guest_view/guest_view_base.h"
 
 #include "base/lazy_instance.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/ui/zoom/zoom_controller.h"
 #include "content/public/browser/navigation_details.h"
@@ skipping 34 matching lines @@
     GuestViewCreationMap;
 static base::LazyInstance<GuestViewCreationMap> guest_view_registry =
     LAZY_INSTANCE_INITIALIZER;
 
 typedef std::map<WebContents*, GuestViewBase*> WebContentsGuestViewMap;
 static base::LazyInstance<WebContentsGuestViewMap> webcontents_guestview_map =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
-SetSizeParams::SetSizeParams() {}
-SetSizeParams::~SetSizeParams() {}
-
 GuestViewBase::Event::Event(const std::string& name,
                             scoped_ptr<base::DictionaryValue> args)
     : name_(name), args_(args.Pass()) {
 }
 
 GuestViewBase::Event::~Event() {
 }
 
 scoped_ptr<base::DictionaryValue> GuestViewBase::Event::GetArguments() {
   return args_.Pass();
@@ skipping 147 matching lines @@
       AddGuest(guest_instance_id_, guest_web_contents);
 
   // Create a ZoomController to allow the guest's contents to be zoomed.
   ui_zoom::ZoomController::CreateForWebContents(guest_web_contents);
 
   // Populate the view instance ID if we have it on creation.
   create_params.GetInteger(guestview::kParameterInstanceId,
                            &view_instance_id_);
 
   if (CanRunInDetachedState())
-    SetUpSizing(create_params);
+    SetUpAutoSize(create_params);
 
   // Give the derived class an opportunity to perform additional initialization.
   DidInitialize(create_params);
 }
 
-void GuestViewBase::SetSize(const SetSizeParams& params) {
-  bool enable_auto_size =
-      params.enable_auto_size ? *params.enable_auto_size : auto_size_enabled_;
-  gfx::Size min_size = params.min_size ? *params.min_size : min_auto_size_;
-  gfx::Size max_size = params.max_size ? *params.max_size : max_auto_size_;
-
-  if (params.normal_size)
-    normal_size_ = *params.normal_size;
-
+void GuestViewBase::SetAutoSize(bool enabled,
+                                const gfx::Size& min_size,
+                                const gfx::Size& max_size) {
   min_auto_size_ = min_size;
   min_auto_size_.SetToMin(max_size);
   max_auto_size_ = max_size;
   max_auto_size_.SetToMax(min_size);
 
-  enable_auto_size &= !min_auto_size_.IsEmpty() && !max_auto_size_.IsEmpty() &&
-                      IsAutoSizeSupported();
+  enabled &= !min_auto_size_.IsEmpty() && !max_auto_size_.IsEmpty() &&
+      IsAutoSizeSupported();
+  if (!enabled && !auto_size_enabled_)
+    return;
+
+  auto_size_enabled_ = enabled;
+
+  if (!attached() && !CanRunInDetachedState())
+    return;
 
   content::RenderViewHost* rvh = web_contents()->GetRenderViewHost();
-  if (enable_auto_size) {
-    // Autosize is being enabled.
+  if (auto_size_enabled_) {
     rvh->EnableAutoResize(min_auto_size_, max_auto_size_);
-    normal_size_.SetSize(0, 0);
   } else {
-    // Autosize is being disabled.
-    // Use default width/height if missing from partially defined normal size.
-    if (normal_size_.width() && !normal_size_.height())
-      normal_size_.set_height(guestview::kDefaultHeight);
-    if (!normal_size_.width() && normal_size_.height())
-      normal_size_.set_width(guestview::kDefaultWidth);
-
-    gfx::Size new_size = !normal_size_.IsEmpty() ? normal_size_ :
-        !guest_size_.IsEmpty() ? guest_size_ :
-        gfx::Size(guestview::kDefaultWidth, guestview::kDefaultHeight);
-    if (auto_size_enabled_) {
-      // Autosize was previously enabled.
-      rvh->DisableAutoResize(new_size);
-      GuestSizeChangedDueToAutoSize(guest_size_, new_size);
-    } else {
-      // Autosize was already disabled.
-      guest_sizer_->SizeContents(new_size);
-    }
-    // TODO (paulmeyer): Launch the onResize event here.
-    guest_size_ = new_size;
+    rvh->DisableAutoResize(element_size_);
+    guest_size_ = element_size_;
+    GuestSizeChangedDueToAutoSize(guest_size_, element_size_);
   }
-
-  auto_size_enabled_ = enable_auto_size;
 }
 
 // static
 void GuestViewBase::RegisterGuestViewType(
     const std::string& view_type,
     const GuestCreationCallback& callback) {
   GuestViewCreationMap::iterator it =
       guest_view_registry.Get().find(view_type);
   DCHECK(it == guest_view_registry.Get().end());
   guest_view_registry.Get()[view_type] = callback;
@@ skipping 58 matching lines @@
   return false;
 }
 
 bool GuestViewBase::ZoomPropagatesFromEmbedderToGuest() const {
   return true;
 }
 
 void GuestViewBase::DidAttach(int guest_proxy_routing_id) {
   opener_lifetime_observer_.reset();
 
-  SetUpSizing(*attach_params());
+  SetUpAutoSize(*attach_params());
 
   // Give the derived class an opportunity to perform some actions.
   DidAttachToEmbedder();
 
   // Inform the associated GuestViewContainer that the contentWindow is ready.
   embedder_web_contents()->Send(new ExtensionMsg_GuestAttached(
       element_instance_id_,
       guest_proxy_routing_id));
 
   SendQueuedEvents();
 }
 
 void GuestViewBase::DidDetach() {
   GuestViewManager::FromBrowserContext(browser_context_)->DetachGuest(
       this, element_instance_id_);
   StopTrackingEmbedderZoomLevel();
   owner_web_contents()->Send(new ExtensionMsg_GuestDetached(
       element_instance_id_));
   element_instance_id_ = guestview::kInstanceIDNone;
 }
 
 void GuestViewBase::ElementSizeChanged(const gfx::Size& size) {
+  element_size_ = size;
+
   // Only resize if needed.
-  if (size.IsEmpty())
-    return;
-
-  guest_sizer_->SizeContents(size);
+  if (!size.IsEmpty())
+    guest_sizer_->SizeContents(size);
 }
 
 WebContents* GuestViewBase::GetOwnerWebContents() const {
   return owner_web_contents_;
 }
 
 void GuestViewBase::GuestSizeChanged(const gfx::Size& old_size,
                                      const gfx::Size& new_size) {
   if (!auto_size_enabled_)
     return;
@@ skipping 220 matching lines @@
     // The derived class did not create a WebContents so this class serves no
     // purpose. Let's self-destruct.
     delete this;
     callback.Run(NULL);
     return;
   }
   InitWithWebContents(*create_params, guest_web_contents);
   callback.Run(guest_web_contents);
 }
 
-void GuestViewBase::SetUpSizing(const base::DictionaryValue& params) {
+void GuestViewBase::SetUpAutoSize(const base::DictionaryValue& params) {
   // Read the autosize parameters passed in from the embedder.
   bool auto_size_enabled = false;
   params.GetBoolean(guestview::kAttributeAutoSize, &auto_size_enabled);
 
   int max_height = 0;
   int max_width = 0;
   params.GetInteger(guestview::kAttributeMaxHeight, &max_height);
   params.GetInteger(guestview::kAttributeMaxWidth, &max_width);
 
   int min_height = 0;
   int min_width = 0;
   params.GetInteger(guestview::kAttributeMinHeight, &min_height);
   params.GetInteger(guestview::kAttributeMinWidth, &min_width);
 
-  // Set the normal size to the element size so that the guestview will fit the
-  // element initially if autosize is disabled.
-  int normal_height = 0;
-  int normal_width = 0;
-  params.GetInteger(guestview::kElementHeight, &normal_height);
-  params.GetInteger(guestview::kElementWidth, &normal_width);
-
-  SetSizeParams set_size_params;
-  set_size_params.enable_auto_size.reset(new bool(auto_size_enabled));
-  set_size_params.min_size.reset(new gfx::Size(min_width, min_height));
-  set_size_params.max_size.reset(new gfx::Size(max_width, max_height));
-  set_size_params.normal_size.reset(new gfx::Size(normal_width, normal_height));
-
-  // Call SetSize to apply all the appropriate validation and clipping of
+  // Call SetAutoSize to apply all the appropriate validation and clipping of
   // values.
-  SetSize(set_size_params);
+  SetAutoSize(auto_size_enabled,
+              gfx::Size(min_width, min_height),
+              gfx::Size(max_width, max_height));
 }
 
 void GuestViewBase::StartTrackingEmbedderZoomLevel() {
   if (!ZoomPropagatesFromEmbedderToGuest())
     return;
 
   ui_zoom::ZoomController* zoom_controller =
       ui_zoom::ZoomController::FromWebContents(owner_web_contents());
   // Chrome Apps do not have a ZoomController.
   if (!zoom_controller)
@@ skipping 19 matching lines @@
 // static
 void GuestViewBase::RegisterGuestViewTypes() {
   AppViewGuest::Register();
   ExtensionOptionsGuest::Register();
   MimeHandlerViewGuest::Register();
   SurfaceWorkerGuest::Register();
   WebViewGuest::Register();
 }
 
 }  // namespace extensions