Implemented explicit resizing from guestview.

extensions/browser/guest_view/guest_view_base.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_GUEST_VIEW_GUEST_VIEW_BASE_H_
 #define EXTENSIONS_BROWSER_GUEST_VIEW_GUEST_VIEW_BASE_H_
 
 #include <queue>
 
 #include "base/memory/weak_ptr.h"
 #include "base/values.h"
 #include "components/ui/zoom/zoom_observer.h"
 #include "content/public/browser/browser_plugin_guest_delegate.h"
 #include "content/public/browser/guest_sizer.h"
 #include "content/public/browser/render_process_host_observer.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "extensions/common/guest_view/guest_view_constants.h"
 
 struct RendererContentSettingRules;
 
 namespace extensions {
 
+// A struct of parameters for SetSize(). The parameters are all declared as
+// scoped pointers since they are all optional. Null pointers indicate that the
+// parameter has not been provided, and the last used value should be used. Note
+// that when |enable_auto_size| is true, providing |normal_size| is not
+// meaningful. This is because the normal size of the guestview is overridden
+// whenever autosizing occurs.
+struct SetSizeParams {
+  SetSizeParams();
+  ~SetSizeParams();
+
+  scoped_ptr<bool> enable_auto_size;
+  scoped_ptr<gfx::Size> min_size;
+  scoped_ptr<gfx::Size> max_size;
+  scoped_ptr<gfx::Size> normal_size;
+};
+
 // A GuestViewBase is the base class browser-side API implementation for a
 // <*view> tag. GuestViewBase maintains an association between a guest
 // WebContents and an owner WebContents. It receives events issued from
 // the guest and relays them to the owner. GuestViewBase tracks the lifetime
 // of its owner. A GuestViewBase's owner is referred to as an embedder if
 // it is attached to a container within the owner's WebContents.
 class GuestViewBase : public content::BrowserPluginGuestDelegate,
                       public content::WebContentsDelegate,
                       public content::WebContentsObserver,
                       public ui_zoom::ZoomObserver {
@@ skipping 148 matching lines @@
   void Init(const base::DictionaryValue& create_params,
             const WebContentsCreatedCallback& callback);
 
   void InitWithWebContents(const base::DictionaryValue& create_params,
                            content::WebContents* guest_web_contents);
 
   bool IsViewType(const char* const view_type) const {
     return !strcmp(GetViewType(), view_type);
   }
 
-  // Toggles autosize mode for this GuestView.
-  void SetAutoSize(bool enabled,
-                   const gfx::Size& min_size,
-                   const gfx::Size& max_size);
+  // Used to toggle autosize mode for this GuestView, and set both the automatic
+  // and normal sizes.
+  void SetSize(const SetSizeParams& params);
 
   bool initialized() const { return initialized_; }
 
   content::WebContents* embedder_web_contents() const {
     return attached() ? owner_web_contents_ : NULL;
   }
 
   content::WebContents* owner_web_contents() const {
     return owner_web_contents_;
   }
@@ skipping 77 matching lines @@
   class OwnerLifetimeObserver;
 
   class OpenerLifetimeObserver;
 
   void SendQueuedEvents();
 
   void CompleteInit(scoped_ptr<base::DictionaryValue> create_params,
                     const WebContentsCreatedCallback& callback,
                     content::WebContents* guest_web_contents);
 
-  void SetUpAutoSize(const base::DictionaryValue& params);
+  void SetUpSizing(const base::DictionaryValue& params);
 
   void StartTrackingEmbedderZoomLevel();
   void StopTrackingEmbedderZoomLevel();
 
   static void RegisterGuestViewTypes();
 
   // WebContentsObserver implementation.
   void DidStopLoading(content::RenderViewHost* render_view_host) final;
   void RenderViewReady() final;
   void WebContentsDestroyed() final;
@@ skipping 51 matching lines @@
   scoped_ptr<base::DictionaryValue> attach_params_;
 
   // This observer ensures that this guest self-destructs if the embedder goes
   // away.
   scoped_ptr<OwnerLifetimeObserver> owner_lifetime_observer_;
 
   // This observer ensures that if the guest is unattached and its opener goes
   // away then this guest also self-destructs.
   scoped_ptr<OpenerLifetimeObserver> opener_lifetime_observer_;
 
-  // The size of the container element.
-  gfx::Size element_size_;
-
   // The size of the guest content. Note: In autosize mode, the container
   // element may not match the size of the guest.
   gfx::Size guest_size_;
 
   // A pointer to the guest_sizer.
   content::GuestSizer* guest_sizer_;
 
   // Indicates whether autosize mode is enabled or not.
   bool auto_size_enabled_;
 
   // The maximum size constraints of the container element in autosize mode.
   gfx::Size max_auto_size_;
 
   // The minimum size constraints of the container element in autosize mode.
   gfx::Size min_auto_size_;
 
+  // The size that will be used when autosize mode is disabled.
+  gfx::Size normal_size_;
+
   // Whether the guest view is inside a plugin document.
   bool is_full_page_plugin_;
 
   // This is used to ensure pending tasks will not fire after this object is
   // destroyed.
   base::WeakPtrFactory<GuestViewBase> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GuestViewBase);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_GUEST_VIEW_GUEST_VIEW_BASE_H_