Support auto-hide taskbar for panels on Windows.

chrome/browser/ui/panels/panel_browsertest.cc

 // Copyright (c) 2011 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 "base/command_line.h"
-#include "base/mac/scoped_nsautorelease_pool.h"
-#include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/ui/panels/base_panel_browser_test.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/find_bar/find_bar.h"
 #include "chrome/browser/ui/find_bar/find_bar_controller.h"
 #include "chrome/browser/ui/panels/native_panel.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/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/browser/download/download_manager.h"
 #include "content/browser/net/url_request_mock_http_job.h"
-#include "content/browser/tab_contents/test_tab_contents.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-#if defined(OS_MACOSX)
-#include "chrome/browser/ui/cocoa/find_bar/find_bar_bridge.h"
-#endif
-
-class PanelBrowserTest : public InProcessBrowserTest {
+class PanelBrowserTest : public BasePanelBrowserTest {
  public:
-  PanelBrowserTest() : InProcessBrowserTest() {
-#if defined(OS_MACOSX)
-    FindBarBridge::disable_animations_during_testing_ = true;
-#endif
-  }
-
-  virtual void SetUpCommandLine(CommandLine* command_line) {
-    command_line->AppendSwitch(switches::kEnablePanels);
+  PanelBrowserTest() : BasePanelBrowserTest() {
   }
 
  protected:
-  Panel* CreatePanel(const std::string& name, const gfx::Rect& bounds) {
-    // Opening panels on a Mac causes NSWindowController of the Panel window
-    // to be autoreleased. We need a pool drained after it's done so the test
-    // can close correctly. The NSWindowController of the Panel window controls
-    // lifetime of the Browser object so we want to release it as soon as
-    // possible. In real Chrome, this is done by message pump.
-    // On non-Mac platform, this is an empty class.
-    base::mac::ScopedNSAutoreleasePool autorelease_pool;
-
-    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();
-    MessageLoopForUI::current()->RunAllPending();
-
-    return panel;
-  }
-
   void CloseWindowAndWait(Browser* browser) {
     // Closing a browser window may involve several async tasks. Need to use
     // message pump and wait for the notification.
     size_t browser_count = BrowserList::size();
     ui_test_utils::WindowedNotificationObserver signal(
         chrome::NOTIFICATION_BROWSER_CLOSED,
         Source<Browser>(browser));
     browser->CloseWindow();
     signal.Wait();
     // Now we have one less browser instance.
     EXPECT_EQ(browser_count - 1, BrowserList::size());
   }
 
-  // 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.
+    DictionaryValue empty_value;
     scoped_refptr<Extension> extension1 =
-        CreateExtension(FILE_PATH_LITERAL("extension1"));
+        CreateExtension(FILE_PATH_LITERAL("extension1"),
+        Extension::INVALID, empty_value);
     scoped_refptr<Extension> extension2 =
-        CreateExtension(FILE_PATH_LITERAL("extension2"));
+        CreateExtension(FILE_PATH_LITERAL("extension2"),
+        Extension::INVALID, empty_value);
     scoped_refptr<Extension> extension3 =
-        CreateExtension(FILE_PATH_LITERAL("extension3"));
+        CreateExtension(FILE_PATH_LITERAL("extension3"),
+        Extension::INVALID, empty_value);
 
     // First, create 3 panels.
-    Panel* panel1 = CreatePanel(
+    Panel* panel1 = CreatePanelWithBounds(
         web_app::GenerateApplicationNameFromExtensionId(extension1->id()),
         gfx::Rect(0, 0, 250, 200));
-    Panel* panel2 = CreatePanel(
+    Panel* panel2 = CreatePanelWithBounds(
         web_app::GenerateApplicationNameFromExtensionId(extension2->id()),
         gfx::Rect(0, 0, 300, 200));
-    Panel* panel3 = CreatePanel(
+    Panel* panel3 = CreatePanelWithBounds(
         web_app::GenerateApplicationNameFromExtensionId(extension1->id()),
         gfx::Rect(0, 0, 200, 200));
     ASSERT_EQ(3, panel_manager->num_panels());
 
     // Test closing the leftmost panel that is from same extension.
     ui_test_utils::WindowedNotificationObserver signal(
         chrome::NOTIFICATION_BROWSER_CLOSED,
         Source<Browser>(panel2->browser()));
-    Panel* panel4 = CreatePanel(
+    Panel* panel4 = CreatePanelWithBounds(
         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 leftmost panel.
     ui_test_utils::WindowedNotificationObserver signal2(
         chrome::NOTIFICATION_BROWSER_CLOSED,
         Source<Browser>(panel4->browser()));
-    Panel* panel5 = CreatePanel(
+    Panel* panel5 = CreatePanelWithBounds(
         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 leftmost 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(
+    Panel* panel6 = CreatePanelWithBounds(
         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();
   }
 
-  void SetWorkArea(const gfx::Rect& work_area) {
-    PanelManager::GetInstance()->SetWorkArea(gfx::Rect(0, 0, 800, 600));
-  }
-
   int horizontal_spacing() {
     return PanelManager::horizontal_spacing();
   }
 
   std::vector<gfx::Rect> GetAllPanelsBounds() {
     std::vector<gfx::Rect> panels_bounds;
     const std::vector<Panel*>& panels = PanelManager::GetInstance()->panels();
     for (size_t i = 0; i < panels.size(); ++i)
       panels_bounds.push_back(panels[i]->GetRestoredBounds());
     return panels_bounds;
@@ skipping 96 matching lines @@
       CheckPanelBoundsWithDeltas(panels, test_begin_bounds,
                                  expected_delta_x_after_finish);
     }
   }
 };
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, CreatePanel) {
   PanelManager* panel_manager = PanelManager::GetInstance();
   EXPECT_EQ(0, panel_manager->num_panels()); // No panels initially.
 
-  Panel* panel = CreatePanel("PanelTest", gfx::Rect());
+  Panel* panel = CreatePanel("PanelTest");
   EXPECT_EQ(1, panel_manager->num_panels());
 
   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);
 
   CloseWindowAndWait(panel->browser());
 
   EXPECT_EQ(0, panel_manager->num_panels());
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, FindBar) {
-  Panel* panel = CreatePanel("PanelTest", gfx::Rect(0, 0, 400, 400));
+  Panel* panel = CreatePanelWithBounds("PanelTest", gfx::Rect(0, 0, 400, 400));
   Browser* browser = panel->browser();
   browser->ShowFindBar();
   ASSERT_TRUE(browser->GetFindBarController()->find_bar()->IsFindBarVisible());
   panel->Close();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, CreatePanelOnOverflow) {
   TestCreatePanelOnOverflow();
 }
 
 #if defined(TOOLKIT_GTK) || defined(OS_WIN)
 #define MAYBE_DragPanels DragPanels
 #else
 #define MAYBE_DragPanels DISABLED_DragPanels
 #endif
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_DragPanels) {
-  // Set work area to make the test consistent on different monitor sizes.
-  SetWorkArea(gfx::Rect(0, 0, 800, 600));
-
   static const int max_panels = 3;
   static const int zero_delta = 0;
   static const int small_delta = 10;
   static const int big_delta = 70;
   static const int bigger_delta = 120;
   static const int biggest_delta = 200;
   static const std::vector<int> zero_deltas(max_panels, zero_delta);
 
   std::vector<int> expected_delta_x_after_drag(max_panels, zero_delta);
   std::vector<int> expected_delta_x_after_finish(max_panels, zero_delta);
   std::vector<gfx::Rect> current_bounds;
   std::vector<gfx::Rect> initial_bounds;
 
   // Tests with a single panel.
   {
-    CreatePanel("PanelTest1", gfx::Rect(0, 0, 100, 100));
+    CreatePanelWithBounds("PanelTest1", gfx::Rect(0, 0, 100, 100));
 
     // Drag left.
     expected_delta_x_after_drag[0] = -big_delta;
     expected_delta_x_after_finish = zero_deltas;
     TestDragging(-big_delta, zero_delta, 0, expected_delta_x_after_drag,
                  zero_deltas, GetAllPanelsBounds(),
                  DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
 
     // Drag left and cancel.
     expected_delta_x_after_drag[0] = -big_delta;
@@ skipping 17 matching lines @@
     TestDragging(0, -big_delta, 0, zero_deltas, zero_deltas,
                  GetAllPanelsBounds(), DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
 
     // Drag down.  Expect no movement on drag.
     TestDragging(0, big_delta, 0, zero_deltas, zero_deltas,
                  GetAllPanelsBounds(), DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
   }
 
   // Tests with two panels.
   {
-    CreatePanel("PanelTest2", gfx::Rect(0, 0, 120, 120));
+    CreatePanelWithBounds("PanelTest2", gfx::Rect(0, 0, 120, 120));
 
     // Drag left, small delta, expect no shuffle.
     {
       expected_delta_x_after_drag = zero_deltas;
       expected_delta_x_after_drag[0] = -small_delta;
       TestDragging(-small_delta, zero_delta, 0, expected_delta_x_after_drag,
                    zero_deltas, GetAllPanelsBounds(),
                    DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
 
       // Drag right panel i.e index 0, towards left, big delta, expect shuffle.
@@ skipping 52 matching lines @@
       // As the drag is being canceled, we don't need expected_delta_x_after
       // finish.  Instead initial_bounds will be used.
       TestDragging(big_delta, zero_delta, 1, expected_delta_x_after_drag,
                    zero_deltas, initial_bounds,
                    DRAG_ACTION_BEGIN | DRAG_ACTION_CANCEL);
     }
   }
 
   // Tests with three panels.
   {
-    CreatePanel("PanelTest3", gfx::Rect(0, 0, 110, 110));
+    CreatePanelWithBounds("PanelTest3", gfx::Rect(0, 0, 110, 110));
 
     // Drag leftmost panel to become rightmost with two shuffles.
     // We test both shuffles.
     {
       // Drag the left-most panel towards right without ending or cancelling it.
       // Expect shuffle.
       initial_bounds = GetAllPanelsBounds();
       expected_delta_x_after_drag = zero_deltas;
 
       // Delta for panel being dragged.
@@ skipping 304 matching lines @@
   EXPECT_EQ(1, tabbed_browser->tab_count());
   ASSERT_TRUE(tabbed_browser->window()->IsDownloadShelfVisible());
   tabbed_browser->CloseWindow();
 #endif
 
   EXPECT_EQ(1, panel_browser->tab_count());
   ASSERT_FALSE(panel_browser->window()->IsDownloadShelfVisible());
 
   panel_browser->CloseWindow();
 }