Update panel layout immediately after the user has finished resizing a panel.

chrome/browser/ui/panels/panel_resize_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 "chrome/browser/ui/panels/base_panel_browser_test.h"
 #include "chrome/browser/ui/panels/detached_panel_collection.h"
 #include "chrome/browser/ui/panels/panel.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/panels/panel_resize_controller.h"
 #include "chrome/browser/ui/panels/stacked_panel_collection.h"
+#include "ui/base/hit_test.h"
 
 class PanelResizeBrowserTest : public BasePanelBrowserTest {
  public:
   PanelResizeBrowserTest() : BasePanelBrowserTest() {
   }
 
   virtual ~PanelResizeBrowserTest() {
   }
 
   virtual void SetUpOnMainThread() OVERRIDE {
     BasePanelBrowserTest::SetUpOnMainThread();
 
     // All the tests here assume using mocked 800x600 display area for the
     // primary monitor. Do the check now.
     gfx::Rect primary_display_area = PanelManager::GetInstance()->
         display_settings_provider()->GetPrimaryDisplayArea();
     DCHECK(primary_display_area.width() == 800);
     DCHECK(primary_display_area.height() == 600);
   }
 
   void ResizePanel(Panel* panel,
-                   panel::ResizingSides sides,
+                   int component,
                    const gfx::Vector2d& delta) {
     PanelManager* panel_manager = PanelManager::GetInstance();
     gfx::Rect bounds = panel->GetBounds();
     gfx::Point mouse_location;
-    switch (sides) {
-      case panel::RESIZE_TOP_LEFT:
+    switch (component) {
+      case HTTOPLEFT:
         mouse_location = bounds.origin();
         break;
-      case panel::RESIZE_TOP:
+      case HTTOP:
         mouse_location.SetPoint(bounds.x() + bounds.width() / 2, bounds.y());
         break;
-      case panel::RESIZE_TOP_RIGHT:
+      case HTTOPRIGHT:
         mouse_location.SetPoint(bounds.right(), bounds.y());
         break;
-      case panel::RESIZE_LEFT:
+      case HTLEFT:
         mouse_location.SetPoint(bounds.x(), bounds.y() + bounds.height() / 2);
         break;
-      case panel::RESIZE_RIGHT:
+      case HTRIGHT:
         mouse_location.SetPoint(bounds.right(),
                                 bounds.y() + bounds.height() / 2);
         break;
-      case panel::RESIZE_BOTTOM_LEFT:
+      case HTBOTTOMLEFT:
         mouse_location.SetPoint(bounds.x(), bounds.bottom());
         break;
-      case panel::RESIZE_BOTTOM:
+      case HTBOTTOM:
         mouse_location.SetPoint(bounds.x() + bounds.width() / 2,
                                 bounds.bottom());
         break;
-      case panel::RESIZE_BOTTOM_RIGHT:
+      case HTBOTTOMRIGHT:
         mouse_location.SetPoint(bounds.right(), bounds.bottom());
         break;
       default:
         NOTREACHED();
         break;
     }
-    panel_manager->StartResizingByMouse(panel, mouse_location, sides);
+    panel_manager->StartResizingByMouse(panel, mouse_location, component);
     mouse_location += delta;
     panel_manager->ResizeByMouse(mouse_location);
     panel_manager->EndResizingByMouse(false);
   }
 };
 
 // http://crbug.com/175760; several panel tests failing regularly on mac.
 #if defined(OS_MACOSX)
 #define MAYBE_DockedPanelResizability DISABLED_DockedPanelResizability
 #else
 #define MAYBE_DockedPanelResizability DockedPanelResizability
 #endif
 IN_PROC_BROWSER_TEST_F(PanelResizeBrowserTest, MAYBE_DockedPanelResizability) {
   PanelManager* panel_manager = PanelManager::GetInstance();
   Panel* panel = CreatePanel("Panel");
 
   EXPECT_EQ(panel::RESIZABLE_EXCEPT_BOTTOM, panel->CanResizeByMouse());
 
   gfx::Rect bounds = panel->GetBounds();
 
   // Try resizing by the top left corner.
   gfx::Point mouse_location = bounds.origin();
-  panel_manager->StartResizingByMouse(panel, mouse_location,
-                                      panel::RESIZE_TOP_LEFT);
+  panel_manager->StartResizingByMouse(panel, mouse_location, HTTOPLEFT);
   mouse_location.Offset(-20, -10);
   panel_manager->ResizeByMouse(mouse_location);
 
   bounds.set_size(gfx::Size(bounds.width() + 20, bounds.height() + 10));
   bounds.Offset(-20, -10);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   panel_manager->EndResizingByMouse(false);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   // Try resizing by the top.
   mouse_location = bounds.origin() + gfx::Vector2d(10, 1);
-  panel_manager->StartResizingByMouse(panel, mouse_location,
-                                      panel::RESIZE_TOP);
+  panel_manager->StartResizingByMouse(panel, mouse_location, HTTOP);
   mouse_location.Offset(5, -10);
   panel_manager->ResizeByMouse(mouse_location);
 
   bounds.set_height(bounds.height() + 10);
   bounds.Offset(0, -10);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   panel_manager->EndResizingByMouse(false);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   // Try resizing by the left side.
   mouse_location = bounds.origin() + gfx::Vector2d(1, 30);
-  panel_manager->StartResizingByMouse(panel, mouse_location,
-                                      panel::RESIZE_LEFT);
+  panel_manager->StartResizingByMouse(panel, mouse_location, HTLEFT);
   mouse_location.Offset(-5, 25);
   panel_manager->ResizeByMouse(mouse_location);
 
   bounds.set_width(bounds.width() + 5);
   bounds.Offset(-5, 0);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   panel_manager->EndResizingByMouse(false);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   // Try resizing by the top right side.
   mouse_location = bounds.origin() + gfx::Vector2d(bounds.width() - 1, 2);
-  panel_manager->StartResizingByMouse(panel, mouse_location,
-                                      panel::RESIZE_TOP_RIGHT);
+  panel_manager->StartResizingByMouse(panel, mouse_location, HTTOPRIGHT);
   mouse_location.Offset(30, 20);
   panel_manager->ResizeByMouse(mouse_location);
 
   bounds.set_size(gfx::Size(bounds.width() + 30, bounds.height() - 20));
   bounds.Offset(0, 20);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   panel_manager->EndResizingByMouse(false);
   WaitForBoundsAnimationFinished(panel);
   bounds.Offset(-30, 0);  // Layout of panel adjusted in docked collection.
   EXPECT_EQ(bounds, panel->GetBounds());
 
   // Try resizing by the right side.
   mouse_location = bounds.origin() + gfx::Vector2d(bounds.width() - 1, 30);
-  panel_manager->StartResizingByMouse(panel, mouse_location,
-                                      panel::RESIZE_RIGHT);
+  panel_manager->StartResizingByMouse(panel, mouse_location, HTRIGHT);
   mouse_location.Offset(5, 25);
   panel_manager->ResizeByMouse(mouse_location);
 
   bounds.set_width(bounds.width() + 5);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   panel_manager->EndResizingByMouse(false);
   WaitForBoundsAnimationFinished(panel);
   bounds.Offset(-5, 0);  // Layout of panel adjusted in docked collection.
   EXPECT_EQ(bounds, panel->GetBounds());
 
   // Try resizing by the bottom side; verify resize won't work.
   mouse_location = bounds.origin() + gfx::Vector2d(10, bounds.height() - 1);
-  panel_manager->StartResizingByMouse(panel, mouse_location,
-                                      panel::RESIZE_BOTTOM);
+  panel_manager->StartResizingByMouse(panel, mouse_location, HTBOTTOM);
   mouse_location.Offset(30, -10);
   panel_manager->ResizeByMouse(mouse_location);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   panel_manager->EndResizingByMouse(false);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   // Try resizing by the bottom left corner; verify resize won't work.
   mouse_location = bounds.origin() + gfx::Vector2d(1, bounds.height() - 1);
-  panel_manager->StartResizingByMouse(panel, mouse_location,
-                                      panel::RESIZE_BOTTOM_LEFT);
+  panel_manager->StartResizingByMouse(panel, mouse_location, HTBOTTOMLEFT);
   mouse_location.Offset(-10, 15);
   panel_manager->ResizeByMouse(mouse_location);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   panel_manager->EndResizingByMouse(false);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   // Try resizing by the bottom right corner; verify resize won't work.
   mouse_location = bounds.origin() +
       gfx::Vector2d(bounds.width() - 2, bounds.height());
-  panel_manager->StartResizingByMouse(panel, mouse_location,
-                                      panel::RESIZE_BOTTOM_RIGHT);
+  panel_manager->StartResizingByMouse(panel, mouse_location, HTBOTTOMRIGHT);
   mouse_location.Offset(20, 10);
   panel_manager->ResizeByMouse(mouse_location);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   panel_manager->EndResizingByMouse(false);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   panel->Close();
 }
 
 // http://crbug.com/175760; several panel tests failing regularly on mac.
 #if defined(OS_MACOSX)
 #define MAYBE_ResizeDetachedPanel DISABLED_ResizeDetachedPanel
 #else
 #define MAYBE_ResizeDetachedPanel ResizeDetachedPanel
 #endif
 IN_PROC_BROWSER_TEST_F(PanelResizeBrowserTest, MAYBE_ResizeDetachedPanel) {
   PanelManager* panel_manager = PanelManager::GetInstance();
   Panel* panel = CreateDetachedPanel("Panel", gfx::Rect(300, 200, 150, 100));
 
   EXPECT_EQ(panel::RESIZABLE_ALL, panel->CanResizeByMouse());
 
   gfx::Rect bounds = panel->GetBounds();
 
   // Try resizing by the right side; verify resize will change width only.
   gfx::Point mouse_location = bounds.origin() +
       gfx::Vector2d(bounds.width() - 1, 30);
-  panel_manager->StartResizingByMouse(panel, mouse_location,
-                                      panel::RESIZE_RIGHT);
+  panel_manager->StartResizingByMouse(panel, mouse_location, HTRIGHT);
   mouse_location.Offset(5, 25);
   panel_manager->ResizeByMouse(mouse_location);
 
   bounds.set_width(bounds.width() + 5);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   panel_manager->EndResizingByMouse(false);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   // Try resizing by the bottom left side.
   mouse_location = bounds.origin() + gfx::Vector2d(1, bounds.height() - 1);
-  panel_manager->StartResizingByMouse(panel, mouse_location,
-                                      panel::RESIZE_BOTTOM_LEFT);
+  panel_manager->StartResizingByMouse(panel, mouse_location, HTBOTTOMLEFT);
   mouse_location.Offset(-10, 15);
   panel_manager->ResizeByMouse(mouse_location);
 
   bounds.set_size(gfx::Size(bounds.width() + 10, bounds.height() + 15));
   bounds.Offset(-10, 0);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   panel_manager->EndResizingByMouse(false);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   // Try resizing by the top right side.
   mouse_location = bounds.origin() + gfx::Vector2d(bounds.width() - 1, 2);
-  panel_manager->StartResizingByMouse(panel, mouse_location,
-                                      panel::RESIZE_TOP_RIGHT);
+  panel_manager->StartResizingByMouse(panel, mouse_location, HTTOPRIGHT);
   mouse_location.Offset(30, 20);
   panel_manager->ResizeByMouse(mouse_location);
 
   bounds.set_size(gfx::Size(bounds.width() + 30, bounds.height() - 20));
   bounds.Offset(0, 20);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   panel_manager->EndResizingByMouse(false);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   // Try resizing by the top left side.
   mouse_location = bounds.origin() + gfx::Vector2d(1, 0);
-  panel_manager->StartResizingByMouse(panel, mouse_location,
-                                      panel::RESIZE_TOP_LEFT);
+  panel_manager->StartResizingByMouse(panel, mouse_location, HTTOPLEFT);
   mouse_location.Offset(-20, -10);
   panel_manager->ResizeByMouse(mouse_location);
 
   bounds.set_size(gfx::Size(bounds.width() + 20, bounds.height() + 10));
   bounds.Offset(-20, -10);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   panel_manager->EndResizingByMouse(false);
   EXPECT_EQ(bounds, panel->GetBounds());
 
@@ skipping 12 matching lines @@
   int initial_width = 150;
   int initial_height = 100;
   Panel* panel = CreateDetachedPanel("1",
       gfx::Rect(300, 200, initial_width, initial_height));
 
   // Try to resize the panel below the minimum size. Expect that the panel
   // shrinks to the minimum size.
   int resize_width = panel::kPanelMinWidth / 2 - initial_width;
   int resize_height = panel::kPanelMinHeight / 2 - initial_height;
   ResizePanel(panel,
-              panel::RESIZE_BOTTOM_RIGHT,
+              HTBOTTOMRIGHT,
               gfx::Vector2d(resize_width, resize_height));
 
   EXPECT_EQ(panel::kPanelMinWidth, panel->GetBounds().width());
   EXPECT_EQ(panel::kPanelMinHeight, panel->GetBounds().height());
 
   PanelManager::GetInstance()->CloseAll();
 }
 
 // http://crbug.com/175760; several panel tests failing regularly on mac.
 #if defined(OS_MACOSX)
 #define MAYBE_ResizeDetachedPanelToClampSize \
   DISABLED_ResizeDetachedPanelToClampSize
 #else
 #define MAYBE_ResizeDetachedPanelToClampSize ResizeDetachedPanelToClampSize
 #endif
 IN_PROC_BROWSER_TEST_F(PanelResizeBrowserTest,
                        MAYBE_ResizeDetachedPanelToClampSize) {
   PanelManager* panel_manager = PanelManager::GetInstance();
   Panel* panel = CreateDetachedPanel("Panel", gfx::Rect(300, 200, 150, 100));
 
   EXPECT_EQ(panel::RESIZABLE_ALL, panel->CanResizeByMouse());
 
   gfx::Rect bounds = panel->GetBounds();
 
   // Make sure the panel does not resize smaller than its min size.
   gfx::Point mouse_location = bounds.origin() +
       gfx::Vector2d(30, bounds.height() - 2);
-  panel_manager->StartResizingByMouse(panel, mouse_location,
-                                      panel::RESIZE_BOTTOM);
+  panel_manager->StartResizingByMouse(panel, mouse_location, HTBOTTOM);
   mouse_location.Offset(-20, -500);
   panel_manager->ResizeByMouse(mouse_location);
 
   bounds.set_height(panel->min_size().height());
   EXPECT_EQ(bounds, panel->GetBounds());
 
   panel_manager->EndResizingByMouse(false);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   // Make sure the panel can resize larger than its size. User is in control.
   mouse_location = bounds.origin() +
       gfx::Vector2d(bounds.width(), bounds.height() - 2);
-  panel_manager->StartResizingByMouse(panel, mouse_location,
-                                      panel::RESIZE_BOTTOM_RIGHT);
+  panel_manager->StartResizingByMouse(panel, mouse_location, HTBOTTOMRIGHT);
 
   // This drag would take us beyond max size.
   int delta_x = panel->max_size().width() + 10 - panel->GetBounds().width();
   int delta_y = panel->max_size().height() + 10 - panel->GetBounds().height();
   mouse_location.Offset(delta_x, delta_y);
   panel_manager->ResizeByMouse(mouse_location);
 
   // The bounds if the max_size does not limit the resize.
   bounds.set_size(gfx::Size(bounds.width() + delta_x,
                             bounds.height() + delta_y));
@@ skipping 25 matching lines @@
   ASSERT_EQ(3, detached_collection->num_panels());
 
   gfx::Rect panel1_bounds = panel1->GetBounds();
   gfx::Rect panel2_bounds = panel2->GetBounds();
   gfx::Rect panel3_bounds = panel3->GetBounds();
 
   // Start resizing panel1, and close panel2 in the process.
   // Panel1 is not affected.
   gfx::Point mouse_location = panel1_bounds.origin() +
       gfx::Vector2d(1, panel1_bounds.height() - 1);
-  panel_manager->StartResizingByMouse(panel1, mouse_location,
-                                      panel::RESIZE_BOTTOM_LEFT);
+  panel_manager->StartResizingByMouse(panel1, mouse_location, HTBOTTOMLEFT);
   mouse_location.Offset(-10, 15);
   panel_manager->ResizeByMouse(mouse_location);
 
   panel1_bounds.set_size(gfx::Size(panel1_bounds.width() + 10,
                                    panel1_bounds.height() + 15));
   panel1_bounds.Offset(-10, 0);
   EXPECT_EQ(panel1_bounds, panel1->GetBounds());
 
   CloseWindowAndWait(panel2);
   EXPECT_TRUE(resize_controller->IsResizing());
   EXPECT_EQ(2, detached_collection->num_panels());
 
   panel_manager->EndResizingByMouse(false);
   EXPECT_EQ(panel1_bounds, panel1->GetBounds());
 
   // Start resizing panel3, and close it in the process.
   // Resize should abort, panel1 will not be affected.
   mouse_location = panel3_bounds.origin() +
       gfx::Vector2d(panel3_bounds.width() - 1, panel3_bounds.height() - 2);
-  panel_manager->StartResizingByMouse(panel3, mouse_location,
-                                      panel::RESIZE_BOTTOM_RIGHT);
+  panel_manager->StartResizingByMouse(panel3, mouse_location, HTBOTTOMRIGHT);
   mouse_location.Offset(7, -12);
   panel_manager->ResizeByMouse(mouse_location);
 
   panel3_bounds.set_size(gfx::Size(panel3_bounds.width() + 7,
                                    panel3_bounds.height() - 12));
   EXPECT_EQ(panel3_bounds, panel3->GetBounds());
 
   CloseWindowAndWait(panel3);
   EXPECT_EQ(1, detached_collection->num_panels());
   // Since we closed the panel we were resizing, we should be out of the
@@ skipping 20 matching lines @@
 
   EXPECT_EQ(panel::RESIZABLE_ALL, panel->CanResizeByMouse());
 
   gfx::Rect original_bounds = panel->GetBounds();
 
   // Resizing the panel, then cancelling should return it to the original state.
   // Try resizing by the top right side.
   gfx::Rect bounds = panel->GetBounds();
   gfx::Point mouse_location = bounds.origin() +
       gfx::Vector2d(bounds.width() - 1, 1);
-  panel_manager->StartResizingByMouse(panel, mouse_location,
-                                      panel::RESIZE_TOP_RIGHT);
+  panel_manager->StartResizingByMouse(panel, mouse_location, HTTOPRIGHT);
   mouse_location.Offset(5, 25);
   panel_manager->ResizeByMouse(mouse_location);
 
   bounds.set_size(gfx::Size(bounds.width() + 5, bounds.height() - 25));
   bounds.Offset(0, 25);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   panel_manager->EndResizingByMouse(true);
   EXPECT_EQ(original_bounds, panel->GetBounds());
 
   // Try resizing by the bottom left side.
   bounds = panel->GetBounds();
   mouse_location = bounds.origin() + gfx::Vector2d(1, bounds.height() - 1);
-  panel_manager->StartResizingByMouse(panel, mouse_location,
-                                      panel::RESIZE_BOTTOM_LEFT);
+  panel_manager->StartResizingByMouse(panel, mouse_location, HTBOTTOMLEFT);
   mouse_location.Offset(-10, 15);
   panel_manager->ResizeByMouse(mouse_location);
 
   bounds.set_size(gfx::Size(bounds.width() + 10, bounds.height() + 15));
   bounds.Offset(-10, 0);
   EXPECT_EQ(bounds, panel->GetBounds());
 
   panel_manager->EndResizingByMouse(true);
   EXPECT_EQ(original_bounds, panel->GetBounds());
   EXPECT_FALSE(resize_controller->IsResizing());
@@ skipping 15 matching lines @@
       primary_display_area, primary_work_area);
 
   PanelManager* panel_manager = PanelManager::GetInstance();
   Panel* panel = CreateDetachedPanel("1", gfx::Rect(300, 200, 250, 200));
   gfx::Rect bounds = panel->GetBounds();
 
   // Try resizing by the top left corner.
   gfx::Point mouse_location = bounds.origin();
   panel_manager->StartResizingByMouse(panel,
                                       mouse_location,
-                                      panel::RESIZE_TOP_LEFT);
+                                      HTTOPLEFT);
 
   // Try moving the mouse outside the top of the work area. Expect that panel's
   // top position will not exceed the top of the work area.
   mouse_location = gfx::Point(250, 2);
   panel_manager->ResizeByMouse(mouse_location);
 
   bounds.set_width(bounds.width() + bounds.x() - mouse_location.x());
   bounds.set_height(bounds.height() + bounds.y() - primary_work_area.y());
   bounds.set_x(mouse_location.x());
   bounds.set_y(primary_work_area.y());
