Addition of 'maxSize' to experimental popup extension API.

chrome/browser/extensions/extension_popup_api.cc

 // Copyright (c) 2010 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 "chrome/browser/extensions/extension_popup_api.h"
 
 #include "base/json/json_writer.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
@@ skipping 39 matching lines @@
     "Popups are only supported from tab-contents views.";
 
 // Keys.
 const char kWidthKey[] = "width";
 const char kHeightKey[] = "height";
 const char kTopKey[] = "top";
 const char kLeftKey[] = "left";
 const char kGiveFocusKey[] = "giveFocus";
 const char kDomAnchorKey[] = "domAnchor";
 const char kBorderStyleKey[] = "borderStyle";
+const char kMaxSizeKey[] = "maxSize";
 
 // chrome enumeration values
 const char kRectangleChrome[] = "rectangle";
 
 #if defined(TOOLKIT_VIEWS)
 // Returns an updated arrow location, conditioned on the type of intersection
 // between the popup window, and the screen.  |location| is the current position
 // of the arrow on the popup.  |intersection| is the rect representing the
 // intersection between the popup view and its working screen.  |popup_rect|
 // is the rect of the popup window in screen space coordinates.
@@ skipping 30 matching lines @@
 // and browser action, it also manages its own focus change listening. The
 // difference in close-on-focus-lost is that in the page action and browser
 // action cases, the popup closes when the focus leaves the popup or any of its
 // children. In this case, the popup closes when the focus leaves the popups
 // containing view or any of *its* children.
 class ExtensionPopupHost : public ExtensionPopup::Observer,
                            public views::WidgetFocusChangeListener,
                            public base::RefCounted<ExtensionPopupHost>,
                            public NotificationObserver {
  public:
-  explicit ExtensionPopupHost(ExtensionFunctionDispatcher* dispatcher)
-      : dispatcher_(dispatcher), popup_(NULL) {
+  // Pass |max_popup_size| to specify the maximal size to which the popup
+  // will expand.  A width or height of 0 will result in the popup making use
+  // of the default max width or height, respectively: ExtensionPopup:kMaxWidth,
+  // and ExtensionPopup::kMaxHeight.
+  explicit ExtensionPopupHost(ExtensionFunctionDispatcher* dispatcher,
+                              const gfx::Size& max_popup_size)
+      : dispatcher_(dispatcher), popup_(NULL), max_popup_size_(max_popup_size) {
     AddRef();  // Balanced in DispatchPopupClosedEvent().
     views::FocusManager::GetWidgetFocusManager()->AddFocusChangeListener(this);
   }
 
   ~ExtensionPopupHost() {
     views::FocusManager::GetWidgetFocusManager()->
         RemoveFocusChangeListener(this);
   }
 
   void set_popup(ExtensionPopup* popup) {
@@ skipping 48 matching lines @@
     // Extension hosts created for popup contents exist in the same tab
     // contents as the ExtensionFunctionDispatcher that requested the popup.
     // For example, '_blank' link navigation should be routed through the tab
     // contents that requested the popup.
     if (dispatcher_ && dispatcher_->delegate()) {
       host->set_associated_tab_contents(
           dispatcher_->delegate()->associated_tab_contents());
     }
   }
 
+  virtual void ExtensionPopupCreated(ExtensionPopup* popup) {
+    // The popup has been created, but not yet displayed, so install the max
+    // size overrides before the first positioning.
+    if (max_popup_size_.width())
+      popup->set_max_width(max_popup_size_.width());
+
+    if (max_popup_size_.height())
+      popup->set_max_height(max_popup_size_.height());
+  }
+
   virtual void ExtensionPopupResized(ExtensionPopup* popup) {
     // Reposition the location of the arrow on the popup so that the popup
     // better fits on the working monitor.
     gfx::Rect popup_rect = popup->GetOuterBounds();
     if (popup_rect.IsEmpty())
       return;
 
     scoped_ptr<WindowSizer::MonitorInfoProvider> monitor_provider(
         WindowSizer::CreateDefaultMonitorInfoProvider());
     gfx::Rect monitor_bounds(
@@ skipping 19 matching lines @@
       // situation - the popup will be contained entirely in its working monitor
       // bounds.
       gfx::Rect flipped_bounds = popup->GetOuterBounds();
       gfx::Rect updated_monitor_bounds =
           monitor_provider->GetMonitorWorkAreaMatching(flipped_bounds);
       if (!updated_monitor_bounds.Contains(flipped_bounds))
         popup->SetArrowPosition(previous_location);
     }
   }
 
-  virtual void DispatchPopupClosedEvent() {
-    if (dispatcher_) {
-      PopupEventRouter::OnPopupClosed(
-          dispatcher_->profile(),
-          dispatcher_->render_view_host()->routing_id());
-      dispatcher_ = NULL;
-    }
-    Release();  // Balanced in ctor.
-  }
-
   // Overridden from views::WidgetFocusChangeListener
   virtual void NativeFocusWillChange(gfx::NativeView focused_before,
                                      gfx::NativeView focused_now) {
     // If the popup doesn't exist, then do nothing.
     if (!popup_)
       return;
 
     // If no view is to be focused, then Chrome was deactivated, so hide the
     // popup.
     if (focused_now) {
@@ skipping 77 matching lines @@
     if (!dispatcher)
       return NULL;
 
     RenderViewHost* render_view_host = dispatcher->render_view_host();
     RenderViewHostDelegate* delegate =
         render_view_host ? render_view_host->delegate() : NULL;
 
     return delegate ? delegate->GetAutomationResourceRoutingDelegate() : NULL;
   }
 
+  void DispatchPopupClosedEvent() {
+    if (dispatcher_) {
+      PopupEventRouter::OnPopupClosed(
+          dispatcher_->profile(),
+          dispatcher_->render_view_host()->routing_id());
+      dispatcher_ = NULL;
+    }
+    Release();  // Balanced in ctor.
+  }
+
   // A pointer to the dispatcher that handled the request that opened this
   // popup view.
   ExtensionFunctionDispatcher* dispatcher_;
 
   // A pointer to the popup.
   ExtensionPopup* popup_;
 
+  // The maximal size to which the popup is permitted to expand.
+  gfx::Size max_popup_size_;
+
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPopupHost);
 };
 #endif  // TOOLKIT_VIEWS
 
 PopupShowFunction::PopupShowFunction()
 #if defined (TOOLKIT_VIEWS)
     : popup_(NULL)
 #endif
@@ skipping 56 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(dom_top >= 0 && dom_left >= 0 &&
                               dom_width >= 0 && dom_height >= 0);
 
   // The default behaviour is to give the focus to the pop-up window.
   bool give_focus = true;
   if (show_details->HasKey(kGiveFocusKey)) {
     EXTENSION_FUNCTION_VALIDATE(show_details->GetBoolean(kGiveFocusKey,
                                                          &give_focus));
   }
 
+  int max_width = 0;
+  int max_height = 0;
+  if (show_details->HasKey(kMaxSizeKey)) {
+    DictionaryValue* max_size = NULL;
+    EXTENSION_FUNCTION_VALIDATE(show_details->GetDictionary(kMaxSizeKey,
+                                                            &max_size));
+
+    if (max_size->HasKey(kWidthKey))
+      EXTENSION_FUNCTION_VALIDATE(max_size->GetInteger(kWidthKey, &max_width));
+
+    if (max_size->HasKey(kHeightKey))
+      EXTENSION_FUNCTION_VALIDATE(max_size->GetInteger(kHeightKey,
+                                                       &max_height));
+  }
+
 #if defined(TOOLKIT_VIEWS)
   // The default behaviour is to provide the bubble-chrome to the popup.
   ExtensionPopup::PopupChrome chrome = ExtensionPopup::BUBBLE_CHROME;
   if (show_details->HasKey(kBorderStyleKey)) {
     std::string chrome_string;
     EXTENSION_FUNCTION_VALIDATE(show_details->GetString(kBorderStyleKey,
                                                         &chrome_string));
     if (chrome_string == kRectangleChrome)
       chrome = ExtensionPopup::RECTANGLE_CHROME;
   }
@@ skipping 30 matching lines @@
   // of this.
   gfx::NativeWindow window =
       dispatcher()->delegate()->GetCustomFrameNativeWindow();
   if (!window)
     window = GetCurrentBrowser()->window()->GetNativeHandle();
 
 #if defined(TOOLKIT_VIEWS)
   BubbleBorder::ArrowLocation arrow_location = BubbleBorder::TOP_LEFT;
 
   // ExtensionPopupHost manages it's own lifetime.
-  ExtensionPopupHost* popup_host = new ExtensionPopupHost(dispatcher());
+  ExtensionPopupHost* popup_host =
+      new ExtensionPopupHost(dispatcher(), gfx::Size(max_width, max_height));
   popup_ = ExtensionPopup::Show(url,
                                 GetCurrentBrowser(),
                                 dispatcher()->profile(),
                                 window,
                                 rect,
                                 arrow_location,
                                 give_focus,
                                 false,  // inspect_with_devtools
                                 chrome,
                                 popup_host);  // ExtensionPopup::Observer
@@ skipping 34 matching lines @@
 // static
 void PopupEventRouter::OnPopupClosed(Profile* profile,
                                      int routing_id) {
   std::string full_event_name = base::StringPrintf(
       extension_popup_module_events::kOnPopupClosed,
       routing_id);
 
   profile->GetExtensionEventRouter()->DispatchEventToRenderers(
       full_event_name, base::JSONWriter::kEmptyArray, profile, GURL());
 }