Handle panel overflow when creating a new panel on Windows.

BUG=none
TEST=new browser test

Review URL: http://codereview.chromium.org/7493020

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@94620 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 226 insertions, 116 deletions

diff --git a/chrome/browser/ui/panels/panel.h b/chrome/browser/ui/panels/panel.h
index df5271d..8d5a1ae 100644
--- a/chrome/browser/ui/panels/panel.h
+++ b/chrome/browser/ui/panels/panel.h
@@ -156,6 +156,7 @@ class Panel : public BrowserWindow {
   NativePanel* native_panel() { return native_panel_; }
 #endif
 
+  Browser* browser() const { return browser_; }
   ExpansionState expansion_state() const { return expansion_state_; }
 
  protected:
diff --git a/chrome/browser/ui/panels/panel_app_browsertest.cc b/chrome/browser/ui/panels/panel_app_browsertest.cc
index e68ecdc..f494e4e 100644
--- a/chrome/browser/ui/panels/panel_app_browsertest.cc
+++ b/chrome/browser/ui/panels/panel_app_browsertest.cc
@@ -46,7 +46,7 @@ IN_PROC_BROWSER_TEST_F(PanelAppBrowserTest, OpenAppInPanel) {
 
   // No Panels initially.
   PanelManager* panel_manager = PanelManager::GetInstance();
-  EXPECT_EQ(0, panel_manager->active_count()); // No panels initially.
+  EXPECT_EQ(0, panel_manager->num_panels()); // No panels initially.
 
   LoadAndLaunchExtension("app_with_panel_container");
 
@@ -65,8 +65,8 @@ IN_PROC_BROWSER_TEST_F(PanelAppBrowserTest, OpenAppInPanel) {
   EXPECT_TRUE(new_browser->is_type_panel());
 
   // Now also check that PanelManager has one new Panel under management.
-  EXPECT_EQ(1, panel_manager->active_count());
+  EXPECT_EQ(1, panel_manager->num_panels());
 
   new_browser->CloseWindow();
-  EXPECT_EQ(0, panel_manager->active_count());
+  EXPECT_EQ(0, panel_manager->num_panels());
 }
diff --git a/chrome/browser/ui/panels/panel_browser_view.cc b/chrome/browser/ui/panels/panel_browser_view.cc
index e471032..324de83 100644
--- a/chrome/browser/ui/panels/panel_browser_view.cc
+++ b/chrome/browser/ui/panels/panel_browser_view.cc
@@ -71,7 +71,7 @@ void PanelBrowserView::Close() {
 
   // Stop the global mouse watcher only if we do not have any panels up.
 #if defined(OS_WIN)
-  if (panel_->manager()->active_count() == 1)
+  if (panel_->manager()->num_panels() == 1)
     StopMouseWatcher();
 #endif
 }
diff --git a/chrome/browser/ui/panels/panel_browser_window_cocoa_unittest.mm b/chrome/browser/ui/panels/panel_browser_window_cocoa_unittest.mm
index e394e86..46b38d0 100644
--- a/chrome/browser/ui/panels/panel_browser_window_cocoa_unittest.mm
+++ b/chrome/browser/ui/panels/panel_browser_window_cocoa_unittest.mm
@@ -58,7 +58,7 @@ class PanelBrowserWindowCocoaTest : public CocoaTest {
 
 TEST_F(PanelBrowserWindowCocoaTest, CreateClose) {
   PanelManager* manager = PanelManager::GetInstance();
-  EXPECT_EQ(0, manager->active_count());  // No panels initially.
+  EXPECT_EQ(0, manager->num_panels());  // No panels initially.
 
   Panel* panel = CreateTestPanel("Test Panel");
   EXPECT_TRUE(panel);
@@ -67,7 +67,7 @@ TEST_F(PanelBrowserWindowCocoaTest, CreateClose) {
       static_cast<PanelBrowserWindowCocoa*>(panel->native_panel());
 
   EXPECT_EQ(panel, native_window->panel_);  // Back pointer initialized.
-  EXPECT_EQ(1, manager->active_count());
+  EXPECT_EQ(1, manager->num_panels());
 
   // Window should not load before Show()
   EXPECT_FALSE([native_window->controller_ isWindowLoaded]);
@@ -84,7 +84,7 @@ TEST_F(PanelBrowserWindowCocoaTest, CreateClose) {
   EXPECT_EQ(NO, [[native_window->controller_ window] isReleasedWhenClosed]);
 
   panel->Close();
-  EXPECT_EQ(0, manager->active_count());
+  EXPECT_EQ(0, manager->num_panels());
   // Close() destroys the controller, which destroys the NSWindow. CocoaTest
   // base class verifies that there is no remaining open windows after the test.
   EXPECT_FALSE(native_window->controller_);
@@ -95,7 +95,7 @@ TEST_F(PanelBrowserWindowCocoaTest, AssignedBounds) {
   Panel* panel1 = CreateTestPanel("Test Panel 1");
   Panel* panel2 = CreateTestPanel("Test Panel 2");
   Panel* panel3 = CreateTestPanel("Test Panel 3");
-  EXPECT_EQ(3, manager->active_count());
+  EXPECT_EQ(3, manager->num_panels());
 
   panel1->Show();
   panel2->Show();
@@ -116,15 +116,15 @@ TEST_F(PanelBrowserWindowCocoaTest, AssignedBounds) {
   panel2->Close();
   bounds3 = panel3->GetBounds();
   EXPECT_EQ(bounds2, bounds3);
-  EXPECT_EQ(2, manager->active_count());
+  EXPECT_EQ(2, manager->num_panels());
 
   // After panel1 is closed, panel3 should take its place.
   panel1->Close();
   EXPECT_EQ(bounds1, panel3->GetBounds());
-  EXPECT_EQ(1, manager->active_count());
+  EXPECT_EQ(1, manager->num_panels());
 
   panel3->Close();
-  EXPECT_EQ(0, manager->active_count());
+  EXPECT_EQ(0, manager->num_panels());
 }
 
 // Same test as AssignedBounds, but checks actual bounds on native OS windows.
@@ -133,7 +133,7 @@ TEST_F(PanelBrowserWindowCocoaTest, NativeBounds) {
   Panel* panel1 = CreateTestPanel("Test Panel 1");
   Panel* panel2 = CreateTestPanel("Test Panel 2");
   Panel* panel3 = CreateTestPanel("Test Panel 3");
-  EXPECT_EQ(3, manager->active_count());
+  EXPECT_EQ(3, manager->num_panels());
 
   panel1->Show();
   panel2->Show();
@@ -162,7 +162,7 @@ TEST_F(PanelBrowserWindowCocoaTest, NativeBounds) {
   EXPECT_EQ(bounds2.origin.y, bounds3.origin.y);
   EXPECT_EQ(bounds2.size.width, bounds3.size.width);
   EXPECT_EQ(bounds2.size.height, bounds3.size.height);
-  EXPECT_EQ(2, manager->active_count());
+  EXPECT_EQ(2, manager->num_panels());
 
   // After panel1 is closed, panel3 should take its place.
   panel1->Close();
@@ -171,10 +171,10 @@ TEST_F(PanelBrowserWindowCocoaTest, NativeBounds) {
   EXPECT_EQ(bounds1.origin.y, bounds3.origin.y);
   EXPECT_EQ(bounds1.size.width, bounds3.size.width);
   EXPECT_EQ(bounds1.size.height, bounds3.size.height);
-  EXPECT_EQ(1, manager->active_count());
+  EXPECT_EQ(1, manager->num_panels());
 
   panel3->Close();
-  EXPECT_EQ(0, manager->active_count());
+  EXPECT_EQ(0, manager->num_panels());
 }
 
 // Verify the titlebar is being created.
@@ -241,9 +241,9 @@ TEST_F(PanelBrowserWindowCocoaTest, TitlebarViewClose) {
   PanelTitlebarViewCocoa* titlebar = [native_window->controller_ titlebarView];
   EXPECT_TRUE(titlebar);
 
-  EXPECT_EQ(1, manager->active_count());
+  EXPECT_EQ(1, manager->num_panels());
   // Simulate clicking Close Button. This should close the Panel as well.
   [titlebar simulateCloseButtonClick];
-  EXPECT_EQ(0, manager->active_count());
+  EXPECT_EQ(0, manager->num_panels());
 }
 
diff --git a/chrome/browser/ui/panels/panel_browsertest.cc b/chrome/browser/ui/panels/panel_browsertest.cc
index 74a6fdb..35c8b79 100644
--- a/chrome/browser/ui/panels/panel_browsertest.cc
+++ b/chrome/browser/ui/panels/panel_browsertest.cc
@@ -4,15 +4,19 @@
 
 #include "base/command_line.h"
 #include "chrome/browser/download/download_manager.h"
+#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/ui/panels/panel.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/extensions/extension.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/in_process_browser_test.h"
 #include "chrome/test/ui_test_utils.h"
@@ -27,33 +31,143 @@ class PanelBrowserTest : public InProcessBrowserTest {
   virtual void SetUpCommandLine(CommandLine* command_line) {
     command_line->AppendSwitch(switches::kEnablePanels);
   }
+
+ protected:
+  Panel* CreatePanel(const std::string& name, const gfx::Rect& bounds) {
+    Browser* panel_browser = Browser::CreateForApp(Browser::TYPE_PANEL,
+                                                   name,
+                                                   bounds,
+                                                   browser()->profile());
+    EXPECT_TRUE(panel_browser->is_type_panel());
+
+    TabContentsWrapper* tab_contents =
+        new TabContentsWrapper(new TestTabContents(browser()->profile(), NULL));
+    panel_browser->AddTab(tab_contents, PageTransition::LINK);
+
+    Panel* panel = static_cast<Panel*>(panel_browser->window());
+    panel->Show();
+    return panel;
+  }
+
+  // Creates a testing extension.
+  scoped_refptr<Extension> CreateExtension(const FilePath::StringType& path) {
+#if defined(OS_WIN)
+    FilePath full_path(FILE_PATH_LITERAL("c:\\"));
+#else
+    FilePath full_path(FILE_PATH_LITERAL("/"));
+#endif
+    full_path = full_path.Append(path);
+    DictionaryValue input_value;
+    input_value.SetString(extension_manifest_keys::kVersion, "1.0.0.0");
+    input_value.SetString(extension_manifest_keys::kName, "Sample Extension");
+    std::string error;
+    scoped_refptr<Extension> extension = Extension::Create(
+        full_path,  Extension::INVALID, input_value,
+        Extension::STRICT_ERROR_CHECKS, &error);
+    EXPECT_TRUE(extension.get());
+    EXPECT_STREQ("", error.c_str());
+    browser()->GetProfile()->GetExtensionService()->OnLoadSingleExtension(
+        extension.get(), false);
+    return extension;
+  }
+
+  void TestCreatePanelOnOverflow() {
+    PanelManager* panel_manager = PanelManager::GetInstance();
+    EXPECT_EQ(0, panel_manager->num_panels()); // No panels initially.
+
+    // Specify the work area for testing purpose.
+    panel_manager->SetWorkArea(gfx::Rect(0, 0, 800, 600));
+
+    // Create testing extensions.
+    scoped_refptr<Extension> extension1 =
+        CreateExtension(FILE_PATH_LITERAL("extension1"));
+    scoped_refptr<Extension> extension2 =
+        CreateExtension(FILE_PATH_LITERAL("extension2"));
+    scoped_refptr<Extension> extension3 =
+        CreateExtension(FILE_PATH_LITERAL("extension3"));
+
+    // First, create 3 panels.
+    Panel* panel1 = CreatePanel(
+        web_app::GenerateApplicationNameFromExtensionId(extension1->id()),
+        gfx::Rect(0, 0, 250, 200));
+    Panel* panel2 = CreatePanel(
+        web_app::GenerateApplicationNameFromExtensionId(extension2->id()),
+        gfx::Rect(0, 0, 300, 200));
+    Panel* panel3 = CreatePanel(
+        web_app::GenerateApplicationNameFromExtensionId(extension1->id()),
+        gfx::Rect(0, 0, 200, 200));
+    ASSERT_EQ(3, panel_manager->num_panels());
+
+    // Test closing the left-most panel that is from same extension.
+    ui_test_utils::WindowedNotificationObserver signal(
+        chrome::NOTIFICATION_BROWSER_CLOSED,
+        Source<Browser>(panel2->browser()));
+    Panel* panel4 = CreatePanel(
+        web_app::GenerateApplicationNameFromExtensionId(extension2->id()),
+        gfx::Rect(0, 0, 280, 200));
+    signal.Wait();
+    ASSERT_EQ(3, panel_manager->num_panels());
+    EXPECT_LT(panel4->GetBounds().right(), panel3->GetBounds().x());
+    EXPECT_LT(panel3->GetBounds().right(), panel1->GetBounds().x());
+
+    // Test closing the left-most panel.
+    ui_test_utils::WindowedNotificationObserver signal2(
+        chrome::NOTIFICATION_BROWSER_CLOSED,
+        Source<Browser>(panel4->browser()));
+    Panel* panel5 = CreatePanel(
+        web_app::GenerateApplicationNameFromExtensionId(extension3->id()),
+        gfx::Rect(0, 0, 300, 200));
+    signal2.Wait();
+    ASSERT_EQ(3, panel_manager->num_panels());
+    EXPECT_LT(panel5->GetBounds().right(), panel3->GetBounds().x());
+    EXPECT_LT(panel3->GetBounds().right(), panel1->GetBounds().x());
+
+    // Test closing 2 left-most panels.
+    ui_test_utils::WindowedNotificationObserver signal3(
+        chrome::NOTIFICATION_BROWSER_CLOSED,
+        Source<Browser>(panel3->browser()));
+    ui_test_utils::WindowedNotificationObserver signal4(
+        chrome::NOTIFICATION_BROWSER_CLOSED,
+        Source<Browser>(panel5->browser()));
+    Panel* panel6 = CreatePanel(
+        web_app::GenerateApplicationNameFromExtensionId(extension3->id()),
+        gfx::Rect(0, 0, 500, 200));
+    signal3.Wait();
+    signal4.Wait();
+    ASSERT_EQ(2, panel_manager->num_panels());
+    EXPECT_LT(panel6->GetBounds().right(), panel1->GetBounds().x());
+
+    panel1->Close();
+    panel6->Close();
+  }
 };
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, CreatePanel) {
   PanelManager* panel_manager = PanelManager::GetInstance();
-  EXPECT_EQ(0, panel_manager->active_count()); // No panels initially.
-
-  Browser* panel_browser = Browser::CreateForApp(Browser::TYPE_PANEL,
-                                                 "PanelTest",
-                                                 gfx::Rect(),
-                                                 browser()->profile());
-  EXPECT_TRUE(panel_browser->is_type_panel());
+  EXPECT_EQ(0, panel_manager->num_panels()); // No panels initially.
 
-  TabContentsWrapper* tab_contents =
-      new TabContentsWrapper(new TestTabContents(browser()->profile(), NULL));
-  panel_browser->AddTab(tab_contents, PageTransition::LINK);
+  Panel* panel = CreatePanel("PanelTest", gfx::Rect());
+  EXPECT_EQ(1, panel_manager->num_panels());
 
-  panel_browser->window()->Show();
-  EXPECT_EQ(1, panel_manager->active_count());
-
-  gfx::Rect bounds = panel_browser->window()->GetBounds();
+  gfx::Rect bounds = panel->GetBounds();
   EXPECT_GT(bounds.x(), 0);
   EXPECT_GT(bounds.y(), 0);
   EXPECT_GT(bounds.width(), 0);
   EXPECT_GT(bounds.height(), 0);
 
-  panel_browser->window()->Close();
-  EXPECT_EQ(0, panel_manager->active_count());
+  panel->Close();
+  EXPECT_EQ(0, panel_manager->num_panels());
+}
+
+// TODO(jianli): Investigate and enable it for Mac.
+#ifdef OS_MACOSX
+#define MAYBE_CreatePanelOnOverflow DISABLED_CreatePanelOnOverflow
+#else
+#define MAYBE_CreatePanelOnOverflow CreatePanelOnOverflow
+#endif
+
+IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_CreatePanelOnOverflow) {
+  TestCreatePanelOnOverflow();
 }
 
 class PanelDownloadTest : public PanelBrowserTest {
diff --git a/chrome/browser/ui/panels/panel_manager.cc b/chrome/browser/ui/panels/panel_manager.cc
index 9aea49e..cc8d00d 100644
--- a/chrome/browser/ui/panels/panel_manager.cc
+++ b/chrome/browser/ui/panels/panel_manager.cc
@@ -55,15 +55,17 @@ PanelManager::PanelManager()
 }
 
 PanelManager::~PanelManager() {
-  DCHECK(active_panels_.empty());
-  DCHECK(pending_panels_.empty());
+  DCHECK(panels_.empty());
   DCHECK(panels_pending_to_remove_.empty());
 }
 
 void PanelManager::OnDisplayChanged() {
   scoped_ptr<WindowSizer::MonitorInfoProvider> info_provider(
       WindowSizer::CreateDefaultMonitorInfoProvider());
-  gfx::Rect work_area = info_provider->GetPrimaryMonitorWorkArea();
+  SetWorkArea(info_provider->GetPrimaryMonitorWorkArea());
+}
+
+void PanelManager::SetWorkArea(const gfx::Rect& work_area) {
   if (work_area == work_area_)
     return;
   work_area_ = work_area;
@@ -74,34 +76,44 @@ void PanelManager::OnDisplayChanged() {
   max_width_ = static_cast<int>(work_area.width() * kPanelMaxWidthFactor);
   max_height_ = static_cast<int>(work_area.height() * kPanelMaxHeightFactor);
 
-  Rearrange(active_panels_.begin());
+  Rearrange(panels_.begin());
+}
+
+void PanelManager::FindAndClosePanelOnOverflow(const Extension* extension) {
+  Panel* panel_to_close = NULL;
+
+  // Try to find the left-most panel invoked from the same extension and close
+  // it.
+  for (Panels::reverse_iterator iter = panels_.rbegin();
+       iter != panels_.rend(); ++iter) {
+    if (extension == Panel::GetExtension((*iter)->browser_)) {
+      panel_to_close = *iter;
+      break;
+    }
+  }
+
+  // If none is found, just pick the left-most panel.
+  if (!panel_to_close)
+    panel_to_close = panels_.back();
+
+  panel_to_close->Close();
 }
 
 Panel* PanelManager::CreatePanel(Browser* browser) {
+  const Extension* extension = NULL;
   gfx::Rect bounds = browser->override_bounds();
-  bool is_within_bounds = ComputeBoundsForNextPanel(&bounds, true);
+  while (!ComputeBoundsForNextPanel(&bounds, true)) {
+    if (!extension)
+      extension = Panel::GetExtension(browser);
+    FindAndClosePanelOnOverflow(extension);
+  }
 
   Panel* panel = new Panel(browser, bounds);
-  if (is_within_bounds)
-    active_panels_.push_back(panel);
-  else
-    pending_panels_.push_back(panel);
+  panels_.push_back(panel);
 
   return panel;
 }
 
-void PanelManager::ProcessPending() {
-  while (!pending_panels_.empty()) {
-    Panel* panel = pending_panels_.front();
-    gfx::Rect bounds = panel->GetBounds();
-    if (ComputeBoundsForNextPanel(&bounds, true)) {
-      // TODO(jianli): More work to support displaying pending panels.
-      active_panels_.push_back(panel);
-      pending_panels_.pop_front();
-    }
-  }
-}
-
 void PanelManager::Remove(Panel* panel) {
   // If we're in the process of dragging, delay the removal.
   if (dragging_panel_index_ != kInvalidPanelIndex) {
@@ -119,28 +131,18 @@ void PanelManager::DelayedRemove() {
 }
 
 void PanelManager::DoRemove(Panel* panel) {
-  // Checks the active panel list.
-  ActivePanels::iterator iter =
-      find(active_panels_.begin(), active_panels_.end(), panel);
-  if (iter == active_panels_.end()) {
-    // Checks the pending panel list.
-    PendingPanels::iterator iter2 =
-        find(pending_panels_.begin(), pending_panels_.end(), panel);
-    if (iter2 != pending_panels_.end())
-      pending_panels_.erase(iter2);
+  Panels::iterator iter = find(panels_.begin(), panels_.end(), panel);
+  if (iter == panels_.end())
     return;
-  }
 
   gfx::Rect bounds = (*iter)->GetBounds();
   current_x_ = bounds.x() + bounds.width();
-  Rearrange(active_panels_.erase(iter));
-
-  ProcessPending();
+  Rearrange(panels_.erase(iter));
 }
 
 void PanelManager::StartDragging(Panel* panel) {
-  for (size_t i = 0; i < active_panels_.size(); ++i) {
-    if (active_panels_[i] == panel) {
+  for (size_t i = 0; i < panels_.size(); ++i) {
+    if (panels_[i] == panel) {
       dragging_panel_index_ = i;
       dragging_panel_bounds_ = panel->GetBounds();
       dragging_panel_original_x_ = dragging_panel_bounds_.x();
@@ -156,7 +158,7 @@ void PanelManager::Drag(int delta_x) {
     return;
 
   // Moves this panel to the dragging position.
-  Panel* dragging_panel = active_panels_[dragging_panel_index_];
+  Panel* dragging_panel = panels_[dragging_panel_index_];
   gfx::Rect new_bounds(dragging_panel->GetBounds());
   new_bounds.set_x(new_bounds.x() + delta_x);
   dragging_panel->SetPanelBounds(new_bounds);
@@ -169,7 +171,7 @@ void PanelManager::Drag(int delta_x) {
 }
 
 void PanelManager::DragLeft() {
-  Panel* dragging_panel = active_panels_[dragging_panel_index_];
+  Panel* dragging_panel = panels_[dragging_panel_index_];
 
   // This is the left corner of the dragging panel. We use it to check against
   // all the panels on its left.
@@ -181,8 +183,8 @@ void PanelManager::DragLeft() {
 
   // Checks the panels to the left of the dragging panel.
   size_t current_panel_index = dragging_panel_index_ + 1;
-  for (; current_panel_index < active_panels_.size(); ++current_panel_index) {
-    Panel* current_panel = active_panels_[current_panel_index];
+  for (; current_panel_index < panels_.size(); ++current_panel_index) {
+    Panel* current_panel = panels_[current_panel_index];
 
     // Current panel will only be affected if the left corner of dragging
     // panel goes beyond the middle position of the current panel.
@@ -198,7 +200,7 @@ void PanelManager::DragLeft() {
 
     // Updates the index of current panel since it has been moved to the
     // position of previous panel.
-    active_panels_[current_panel_index - 1] = current_panel;
+    panels_[current_panel_index - 1] = current_panel;
   }
 
   // Updates the position and index of dragging panel as the result of moving
@@ -207,12 +209,12 @@ void PanelManager::DragLeft() {
     dragging_panel_bounds_.set_x(current_panel_right_boundary -
                                  dragging_panel_bounds_.width());
     dragging_panel_index_ = current_panel_index - 1;
-    active_panels_[dragging_panel_index_] = dragging_panel;
+    panels_[dragging_panel_index_] = dragging_panel;
   }
 }
 
 void PanelManager::DragRight() {
-  Panel* dragging_panel = active_panels_[dragging_panel_index_];
+  Panel* dragging_panel = panels_[dragging_panel_index_];
 
   // This is the right corner of the dragging panel. We use it to check against
   // all the panels on its right.
@@ -225,7 +227,7 @@ void PanelManager::DragRight() {
   // Checks the panels to the right of the dragging panel.
   int current_panel_index = static_cast<int>(dragging_panel_index_) - 1;
   for (; current_panel_index >= 0; --current_panel_index) {
-    Panel* current_panel = active_panels_[current_panel_index];
+    Panel* current_panel = panels_[current_panel_index];
 
     // Current panel will only be affected if the right corner of dragging
     // panel goes beyond the middle position of the current panel.
@@ -241,7 +243,7 @@ void PanelManager::DragRight() {
 
     // Updates the index of current panel since it has been moved to the
     // position of previous panel.
-    active_panels_[current_panel_index + 1] = current_panel;
+    panels_[current_panel_index + 1] = current_panel;
   }
 
   // Updates the position and index of dragging panel as the result of moving
@@ -249,7 +251,7 @@ void PanelManager::DragRight() {
   if (current_panel_index != static_cast<int>(dragging_panel_index_) - 1) {
     dragging_panel_bounds_.set_x(current_panel_left_boundary);
     dragging_panel_index_ = current_panel_index + 1;
-    active_panels_[dragging_panel_index_] = dragging_panel;
+    panels_[dragging_panel_index_] = dragging_panel;
   }
 }
 
@@ -258,9 +260,9 @@ void PanelManager::EndDragging(bool cancelled) {
 
   if (cancelled) {
     Drag(dragging_panel_original_x_ -
-         active_panels_[dragging_panel_index_]->GetBounds().x());
+         panels_[dragging_panel_index_]->GetBounds().x());
   } else {
-    active_panels_[dragging_panel_index_]->SetPanelBounds(
+    panels_[dragging_panel_index_]->SetPanelBounds(
         dragging_panel_bounds_);
   }
 
@@ -271,8 +273,8 @@ void PanelManager::EndDragging(bool cancelled) {
 
 bool PanelManager::ShouldBringUpTitleBarForAllMinimizedPanels(
     int mouse_x, int mouse_y) const {
-  for (ActivePanels::const_iterator iter = active_panels_.begin();
-       iter != active_panels_.end(); ++iter) {
+  for (Panels::const_iterator iter = panels_.begin();
+       iter != panels_.end(); ++iter) {
     if ((*iter)->ShouldBringUpTitleBar(mouse_x, mouse_y))
       return true;
   }
@@ -280,8 +282,8 @@ bool PanelManager::ShouldBringUpTitleBarForAllMinimizedPanels(
 }
 
 void PanelManager::BringUpOrDownTitleBarForAllMinimizedPanels(bool bring_up) {
-  for (ActivePanels::const_iterator iter = active_panels_.begin();
-       iter != active_panels_.end(); ++iter) {
+  for (Panels::const_iterator iter = panels_.begin();
+       iter != panels_.end(); ++iter) {
     Panel* panel = *iter;
 
     // Skip any panel that is drawing the attention.
@@ -298,12 +300,11 @@ void PanelManager::BringUpOrDownTitleBarForAllMinimizedPanels(bool bring_up) {
   }
 }
 
-void PanelManager::Rearrange(ActivePanels::iterator iter_to_start) {
-  if (iter_to_start == active_panels_.end())
+void PanelManager::Rearrange(Panels::iterator iter_to_start) {
+  if (iter_to_start == panels_.end())
     return;
 
-  for (ActivePanels::iterator iter = iter_to_start;
-       iter != active_panels_.end(); ++iter) {
+  for (Panels::iterator iter = iter_to_start; iter != panels_.end(); ++iter) {
     gfx::Rect new_bounds((*iter)->GetBounds());
     ComputeBoundsForNextPanel(&new_bounds, false);
     if (new_bounds != (*iter)->GetBounds())
@@ -346,13 +347,12 @@ bool PanelManager::ComputeBoundsForNextPanel(gfx::Rect* bounds,
   return true;
 }
 
-void PanelManager::RemoveAllActive() {
+void PanelManager::RemoveAll() {
   // This should not be called when we're in the process of dragging.
   DCHECK(dragging_panel_index_ == kInvalidPanelIndex);
 
   // Start from the bottom to avoid reshuffling.
-  for (int i = static_cast<int>(active_panels_.size()) -1; i >= 0; --i)
-    active_panels_[i]->Close();
-
-  ProcessPending();
+  for (Panels::reverse_iterator iter = panels_.rbegin();
+       iter != panels_.rend(); ++iter)
+    (*iter)->Close();
 }
diff --git a/chrome/browser/ui/panels/panel_manager.h b/chrome/browser/ui/panels/panel_manager.h
index 4de67f8..1b35f0c 100644
--- a/chrome/browser/ui/panels/panel_manager.h
+++ b/chrome/browser/ui/panels/panel_manager.h
@@ -6,7 +6,6 @@
 #define CHROME_BROWSER_UI_PANELS_PANEL_MANAGER_H_
 #pragma once
 
-#include <deque>
 #include <vector>
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
@@ -31,15 +30,10 @@ class PanelManager {
   // later.
   Panel* CreatePanel(Browser* browser);
 
-  // Removes the given panel. Both active and pending panel lists are checked.
-  // If an active panel is removed, pending panels could be displayed if space
-  // allows.
   void Remove(Panel* panel);
+  void RemoveAll();
 
-  // Removes all active panels. Pending panels will be processed for display.
-  void RemoveAllActive();
-
-  // Drags the given active panel.
+  // Drags the given panel.
   void StartDragging(Panel* panel);
   void Drag(int delta_x);
   void EndDragging(bool cancelled);
@@ -51,15 +45,19 @@ class PanelManager {
   // Brings up or down the title-bar for all minimized panels.
   void BringUpOrDownTitleBarForAllMinimizedPanels(bool bring_up);
 
-  // Returns the number of active panels.
-  int active_count() const { return active_panels_.size(); }
+  int num_panels() const { return panels_.size(); }
 
  private:
-  typedef std::vector<Panel*> ActivePanels;
-  typedef std::deque<Panel*> PendingPanels;
+  friend class PanelBrowserTest;
+
+  typedef std::vector<Panel*> Panels;
 
   PanelManager();
 
+  // Applies the new work area. This is called by OnDisplayChanged and the test
+  // code.
+  void SetWorkArea(const gfx::Rect& work_area);
+
   // Handles all the panels that're delayed to be removed.
   void DelayedRemove();
 
@@ -69,10 +67,7 @@ class PanelManager {
   // Rearranges the positions of the panels starting from the given iterator.
   // This is called when the display space has been changed, i.e. working
   // area being changed or a panel being closed.
-  void Rearrange(ActivePanels::iterator iter_to_start);
-
-  // Checks the pending panels to see if we show them when we have more space.
-  void ProcessPending();
+  void Rearrange(Panels::iterator iter_to_start);
 
   // Computes the bounds for next panel.
   // |allow_size_change| is used to indicate if the panel size can be changed to
@@ -80,19 +75,19 @@ class PanelManager {
   // Returns true if computed bounds are within the displayable area.
   bool ComputeBoundsForNextPanel(gfx::Rect* bounds, bool allow_size_change);
 
+  // Finds one panel to close so that we may have space for the new panel
+  // created by |extension|.
+  void FindAndClosePanelOnOverflow(const Extension* extension);
+
   // Help functions to drag the given panel.
   void DragLeft();
   void DragRight();
 
-  // Stores the active panels.
-  ActivePanels active_panels_;
-
-  // Stores the panels that are pending to show.
-  PendingPanels pending_panels_;
+  Panels panels_;
 
   // Stores the panels that are pending to remove. We want to delay the removal
   // when we're in the process of the dragging.
-  std::vector<Panel*> panels_pending_to_remove_;
+  Panels panels_pending_to_remove_;
 
   // Current work area used in computing the panel bounds.
   gfx::Rect work_area_;