@@ skipping 56 matching lines @@
                                    panel2_expected_bounds.width(),
                                    panel3_initial_bounds.height());
   EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds());
 
   // Resize by the top-left corner of the top panel.
   // Expect that the width of all stacked panels get increased by the same
   // amount and the top panel also expands in height.
   int top_resize_width = 15;
   int top_resize_height = 10;
   ResizePanel(panel1,
-              panel::RESIZE_TOP_LEFT,
+              HTTOPLEFT,
               gfx::Vector2d(-top_resize_width, -top_resize_height));
 
   panel1_expected_full_size.Enlarge(top_resize_width, top_resize_height);
   EXPECT_EQ(panel1_expected_full_size, panel1->full_size());
   panel2_expected_full_size.Enlarge(top_resize_width, 0);
   EXPECT_EQ(panel2_expected_full_size, panel2->full_size());
   panel3_expected_full_size.Enlarge(top_resize_width, 0);
   EXPECT_EQ(panel3_expected_full_size, panel3->full_size());
 
   panel1_expected_bounds.SetRect(
@@ skipping 10 matching lines @@
   panel3_expected_bounds.set_width(
       panel3_expected_bounds.width() + top_resize_width);
   EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds());
 
   // Resize by the bottom-right corner of the bottom panel.
   // Expect that the width of all stacked panels get increased by the same
   // amount and the bottom panel also shrinks in height.
   int bottom_resize_width = 12;
   int bottom_resize_height = 8;
   ResizePanel(panel3,
-              panel::RESIZE_BOTTOM_RIGHT,
+              HTBOTTOMRIGHT,
               gfx::Vector2d(-bottom_resize_width, -bottom_resize_height));
 
   panel1_expected_full_size.Enlarge(-bottom_resize_width, 0);
   EXPECT_EQ(panel1_expected_full_size, panel1->full_size());
   panel2_expected_full_size.Enlarge(-bottom_resize_width, 0);
   EXPECT_EQ(panel2_expected_full_size, panel2->full_size());
   panel3_expected_full_size.Enlarge(-bottom_resize_width,
                                     -bottom_resize_height);
   EXPECT_EQ(panel3_expected_full_size, panel3->full_size());
 
   panel1_expected_bounds.set_width(
       panel1_expected_bounds.width() - bottom_resize_width);
   EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds());
   panel2_expected_bounds.set_width(
       panel2_expected_bounds.width() - bottom_resize_width);
   EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds());
   panel3_expected_bounds.set_width(
       panel3_expected_bounds.width() - bottom_resize_width);
   panel3_expected_bounds.set_height(
       panel3_expected_bounds.height() - bottom_resize_height);
   EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds());
 
   // Resize by the bottom edge of the middle panel.
   // Expect that the height of the middle panel increases and the height of
   // the bottom panel decreases by the same amount.
   int middle_resize_height = 5;
   ResizePanel(panel2,
-              panel::RESIZE_BOTTOM,
+              HTBOTTOM,
               gfx::Vector2d(0, middle_resize_height));
 
   EXPECT_EQ(panel1_expected_full_size, panel1->full_size());
   panel2_expected_full_size.Enlarge(0, middle_resize_height);
   EXPECT_EQ(panel2_expected_full_size, panel2->full_size());
   panel3_expected_full_size.Enlarge(0, -middle_resize_height);
   EXPECT_EQ(panel3_expected_full_size, panel3->full_size());
 
   EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds());
   panel2_expected_bounds.set_height(
@@ skipping 18 matching lines @@
   panel2_expected_bounds.set_height(panel2->TitleOnlyHeight());
   EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds());
   panel3_expected_bounds.set_y(panel2_expected_bounds.bottom());
   EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds());
 
   // Resize by the bottom edge of the top panel.
   // Expect that the height of the top panel increases and the height of
   // the middle panel is not affected because it is collapsed.
   top_resize_height = 18;
   ResizePanel(panel1,
-              panel::RESIZE_BOTTOM,
+              HTBOTTOM,
               gfx::Vector2d(0, top_resize_height));
 
   panel1_expected_full_size.Enlarge(0, top_resize_height);
   EXPECT_EQ(panel1_expected_full_size, panel1->full_size());
   EXPECT_EQ(panel2_expected_full_size, panel2->full_size());
   EXPECT_EQ(panel3_expected_full_size, panel3->full_size());
 
   panel1_expected_bounds.set_height(
       panel1_expected_bounds.height() + top_resize_height);
   EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds());
   panel2_expected_bounds.set_y(
       panel2_expected_bounds.y() + top_resize_height);
   EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds());
   panel3_expected_bounds.set_y(
       panel3_expected_bounds.y() + top_resize_height);
   EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds());
 
   panel_manager->CloseAll();
 }
 
 #endif