Modify old Panel test files and include them in .gyp.

chrome/browser/ui/panels/old_panel_browsertest.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/net/url_request_mock_util.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_modal_dialogs/app_modal_dialog.h"
 #include "chrome/browser/ui/app_modal_dialogs/native_app_modal_dialog.h"
 #include "chrome/browser/ui/browser_finder.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/base_panel_browser_test.h"
+#include "chrome/browser/ui/panels/old_base_panel_browser_test.h"
 #include "chrome/browser/ui/panels/docked_panel_strip.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/panels/test_panel_mouse_watcher.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
 #include "content/test/net/url_request_mock_http_job.h"
 #include "net/base/net_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/screen.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DownloadItem;
 using content::DownloadManager;
 using content::WebContents;
 using extensions::Extension;
 
-class PanelBrowserTest : public BasePanelBrowserTest {
+class OldPanelBrowserTest : public OldBasePanelBrowserTest {
  public:
-  PanelBrowserTest() : BasePanelBrowserTest() {
+  OldPanelBrowserTest() : OldBasePanelBrowserTest() {
   }
 
  protected:
   // Helper function for debugging.
   void PrintAllPanelBounds() {
     const std::vector<Panel*>& panels = PanelManager::GetInstance()->panels();
     DLOG(WARNING) << "PanelBounds:";
     for (size_t i = 0; i < panels.size(); ++i) {
       DLOG(WARNING) << "#=" << i
                     << ", ptr=" << panels[i]
@@ skipping 186 matching lines @@
 
     // The below could be separate tests, just adding a TODO here for tracking.
     // TODO(prasadt): Add test for dragging when in titlebar exposed state.
     // TODO(prasadt): Add test in presence of auto hiding task bar.
 
     for (size_t i = 0; i < panels.size(); ++i)
       delete native_panels_testing[i];
   }
 };
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, CheckDockedPanelProperties) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, CheckDockedPanelProperties) {
   PanelManager* panel_manager = PanelManager::GetInstance();
   DockedPanelStrip* docked_strip = panel_manager->docked_strip();
 
   // Create 3 docked panels that are in expanded, title-only or minimized states
   // respectively.
   Panel* panel1 = CreatePanelWithBounds("1", gfx::Rect(0, 0, 100, 100));
   Panel* panel2 = CreatePanelWithBounds("2", gfx::Rect(0, 0, 100, 100));
   panel2->SetExpansionState(Panel::TITLE_ONLY);
   WaitForExpansionStateChanged(panel2, Panel::TITLE_ONLY);
   Panel* panel3 = CreatePanelWithBounds("3", gfx::Rect(0, 0, 100, 100));
@@ skipping 40 matching lines @@
   EXPECT_EQ(panel::NOT_RESIZABLE, panel2->CanResizeByMouse());
   EXPECT_EQ(panel::NOT_RESIZABLE, panel3->CanResizeByMouse());
 
   EXPECT_EQ(Panel::USE_PANEL_ATTENTION, panel1->attention_mode());
   EXPECT_EQ(Panel::USE_PANEL_ATTENTION, panel2->attention_mode());
   EXPECT_EQ(Panel::USE_PANEL_ATTENTION, panel3->attention_mode());
 
   panel_manager->CloseAll();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, CreatePanel) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, CreatePanel) {
   PanelManager* panel_manager = PanelManager::GetInstance();
   EXPECT_EQ(0, panel_manager->num_panels()); // No panels initially.
 
   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);
 
   EXPECT_EQ(bounds.right(),
             panel_manager->docked_strip()->StartingRightPosition());
 
   CloseWindowAndWait(panel);
 
   EXPECT_EQ(0, panel_manager->num_panels());
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, CreateBigPanel) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, CreateBigPanel) {
   gfx::Rect work_area = PanelManager::GetInstance()->
       display_settings_provider()->GetDisplayArea();
   Panel* panel = CreatePanelWithBounds("BigPanel", work_area);
   gfx::Rect bounds = panel->GetBounds();
   EXPECT_EQ(panel->max_size().width(), bounds.width());
   EXPECT_LT(bounds.width(), work_area.width());
   EXPECT_EQ(panel->max_size().height(), bounds.height());
   EXPECT_LT(bounds.height(), work_area.height());
   panel->Close();
 }
 
 // Flaky: http://crbug.com/105445
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DISABLED_AutoResize) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, DISABLED_AutoResize) {
   PanelManager* panel_manager = PanelManager::GetInstance();
   panel_manager->enable_auto_sizing(true);
   // Bigger space is needed by this test.
   SetTestingAreas(gfx::Rect(0, 0, 1200, 900), gfx::Rect());
 
   // Create a test panel with tab contents loaded.
   CreatePanelParams params("PanelTest1", gfx::Rect(), SHOW_AS_ACTIVE);
   GURL url(ui_test_utils::GetTestUrl(
       FilePath(kTestDir),
       FilePath(FILE_PATH_LITERAL("update-preferred-size.html"))));
@@ skipping 46 matching lines @@
       content::Source<Panel>(panel));
   panel->SetAutoResizable(true);
   auto_resize_enabled.Wait();
   gfx::Rect bounds_auto_resize_enabled = panel->GetBounds();
   EXPECT_EQ(bounds_on_shrink.width(), bounds_auto_resize_enabled.width());
   EXPECT_EQ(bounds_on_shrink.height(), bounds_auto_resize_enabled.height());
 
   panel->Close();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, ResizePanel) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, ResizePanel) {
   PanelManager* panel_manager = PanelManager::GetInstance();
   panel_manager->enable_auto_sizing(true);
 
   Panel* panel = CreatePanel("TestPanel");
   EXPECT_TRUE(panel->auto_resizable());
   EXPECT_EQ(Panel::EXPANDED, panel->expansion_state());
 
   // Verify resizing turns off auto-resizing and that it works.
   gfx::Rect original_bounds = panel->GetBounds();
   // These should be identical because the panel is expanded.
@@ skipping 12 matching lines @@
   new_size.Enlarge(5, 5);
   new_bounds.set_size(new_size);
   panel->SetBounds(new_bounds);
   EXPECT_EQ(new_bounds.size().width(), panel->GetBounds().width());
   EXPECT_EQ(original_height, panel->GetBounds().height());
   EXPECT_EQ(new_bounds.size(), panel->GetRestoredBounds().size());
 
   panel->Close();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, AnimateBounds) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, AnimateBounds) {
   Panel* panel = CreatePanelWithBounds("PanelTest", gfx::Rect(0, 0, 100, 100));
   scoped_ptr<NativePanelTesting> panel_testing(
       NativePanelTesting::Create(panel->native_panel()));
 
   // Set bounds with animation.
   gfx::Rect bounds = gfx::Rect(10, 20, 150, 160);
   panel->SetPanelBounds(bounds);
   EXPECT_TRUE(panel_testing->IsAnimatingBounds());
   WaitForBoundsAnimationFinished(panel);
   EXPECT_FALSE(panel_testing->IsAnimatingBounds());
   EXPECT_EQ(bounds, panel->GetBounds());
 
   // Set bounds without animation.
   bounds = gfx::Rect(30, 40, 200, 220);
   panel->SetPanelBoundsInstantly(bounds);
   EXPECT_FALSE(panel_testing->IsAnimatingBounds());
   EXPECT_EQ(bounds, panel->GetBounds());
 
   panel->Close();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, RestoredBounds) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, RestoredBounds) {
   // Disable mouse watcher. We don't care about mouse movements in this test.
   PanelManager* panel_manager = PanelManager::GetInstance();
   PanelMouseWatcher* mouse_watcher = new TestPanelMouseWatcher();
   panel_manager->SetMouseWatcherForTesting(mouse_watcher);
   Panel* panel = CreatePanelWithBounds("PanelTest", gfx::Rect(0, 0, 100, 100));
   EXPECT_EQ(Panel::EXPANDED, panel->expansion_state());
   EXPECT_EQ(panel->GetBounds(), panel->GetRestoredBounds());
 
   panel->SetExpansionState(Panel::MINIMIZED);
   EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state());
