Enforce that only one constrained window is displayed at once per tab.

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>
 
@@ skipping 101 matching lines @@
 
 // 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()),
-      popup_view_(NULL) {
+      popup_view_(NULL),
+      constrained_window_(NULL) {
   gtk_widget_set_name(fixed_, "chrome-tab-contents-view");
   g_signal_connect(fixed_, "size-allocate",
                    G_CALLBACK(OnSizeAllocate), 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_widget_show(floating_.get());
   registrar_.Add(this, NotificationType::TAB_CONTENTS_CONNECTED,
@@ skipping 15 matching lines @@
 
 void TabContentsViewGtk::RemoveBlockedPopupView(
     BlockedPopupContainerViewGtk* popup_view) {
   DCHECK(popup_view_ == popup_view);
   gtk_container_remove(GTK_CONTAINER(floating_.get()), popup_view->widget());
   popup_view_ = NULL;
 }
 
 void TabContentsViewGtk::AttachConstrainedWindow(
     ConstrainedWindowGtk* constrained_window) {
-  DCHECK(find(constrained_windows_.begin(), constrained_windows_.end(),
-              constrained_window) == constrained_windows_.end());
+  DCHECK(constrained_window_ == NULL);
 
-  constrained_windows_.push_back(constrained_window);
+  constrained_window_ = constrained_window;
   gtk_floating_container_add_floating(GTK_FLOATING_CONTAINER(floating_.get()),
                                       constrained_window->widget());
 }
 
 void TabContentsViewGtk::RemoveConstrainedWindow(
     ConstrainedWindowGtk* constrained_window) {
-  std::vector<ConstrainedWindowGtk*>::iterator item =
-      find(constrained_windows_.begin(), constrained_windows_.end(),
-           constrained_window);
-  DCHECK(item != constrained_windows_.end());
+  DCHECK(constrained_window == constrained_window_);
 
+  constrained_window_ = NULL;
   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) {
@@ skipping 257 matching lines @@
                                      widget, "x", &value);
 
     int child_y = std::max(
         allocation->y + allocation->height - requisition.height, 0);
     g_value_set_int(&value, child_y);
     gtk_container_child_set_property(GTK_CONTAINER(floating_container),
                                      widget, "y", &value);
     g_value_unset(&value);
   }
 
-  // Place each ConstrainedWindow in the center of the view.
+  // Place the ConstrainedWindow in the center of the view.
   int half_view_width = std::max((allocation->x + allocation->width) / 2, 0);
   int half_view_height = std::max((allocation->y + allocation->height) / 2, 0);
-  std::vector<ConstrainedWindowGtk*>::iterator it =
-      tab_contents_view->constrained_windows_.begin();
-  std::vector<ConstrainedWindowGtk*>::iterator end =
-      tab_contents_view->constrained_windows_.end();
-  for (; it != end; ++it) {
-    GtkWidget* widget = (*it)->widget();
+  if (tab_contents_view->constrained_window_) {
+    GtkWidget* widget = tab_contents_view->constrained_window_->widget();
     DCHECK(widget->parent == tab_contents_view->floating_.get());
 
     GtkRequisition requisition;
     gtk_widget_size_request(widget, &requisition);
 
     GValue value = { 0, };
     g_value_init(&value, G_TYPE_INT);
 
     int child_x = std::max(half_view_width - (requisition.width / 2), 0);
     g_value_set_int(&value, child_x);
     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);
   }
 }