Fix issue 11258: Linux: gracefully handle small browser window...

chrome/browser/tab_contents/tab_contents_view_gtk.cc

 // Copyright (c) 2009 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/tab_contents/tab_contents_view_gtk.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkkeysyms.h>
 #include <gtk/gtk.h>
 
 #include "app/gtk_dnd_util.h"
 #include "base/gfx/point.h"
 #include "base/gfx/rect.h"
 #include "base/gfx/size.h"
 #include "base/pickle.h"
 #include "base/string_util.h"
 #include "build/build_config.h"
 #include "chrome/browser/download/download_shelf.h"
 #include "chrome/browser/gtk/blocked_popup_container_view_gtk.h"
 #include "chrome/browser/gtk/browser_window_gtk.h"
 #include "chrome/browser/gtk/constrained_window_gtk.h"
+#include "chrome/browser/gtk/gtk_expanded_container.h"
 #include "chrome/browser/gtk/gtk_floating_container.h"
 #include "chrome/browser/gtk/gtk_theme_provider.h"
 #include "chrome/browser/gtk/sad_tab_gtk.h"
 #include "chrome/browser/gtk/tab_contents_drag_source.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/render_view_host_factory.h"
 #include "chrome/browser/renderer_host/render_widget_host_view_gtk.h"
 #include "chrome/browser/tab_contents/interstitial_page.h"
 #include "chrome/browser/tab_contents/render_view_context_menu_gtk.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
@@ skipping 61 matching lines @@
       return TRUE;
     } else if (event->direction == GDK_SCROLL_UP) {
       tab_contents->delegate()->ContentsZoomChange(true);
       return TRUE;
     }
   }
 
   return FALSE;
 }
 
-// Used with gtk_container_foreach to change the sizes of the children of
-// |fixed_|.
-void SetSizeRequest(GtkWidget* widget, gpointer userdata) {
-  gfx::Size* size = static_cast<gfx::Size*>(userdata);
-  if (widget->allocation.width != size->width() ||
-      widget->allocation.height != size->height()) {
-    gtk_widget_set_size_request(widget, size->width(), size->height());
-  }
-}
-
 }  // namespace
 
 // static
 TabContentsView* TabContentsView::Create(TabContents* tab_contents) {
   return new TabContentsViewGtk(tab_contents);
 }
 
 TabContentsViewGtk::TabContentsViewGtk(TabContents* tab_contents)
     : TabContentsView(tab_contents),
       floating_(gtk_floating_container_new()),