@@ skipping 40 matching lines @@
   panel->SetExpansionState(Panel::EXPANDED);
   bounds = gfx::Rect(40, 60, 300, 400);
   panel->SetPanelBounds(bounds);
   EXPECT_EQ(saved_restored_height, panel->GetRestoredBounds().height());
   panel->set_full_size(bounds.size());
   EXPECT_NE(saved_restored_height, panel->GetRestoredBounds().height());
 
   panel->Close();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MinimizeRestore) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, MinimizeRestore) {
   // We'll simulate mouse movements for test.
   PanelMouseWatcher* mouse_watcher = new TestPanelMouseWatcher();
   PanelManager::GetInstance()->SetMouseWatcherForTesting(mouse_watcher);
 
   // Test with one panel.
   CreatePanelWithBounds("PanelTest1", gfx::Rect(0, 0, 100, 100));
   TestMinimizeRestore();
 
   PanelManager::GetInstance()->CloseAll();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MinimizeRestoreTwoPanels) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, MinimizeRestoreTwoPanels) {
   // We'll simulate mouse movements for test.
   PanelMouseWatcher* mouse_watcher = new TestPanelMouseWatcher();
   PanelManager::GetInstance()->SetMouseWatcherForTesting(mouse_watcher);
 
   // Test with two panels.
   CreatePanelWithBounds("PanelTest1", gfx::Rect(0, 0, 100, 100));
   CreatePanelWithBounds("PanelTest2", gfx::Rect(0, 0, 110, 110));
   TestMinimizeRestore();
 
   PanelManager::GetInstance()->CloseAll();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MinimizeRestoreThreePanels) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, MinimizeRestoreThreePanels) {
   // We'll simulate mouse movements for test.
   PanelMouseWatcher* mouse_watcher = new TestPanelMouseWatcher();
   PanelManager::GetInstance()->SetMouseWatcherForTesting(mouse_watcher);
 
   // Test with three panels.
   CreatePanelWithBounds("PanelTest1", gfx::Rect(0, 0, 100, 100));
   CreatePanelWithBounds("PanelTest2", gfx::Rect(0, 0, 110, 110));
   CreatePanelWithBounds("PanelTest3", gfx::Rect(0, 0, 120, 120));
   TestMinimizeRestore();
 
   PanelManager::GetInstance()->CloseAll();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MinimizeRestoreButtonClick) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, MinimizeRestoreButtonClick) {
   // Test with three panels.
   Panel* panel1 = CreatePanel("PanelTest1");
   Panel* panel2 = CreatePanel("PanelTest2");
   Panel* panel3 = CreatePanel("PanelTest3");
   EXPECT_FALSE(panel1->IsMinimized());
   EXPECT_FALSE(panel2->IsMinimized());
   EXPECT_FALSE(panel3->IsMinimized());
 
   // Click restore button on an expanded panel. Expect no change.
   panel1->OnRestoreButtonClicked(panel::NO_MODIFIER);
@@ skipping 26 matching lines @@
   EXPECT_FALSE(panel2->IsMinimized());
   EXPECT_TRUE(panel3->IsMinimized());
 
   // Restore all panels by clicking restore button on a minimized panel.
   panel3->OnRestoreButtonClicked(panel::APPLY_TO_ALL);
   EXPECT_FALSE(panel1->IsMinimized());
   EXPECT_FALSE(panel2->IsMinimized());
   EXPECT_FALSE(panel3->IsMinimized());
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, RestoreAllWithTitlebarClick) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, RestoreAllWithTitlebarClick) {
   // We'll simulate mouse movements for test.
   PanelMouseWatcher* mouse_watcher = new TestPanelMouseWatcher();
   PanelManager::GetInstance()->SetMouseWatcherForTesting(mouse_watcher);
 
   // Test with three panels.
   Panel* panel1 = CreatePanel("PanelTest1");
   Panel* panel2 = CreatePanel("PanelTest2");
   Panel* panel3 = CreatePanel("PanelTest3");
   EXPECT_FALSE(panel1->IsMinimized());
   EXPECT_FALSE(panel2->IsMinimized());
@@ skipping 152 matching lines @@
 
 #if defined(OS_MACOSX)
 // This test doesn't pass on Snow Leopard (10.6), although it works just
 // fine on Lion (10.7). The problem is not having a real run loop around
 // the window close is at fault, given how window controllers in Chrome
 // autorelease themselves on a -performSelector:withObject:afterDelay:
 #define MAYBE_ActivatePanelOrTabbedWindow DISABLED_ActivatePanelOrTabbedWindow
 #else
 #define MAYBE_ActivatePanelOrTabbedWindow ActivatePanelOrTabbedWindow
 #endif
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_ActivatePanelOrTabbedWindow) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, MAYBE_ActivatePanelOrTabbedWindow) {
   CreatePanelParams params1("Panel1", gfx::Rect(), SHOW_AS_ACTIVE);
   Panel* panel1 = CreatePanelWithParams(params1);
   CreatePanelParams params2("Panel2", gfx::Rect(), SHOW_AS_ACTIVE);
   Panel* panel2 = CreatePanelWithParams(params2);
 
   // Need tab contents in order to trigger deactivation upon close.
   CreateTestTabContents(panel2->browser());
 
   ASSERT_FALSE(panel1->IsActive());
   ASSERT_TRUE(panel2->IsActive());
@@ skipping 27 matching lines @@
   WaitForPanelActiveState(panel1, SHOW_AS_ACTIVE);
   panel1->Close();
 }
 
 // TODO(jianli): To be enabled for other platforms.
 #if defined(OS_WIN)
 #define MAYBE_ActivateDeactivateBasic ActivateDeactivateBasic
 #else
 #define MAYBE_ActivateDeactivateBasic DISABLED_ActivateDeactivateBasic
 #endif
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_ActivateDeactivateBasic) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, MAYBE_ActivateDeactivateBasic) {
   // Create an active panel.
   Panel* panel = CreatePanel("PanelTest");
   scoped_ptr<NativePanelTesting> native_panel_testing(
       NativePanelTesting::Create(panel->native_panel()));
   EXPECT_TRUE(panel->IsActive());
   EXPECT_TRUE(native_panel_testing->VerifyActiveState(true));
 
   // Deactivate the panel.
   panel->Deactivate();
   WaitForPanelActiveState(panel, SHOW_AS_INACTIVE);
   EXPECT_FALSE(panel->IsActive());
   EXPECT_TRUE(native_panel_testing->VerifyActiveState(false));
 
   // Reactivate the panel.
   panel->Activate();
   WaitForPanelActiveState(panel, SHOW_AS_ACTIVE);
   EXPECT_TRUE(panel->IsActive());
   EXPECT_TRUE(native_panel_testing->VerifyActiveState(true));
 }
 // TODO(jianli): To be enabled for other platforms.
 #if defined(OS_WIN)
 #define MAYBE_ActivateDeactivateMultiple ActivateDeactivateMultiple
 #else
 #define MAYBE_ActivateDeactivateMultiple DISABLED_ActivateDeactivateMultiple
 #endif
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_ActivateDeactivateMultiple) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, MAYBE_ActivateDeactivateMultiple) {
   BrowserWindow* tabbed_window = browser()->window();
 
   // Create 4 panels in the following screen layout:
   //    P3  P2  P1  P0
   const int kNumPanels = 4;
   for (int i = 0; i < kNumPanels; ++i)
     CreatePanelWithBounds(MakePanelName(i), gfx::Rect(0, 0, 100, 100));
   const std::vector<Panel*>& panels = PanelManager::GetInstance()->panels();
 
   std::vector<bool> expected_active_states;
@@ skipping 34 matching lines @@
 
   // Minimizing active panel P0 should activate last active tabbed window.
   panels[0]->SetExpansionState(Panel::MINIMIZED);
   last_active_states = expected_active_states;
   expected_active_states = ProduceExpectedActiveStates(-1);  // -1 means none.
   WaitForPanelActiveStates(last_active_states, expected_active_states);
   EXPECT_EQ(expected_active_states, GetAllPanelActiveStates());
   EXPECT_TRUE(tabbed_window->IsActive());
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionBasic) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, DrawAttentionBasic) {
   CreatePanelParams params("Initially Inactive", gfx::Rect(), SHOW_AS_INACTIVE);
   Panel* panel = CreatePanelWithParams(params);
   scoped_ptr<NativePanelTesting> native_panel_testing(
       NativePanelTesting::Create(panel->native_panel()));
 
   // Test that the attention is drawn when the expanded panel is not in focus.
   EXPECT_EQ(Panel::EXPANDED, panel->expansion_state());
   EXPECT_FALSE(panel->IsActive());
   EXPECT_FALSE(panel->IsDrawingAttention());
   panel->FlashFrame(true);
@@ skipping 16 matching lines @@
   EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state());
 
   // Stop drawing attention. Titlebar should no longer be visible.
   panel->FlashFrame(false);
   EXPECT_FALSE(panel->IsDrawingAttention());
   EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state());
 
   panel->Close();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionWhileMinimized) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, DrawAttentionWhileMinimized) {
   // We'll simulate mouse movements for test.
   PanelMouseWatcher* mouse_watcher = new TestPanelMouseWatcher();
   PanelManager::GetInstance()->SetMouseWatcherForTesting(mouse_watcher);
 
   // Create 2 panels so we end up with an inactive panel that can
   // be made to draw attention.
   Panel* panel = CreatePanel("test panel1");
   Panel* panel2 = CreatePanel("test panel2");
   Panel* panel3 = CreatePanel("test panel2");
 
@@ skipping 31 matching lines @@
   EXPECT_EQ(Panel::EXPANDED, panel->expansion_state());
   EXPECT_FALSE(native_panel_testing->VerifyDrawingAttention());
 
   panel->Close();
   panel2->Close();
   panel3->Close();
 }
 
 // Verify that minimized state of a panel is correct after draw attention
 // is stopped when there are other minimized panels.
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, StopDrawingAttentionWhileMinimized) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest,
+                       StopDrawingAttentionWhileMinimized) {
   // We'll simulate mouse movements for test.
   PanelMouseWatcher* mouse_watcher = new TestPanelMouseWatcher();
   PanelManager::GetInstance()->SetMouseWatcherForTesting(mouse_watcher);
 
   Panel* panel1 = CreatePanel("panel1");
   Panel* panel2 = CreatePanel("panel2");
 
   panel1->Minimize();
   EXPECT_EQ(Panel::MINIMIZED, panel1->expansion_state());
   panel2->Minimize();
@@ skipping 46 matching lines @@
 
   // Move mouse away and panel should go back to fully minimized state.
   MoveMouseAndWaitForExpansionStateChange(panel1, hover_point);
   EXPECT_EQ(Panel::MINIMIZED, panel1->expansion_state());
   EXPECT_EQ(Panel::MINIMIZED, panel2->expansion_state());
 
   panel1->Close();
   panel2->Close();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionWhenActive) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, DrawAttentionWhenActive) {
   CreatePanelParams params("Initially Active", gfx::Rect(), SHOW_AS_ACTIVE);
   Panel* panel = CreatePanelWithParams(params);
   scoped_ptr<NativePanelTesting> native_panel_testing(
       NativePanelTesting::Create(panel->native_panel()));
 
   // Test that the attention should not be drawn if the expanded panel is in
   // focus.
   EXPECT_EQ(Panel::EXPANDED, panel->expansion_state());
   EXPECT_TRUE(panel->IsActive());
   EXPECT_FALSE(panel->IsDrawingAttention());
   panel->FlashFrame(true);
   EXPECT_FALSE(panel->IsDrawingAttention());
   MessageLoop::current()->RunAllPending();
   EXPECT_FALSE(native_panel_testing->VerifyDrawingAttention());
 
   panel->Close();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionResetOnActivate) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, DrawAttentionResetOnActivate) {
   // Create 2 panels so we end up with an inactive panel that can
   // be made to draw attention.
   Panel* panel = CreatePanel("test panel1");
   Panel* panel2 = CreatePanel("test panel2");
 
   scoped_ptr<NativePanelTesting> native_panel_testing(
       NativePanelTesting::Create(panel->native_panel()));
 
   panel->FlashFrame(true);
   EXPECT_TRUE(panel->IsDrawingAttention());
   MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(native_panel_testing->VerifyDrawingAttention());
 
   // Test that the attention is cleared when panel gets focus.
   panel->Activate();
   MessageLoop::current()->RunAllPending();
   WaitForPanelActiveState(panel, SHOW_AS_ACTIVE);
   EXPECT_FALSE(panel->IsDrawingAttention());
   EXPECT_FALSE(native_panel_testing->VerifyDrawingAttention());
 
   panel->Close();
   panel2->Close();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest,
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest,
                        DrawAttentionMinimizedNotResetOnActivate) {
   // Create 2 panels so we end up with an inactive panel that can
   // be made to draw attention.
   Panel* panel1 = CreatePanel("test panel1");
   Panel* panel2 = CreatePanel("test panel2");
 
   panel1->Minimize();
   EXPECT_TRUE(panel1->IsMinimized());
   panel1->FlashFrame(true);
   EXPECT_TRUE(panel1->IsDrawingAttention());
 
   // Simulate panel being activated while minimized. Cannot call
   // Activate() as that expands the panel.
   panel1->OnActiveStateChanged(true);
   EXPECT_TRUE(panel1->IsDrawingAttention());  // Unchanged.
 
   // Unminimize panel to show that attention would have been cleared
   // if panel had not been minimized.
   panel1->Restore();
   EXPECT_FALSE(panel1->IsMinimized());
   EXPECT_TRUE(panel1->IsDrawingAttention());  // Unchanged.
 
   panel1->OnActiveStateChanged(true);
   EXPECT_FALSE(panel1->IsDrawingAttention());  // Attention cleared.
 
   panel1->Close();
   panel2->Close();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionResetOnClick) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, DrawAttentionResetOnClick) {
   CreatePanelParams params("Initially Inactive", gfx::Rect(), SHOW_AS_INACTIVE);
   Panel* panel = CreatePanelWithParams(params);
   scoped_ptr<NativePanelTesting> native_panel_testing(
       NativePanelTesting::Create(panel->native_panel()));
 
   panel->FlashFrame(true);
   EXPECT_TRUE(panel->IsDrawingAttention());
   MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(native_panel_testing->VerifyDrawingAttention());
 
   // Test that the attention is cleared when panel gets focus.
   native_panel_testing->PressLeftMouseButtonTitlebar(
       panel->GetBounds().origin());
   native_panel_testing->ReleaseMouseButtonTitlebar();
 
   MessageLoop::current()->RunAllPending();
   WaitForPanelActiveState(panel, SHOW_AS_ACTIVE);
   EXPECT_FALSE(panel->IsDrawingAttention());
   EXPECT_FALSE(native_panel_testing->VerifyDrawingAttention());
 
   panel->Close();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest,
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest,
                        MinimizeImmediatelyAfterRestore) {
   CreatePanelParams params("Panel Test", gfx::Rect(), SHOW_AS_ACTIVE);
   Panel* panel = CreatePanelWithParams(params);
   scoped_ptr<NativePanelTesting> native_panel_testing(
       NativePanelTesting::Create(panel->native_panel()));
 
   panel->Minimize();  // this should deactivate.
   MessageLoop::current()->RunAllPending();
   WaitForPanelActiveState(panel, SHOW_AS_INACTIVE);
   EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state());
 
   panel->Restore();
   MessageLoop::current()->RunAllPending();
   WaitForExpansionStateChanged(panel, Panel::EXPANDED);
 
   // Verify that minimizing a panel right after expansion works.
   panel->Minimize();
   MessageLoop::current()->RunAllPending();
   WaitForExpansionStateChanged(panel, Panel::MINIMIZED);
 
   panel->Close();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, FocusLostOnMinimize) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, FocusLostOnMinimize) {
   CreatePanelParams params("Initially Active", gfx::Rect(), SHOW_AS_ACTIVE);
   Panel* panel = CreatePanelWithParams(params);
   EXPECT_EQ(Panel::EXPANDED, panel->expansion_state());
 
   panel->SetExpansionState(Panel::MINIMIZED);
   MessageLoop::current()->RunAllPending();
   WaitForPanelActiveState(panel, SHOW_AS_INACTIVE);
   panel->Close();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, CreateInactiveSwitchToActive) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, CreateInactiveSwitchToActive) {
   // Compiz will not activate initially inactive window.
   if (SkipTestIfCompizWM())
     return;
 
   CreatePanelParams params("Initially Inactive", gfx::Rect(), SHOW_AS_INACTIVE);
   Panel* panel = CreatePanelWithParams(params);
 
   panel->Activate();
   WaitForPanelActiveState(panel, SHOW_AS_ACTIVE);
 
   panel->Close();
 }
 
 // TODO(dimich): try/enable on other platforms. See bug 103253 for details on
 // why this is disabled on windows.
 #if defined(OS_MACOSX)
 #define MAYBE_MinimizeTwoPanelsWithoutTabbedWindow \
     MinimizeTwoPanelsWithoutTabbedWindow
 #else
 #define MAYBE_MinimizeTwoPanelsWithoutTabbedWindow \
     DISABLED_MinimizeTwoPanelsWithoutTabbedWindow
 #endif
 
 // When there are 2 panels and no chrome window, minimizing one panel does
 // not expand/focuses another.
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest,
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest,
                        MAYBE_MinimizeTwoPanelsWithoutTabbedWindow) {
   CreatePanelParams params("Initially Inactive", gfx::Rect(), SHOW_AS_INACTIVE);
   Panel* panel1 = CreatePanelWithParams(params);
   Panel* panel2 = CreatePanelWithParams(params);
 
   // Close main tabbed window.
   ui_test_utils::WindowedNotificationObserver signal(
       chrome::NOTIFICATION_BROWSER_CLOSED,
       content::Source<Browser>(browser()));
   browser()->CloseWindow();
@@ skipping 19 matching lines @@
   EXPECT_EQ(Panel::MINIMIZED, panel1->expansion_state());
 
   // Another check for the same.
   EXPECT_FALSE(panel1->IsActive());
   EXPECT_FALSE(panel2->IsActive());
 
   panel1->Close();
   panel2->Close();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest,
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest,
                        NonExtensionDomainPanelsCloseOnUninstall) {
   // Create a test extension.
   DictionaryValue empty_value;
   scoped_refptr<Extension> extension =
       CreateExtension(FILE_PATH_LITERAL("TestExtension"),
       Extension::INVALID, empty_value);
   std::string extension_app_name =
       web_app::GenerateApplicationNameFromExtensionId(extension->id());
 
   PanelManager* panel_manager = PanelManager::GetInstance();
@@ skipping 40 matching lines @@
 
   // Wait for the panels opened by the first extension to close.
   signal.Wait();
   signal1.Wait();
 
   // Verify that the panel that's left is the panel from the second extension.
   EXPECT_EQ(panel_other, panel_manager->panels()[0]);
   panel_other->Close();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, OnBeforeUnloadOnClose) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, OnBeforeUnloadOnClose) {
   PanelManager* panel_manager = PanelManager::GetInstance();
   EXPECT_EQ(0, panel_manager->num_panels()); // No panels initially.
 
   const string16 title_first_close = UTF8ToUTF16("TitleFirstClose");
   const string16 title_second_close = UTF8ToUTF16("TitleSecondClose");
 
   // Create a test panel with tab contents loaded.
   CreatePanelParams params("PanelTest1", gfx::Rect(0, 0, 300, 300),
                            SHOW_AS_ACTIVE);
   params.url = ui_test_utils::GetTestUrl(
@@ skipping 31 matching lines @@
   panel->Close();
   alert = ui_test_utils::WaitForAppModalDialog();
   alert->native_dialog()->AcceptAppModalDialog();
   signal.Wait();
   EXPECT_EQ(0, panel_manager->num_panels());
 }
 
 // http://crbug.com/126381 - should find a better notification to wait
 // for resize completion. Bounds animation could happen for all sorts of
 // reasons.
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DISABLED_CreateWithExistingContents) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest,
+                       DISABLED_CreateWithExistingContents) {
   PanelManager::GetInstance()->enable_auto_sizing(true);
 
   // Load contents into regular tabbed browser.
   GURL url(ui_test_utils::GetTestUrl(
       FilePath(kTestDir),
       FilePath(FILE_PATH_LITERAL("update-preferred-size.html"))));
   ui_test_utils::NavigateToURL(browser(), url);
   EXPECT_EQ(1, browser()->tab_count());
 
   Profile* profile = browser()->profile();
@@ skipping 31 matching lines @@
       content::Source<Panel>(panel));
   panel_browser->ConvertPopupToTabbedBrowser();
   signal.Wait();
   EXPECT_EQ(0, PanelManager::GetInstance()->num_panels());
 
   Browser* tabbed_browser = browser::FindTabbedBrowser(profile, false);
   EXPECT_EQ(contents, tabbed_browser->GetSelectedTabContentsWrapper());
   tabbed_browser->window()->Close();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, SizeClamping) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, SizeClamping) {
   // Using '0' sizes is equivalent of not providing sizes in API and causes
   // minimum sizes to be applied to facilitate auto-sizing.
   CreatePanelParams params("Panel", gfx::Rect(), SHOW_AS_ACTIVE);
   Panel* panel = CreatePanelWithParams(params);
   EXPECT_EQ(panel->min_size().width(), panel->GetBounds().width());
   EXPECT_EQ(panel->min_size().height(), panel->GetBounds().height());
   int reasonable_width = panel->min_size().width() + 10;
   int reasonable_height = panel->min_size().height() + 20;
 
   panel->Close();
@@ skipping 11 matching lines @@
   // Using just one size should auto-compute some reasonable other size.
   int given_height = 200;
   CreatePanelParams params2("Panel2", gfx::Rect(0, 0, 0, given_height),
                             SHOW_AS_ACTIVE);
   panel = CreatePanelWithParams(params2);
   EXPECT_GT(panel->GetBounds().width(), 0);
   EXPECT_EQ(given_height, panel->GetBounds().height());
   panel->Close();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, TightAutosizeAroundSingleLine) {
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest, TightAutosizeAroundSingleLine) {
   PanelManager::GetInstance()->enable_auto_sizing(true);
   // Using 0 sizes triggers auto-sizing.
   CreatePanelParams params("Panel", gfx::Rect(), SHOW_AS_ACTIVE);
   params.url = GURL("data:text/html;charset=utf-8,<!doctype html><body>");
   Panel* panel = CreatePanelWithParams(params);
 
   int initial_width = panel->GetBounds().width();
   int initial_height = panel->GetBounds().height();
 
   // Inject some HTML content into the panel.
   ui_test_utils::WindowedNotificationObserver enlarge(
       chrome::NOTIFICATION_PANEL_BOUNDS_ANIMATIONS_FINISHED,
       content::Source<Panel>(panel));
   EXPECT_TRUE(ui_test_utils::ExecuteJavaScript(
       panel->WebContents()->GetRenderViewHost(),
       std::wstring(),
       L"document.body.innerHTML ="
       L"'<nobr>line of text and a <button>Button</button>';"));
   enlarge.Wait();
 
   // The panel should have become larger in both dimensions (the minimums
   // has to be set to be smaller then a simple 1-line content, so the autosize
   // can work correctly.
   EXPECT_GT(panel->GetBounds().width(), initial_width);
   EXPECT_GT(panel->GetBounds().height(), initial_height);
 
   panel->Close();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest,
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest,
                        DefaultMaxSizeOnDisplaySettingsChange) {
   Panel* panel = CreatePanelWithBounds("1", gfx::Rect(0, 0, 240, 220));
 
   gfx::Size old_max_size = panel->max_size();
   gfx::Size old_full_size = panel->full_size();
 
   // Shrink the work area. Expect max size and full size become smaller.
   gfx::Size smaller_work_area_size = gfx::Size(500, 300);
   SetTestingAreas(gfx::Rect(gfx::Point(0, 0), smaller_work_area_size),
                   gfx::Rect());
   EXPECT_GT(old_max_size.width(), panel->max_size().width());
   EXPECT_GT(old_max_size.height(), panel->max_size().height());
   EXPECT_GT(smaller_work_area_size.width(), panel->max_size().width());
   EXPECT_GT(smaller_work_area_size.height(), panel->max_size().height());
   EXPECT_GT(old_full_size.width(), panel->full_size().width());
   EXPECT_GT(old_full_size.height(), panel->full_size().height());
   EXPECT_GE(panel->max_size().width(), panel->full_size().width());
   EXPECT_GE(panel->max_size().height(), panel->full_size().height());
 
   panel->Close();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest,
+IN_PROC_BROWSER_TEST_F(OldPanelBrowserTest,
                        CustomMaxSizeOnDisplaySettingsChange) {
   PanelManager* panel_manager = PanelManager::GetInstance();
   Panel* panel = CreatePanelWithBounds("1", gfx::Rect(0, 0, 240, 220));
 
   // Trigger custom max size by user resizing.
   gfx::Size bigger_size = gfx::Size(550, 400);
   gfx::Point mouse_location = panel->GetBounds().origin();
   panel_manager->StartResizingByMouse(panel,
                                       mouse_location,
                                       panel::RESIZE_TOP_LEFT);
@@ skipping 17 matching lines @@
   EXPECT_EQ(smaller_work_area_size.height(), panel->max_size().height());
   EXPECT_GT(old_full_size.width(), panel->full_size().width());
   EXPECT_GT(old_full_size.height(), panel->full_size().height());
   EXPECT_GE(panel->max_size().width(), panel->full_size().width());
   EXPECT_GE(panel->max_size().height(), panel->full_size().height());
   EXPECT_EQ(smaller_work_area_size.height(), panel->full_size().height());
 
   panel->Close();
 }
 
-class PanelDownloadTest : public PanelBrowserTest {
+class OldPanelDownloadTest : public OldPanelBrowserTest {
  public:
-  PanelDownloadTest() : PanelBrowserTest() { }
+  OldPanelDownloadTest() : OldPanelBrowserTest() { }
 
   // Creates a temporary directory for downloads that is auto-deleted
   // on destruction.
   bool CreateDownloadDirectory(Profile* profile) {
     bool created = downloads_directory_.CreateUniqueTempDir();
     if (!created)
       return false;
     profile->GetPrefs()->SetFilePath(
         prefs::kDownloadDefaultDirectory,
         downloads_directory_.path());
     return true;
   }
 
  protected:
   void SetUpOnMainThread() OVERRIDE {
-    PanelBrowserTest::SetUpOnMainThread();
+    OldPanelBrowserTest::SetUpOnMainThread();
 
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&chrome_browser_net::SetUrlRequestMocksEnabled, true));
   }
 
  private:
   // Location of the downloads directory for download tests.
   ScopedTempDir downloads_directory_;
 };
@@ skipping 39 matching lines @@
   }
 
  private:
   DownloadManager* download_manager_;
   bool saw_download_;
   bool waiting_;
 };
 
 // Verify that the download shelf is opened in the existing tabbed browser
 // when a download is started in a Panel.
-IN_PROC_BROWSER_TEST_F(PanelDownloadTest, Download) {
+IN_PROC_BROWSER_TEST_F(OldPanelDownloadTest, Download) {
   Profile* profile = browser()->profile();
   ASSERT_TRUE(CreateDownloadDirectory(profile));
   Browser* panel_browser = Browser::CreateWithParams(
       Browser::CreateParams::CreateForApp(
           Browser::TYPE_PANEL, "PanelTest", gfx::Rect(), profile));
   EXPECT_EQ(2U, BrowserList::size());
   ASSERT_FALSE(browser()->window()->IsDownloadShelfVisible());
   ASSERT_FALSE(panel_browser->window()->IsDownloadShelfVisible());
 
   scoped_ptr<DownloadObserver> observer(new DownloadObserver(profile));
@@ skipping 32 matching lines @@
 
 // See crbug 113779.
 #if defined(OS_MACOSX)
 #define MAYBE_DownloadNoTabbedBrowser DISABLED_DownloadNoTabbedBrowser
 #else
 #define MAYBE_DownloadNoTabbedBrowser DownloadNoTabbedBrowser
 #endif
 // Verify that a new tabbed browser is created to display a download
 // shelf when a download is started in a Panel and there is no existing
 // tabbed browser.
-IN_PROC_BROWSER_TEST_F(PanelDownloadTest, MAYBE_DownloadNoTabbedBrowser) {
+IN_PROC_BROWSER_TEST_F(OldPanelDownloadTest, MAYBE_DownloadNoTabbedBrowser) {
   Profile* profile = browser()->profile();
   ASSERT_TRUE(CreateDownloadDirectory(profile));
   Browser* panel_browser = Browser::CreateWithParams(
       Browser::CreateParams::CreateForApp(
           Browser::TYPE_PANEL, "PanelTest", gfx::Rect(), profile));
   EXPECT_EQ(2U, BrowserList::size());
   ASSERT_FALSE(browser()->window()->IsDownloadShelfVisible());
   ASSERT_FALSE(panel_browser->window()->IsDownloadShelfVisible());
 
   ui_test_utils::WindowedNotificationObserver signal(
@@ skipping 19 matching lines @@
   Browser* tabbed_browser = browser::FindTabbedBrowser(profile, false);
   EXPECT_EQ(1, tabbed_browser->tab_count());
   ASSERT_TRUE(tabbed_browser->window()->IsDownloadShelfVisible());
   tabbed_browser->CloseWindow();
 
   EXPECT_EQ(1, panel_browser->tab_count());
   ASSERT_FALSE(panel_browser->window()->IsDownloadShelfVisible());
 
   panel_browser->CloseWindow();
 }