-      fixed_(gtk_fixed_new()),
+      expanded_(gtk_expanded_container_new()),
       popup_view_(NULL) {
-  gtk_widget_set_name(fixed_, "chrome-tab-contents-view");
-  g_signal_connect(fixed_, "size-allocate",
+  gtk_widget_set_name(expanded_, "chrome-tab-contents-view");
+  g_signal_connect(expanded_, "size-allocate",
                    G_CALLBACK(OnSizeAllocate), this);
+  g_signal_connect(expanded_, "child-size-request",
+                   G_CALLBACK(OnChildSizeRequest), this);
   g_signal_connect(floating_.get(), "set-floating-position",
                    G_CALLBACK(OnSetFloatingPosition), this);
 
-  gtk_container_add(GTK_CONTAINER(floating_.get()), fixed_);
-  gtk_widget_show(fixed_);
+  gtk_container_add(GTK_CONTAINER(floating_.get()), expanded_);
+  gtk_widget_show(expanded_);
   gtk_widget_show(floating_.get());
   registrar_.Add(this, NotificationType::TAB_CONTENTS_CONNECTED,
                  Source<TabContents>(tab_contents));
   drag_source_.reset(new TabContentsDragSource(this));
 }
 
 TabContentsViewGtk::~TabContentsViewGtk() {
   floating_.Destroy();
 }
 
@@ skipping 29 matching lines @@
            constrained_window);
   DCHECK(item != constrained_windows_.end());
 
   gtk_container_remove(GTK_CONTAINER(floating_.get()),
                        constrained_window->widget());
   constrained_windows_.erase(item);
 }
 
 void TabContentsViewGtk::CreateView(const gfx::Size& initial_size) {
   requested_size_ = initial_size;
-  gtk_widget_set_size_request(fixed_, requested_size_.width(),
-                              requested_size_.height());
 }
 
 RenderWidgetHostView* TabContentsViewGtk::CreateViewForWidget(
     RenderWidgetHost* render_widget_host) {
   if (render_widget_host->view()) {
     // During testing, the view will already be set up in most cases to the
     // test view, so we don't want to clobber it with a real one. To verify that
     // this actually is happening (and somebody isn't accidentally creating the
     // view twice), we check for the RVH Factory, which will be set when we're
     // making special ones (which go along with the special views).
@@ skipping 40 matching lines @@
   return window ? GTK_WINDOW(window) : NULL;
 }
 
 void TabContentsViewGtk::GetContainerBounds(gfx::Rect* out) const {
   // This is used for positioning the download shelf arrow animation,
   // as well as sizing some other widgets in Windows.  In GTK the size is
   // managed for us, so it appears to be only used for the download shelf
   // animation.
   int x = 0;
   int y = 0;
-  if (fixed_->window)
-    gdk_window_get_origin(fixed_->window, &x, &y);
-  out->SetRect(x + fixed_->allocation.x, y + fixed_->allocation.y,
+  if (expanded_->window)
+    gdk_window_get_origin(expanded_->window, &x, &y);
+  out->SetRect(x + expanded_->allocation.x, y + expanded_->allocation.y,
                requested_size_.width(), requested_size_.height());
 }
 
 void TabContentsViewGtk::SetPageTitle(const std::wstring& title) {
   // Set the window name to include the page title so it's easier to spot
   // when debugging (e.g. via xwininfo -tree).
   gfx::NativeView content_view = GetContentNativeView();
   if (content_view && content_view->window)
     gdk_window_set_title(content_view->window, WideToUTF8(title).c_str());
 }
@@ skipping 96 matching lines @@
                                        WebDragOperationsMask ops) {
   DCHECK(GetContentNativeView());
 
   drag_source_->StartDragging(drop_data, &last_mouse_down_);
   // TODO(snej): Make use of the WebDragOperationsMask somehow
 }
 
 // -----------------------------------------------------------------------------
 
 void TabContentsViewGtk::InsertIntoContentArea(GtkWidget* widget) {
-  gtk_fixed_put(GTK_FIXED(fixed_), widget, 0, 0);
+  gtk_container_add(GTK_CONTAINER(expanded_), widget);
 }
 
 gboolean TabContentsViewGtk::OnMouseDown(GtkWidget* widget,
     GdkEventButton* event, TabContentsViewGtk* view) {
   view->last_mouse_down_ = *event;
   return FALSE;
 }
 
-gboolean TabContentsViewGtk::OnSizeAllocate(GtkWidget* widget,
-                                            GtkAllocation* allocation,
+void TabContentsViewGtk::OnChildSizeRequest(GtkWidget* widget,
+                                            GtkWidget* child,
+                                            GtkRequisition* requisition,
                                             TabContentsViewGtk* view) {
+  if (view->tab_contents()->delegate()) {
+    requisition->height +=
+        view->tab_contents()->delegate()->GetExtraRenderViewHeight();
+  }
+}
+
+void TabContentsViewGtk::OnSizeAllocate(GtkWidget* widget,
+                                        GtkAllocation* allocation,
+                                        TabContentsViewGtk* view) {
   int width = allocation->width;
   int height = allocation->height;
   // |delegate()| can be NULL here during browser teardown.
   if (view->tab_contents()->delegate())
     height += view->tab_contents()->delegate()->GetExtraRenderViewHeight();
   gfx::Size size(width, height);
   view->requested_size_ = size;
-  gtk_container_foreach(GTK_CONTAINER(widget), SetSizeRequest, &size);
 
   // We manually tell our RWHV to resize the renderer content.  This avoids
   // spurious resizes from GTK+.
   if (view->tab_contents()->render_widget_host_view())
     view->tab_contents()->render_widget_host_view()->SetSize(size);
   if (view->tab_contents()->interstitial_page())
     view->tab_contents()->interstitial_page()->SetSize(size);
-
-  return FALSE;
 }
 
 // static
 void TabContentsViewGtk::OnSetFloatingPosition(
     GtkFloatingContainer* floating_container, GtkAllocation* allocation,
     TabContentsViewGtk* tab_contents_view) {
   if (tab_contents_view->popup_view_) {
     GtkWidget* widget = tab_contents_view->popup_view_->widget();
 
     // Look at the size request of the status bubble and tell the
@@ skipping 41 matching lines @@
     gtk_container_child_set_property(GTK_CONTAINER(floating_container),
                                      widget, "x", &value);
 
     int child_y = std::max(half_view_height - (requisition.height / 2), 0);
     g_value_set_int(&value, child_y);
     gtk_container_child_set_property(GTK_CONTAINER(floating_container),
                                      widget, "y", &value);
     g_value_unset(&value);
   }
 }