Eliminate ash::internal namespace

ash/shelf/shelf_view_unittest.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 "ash/shelf/shelf_view.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/ash_switches.h"
@@ skipping 252 matching lines @@
   virtual ~ShelfViewTest() {}
 
   virtual void SetUp() OVERRIDE {
     AshTestBase::SetUp();
     test::ShellTestApi test_api(Shell::GetInstance());
     model_ = test_api.shelf_model();
     Shelf* shelf = Shelf::ForPrimaryDisplay();
     shelf_view_ = ShelfTestAPI(shelf).shelf_view();
 
     // The bounds should be big enough for 4 buttons + overflow chevron.
-    shelf_view_->SetBounds(0, 0, 500,
-        internal::ShelfLayoutManager::GetPreferredShelfSize());
+    shelf_view_->SetBounds(
+        0, 0, 500, ShelfLayoutManager::GetPreferredShelfSize());
 
     test_api_.reset(new ShelfViewTestAPI(shelf_view_));
     test_api_->SetAnimationDuration(1);  // Speeds up animation for test.
 
     item_manager_ = Shell::GetInstance()->shelf_item_delegate_manager();
     DCHECK(item_manager_);
 
     // Add browser shortcut shelf item at index 0 for test.
     AddBrowserShortcut();
   }
@@ skipping 64 matching lines @@
     ShelfID id = AddPlatformAppNoWait();
     test_api_->RunMessageLoopUntilAnimationsDone();
     return id;
   }
 
   void RemoveByID(ShelfID id) {
     model_->RemoveItemAt(model_->ItemIndexByID(id));
     test_api_->RunMessageLoopUntilAnimationsDone();
   }
 
-  internal::ShelfButton* GetButtonByID(ShelfID id) {
+  ShelfButton* GetButtonByID(ShelfID id) {
     int index = model_->ItemIndexByID(id);
     return test_api_->GetButton(index);
   }
 
   ShelfItem GetItemByID(ShelfID id) {
     ShelfItems::const_iterator items = model_->ItemByID(id);
     return *items;
   }
 
   void CheckModelIDs(
@@ skipping 17 matching lines @@
         gfx::Rect shelf_view_bounds = shelf_view_->GetLocalBounds();
         gfx::Rect item_bounds = test_api_->GetBoundsByIndex(i);
         EXPECT_GE(item_bounds.x(), 0);
         EXPECT_GE(item_bounds.y(), 0);
         EXPECT_LE(item_bounds.right(), shelf_view_bounds.width());
         EXPECT_LE(item_bounds.bottom(), shelf_view_bounds.height());
       }
     }
   }
 
-  views::View* SimulateButtonPressed(
-      internal::ShelfButtonHost::Pointer pointer,
-      int button_index) {
-    internal::ShelfButtonHost* button_host = shelf_view_;
+  views::View* SimulateButtonPressed(ShelfButtonHost::Pointer pointer,
+                                     int button_index) {
+    ShelfButtonHost* button_host = shelf_view_;
     views::View* button = test_api_->GetButton(button_index);
     ui::MouseEvent click_event(ui::ET_MOUSE_PRESSED,
                                button->bounds().origin(),
                                button->GetBoundsInScreen().origin(), 0, 0);
     button_host->PointerPressedOnButton(button, pointer, click_event);
     return button;
   }
 
-  views::View* SimulateClick(internal::ShelfButtonHost::Pointer pointer,
+  views::View* SimulateClick(ShelfButtonHost::Pointer pointer,
                              int button_index) {
-    internal::ShelfButtonHost* button_host = shelf_view_;
+    ShelfButtonHost* button_host = shelf_view_;
     views::View* button = SimulateButtonPressed(pointer, button_index);
-    button_host->PointerReleasedOnButton(button,
-                                         internal::ShelfButtonHost::MOUSE,
-                                         false);
+    button_host->PointerReleasedOnButton(button, ShelfButtonHost::MOUSE, false);
     return button;
   }
 
-  views::View* SimulateDrag(internal::ShelfButtonHost::Pointer pointer,
+  views::View* SimulateDrag(ShelfButtonHost::Pointer pointer,
                             int button_index,
                             int destination_index) {
-    internal::ShelfButtonHost* button_host = shelf_view_;
+    ShelfButtonHost* button_host = shelf_view_;
     views::View* button = SimulateButtonPressed(pointer, button_index);
 
     // Drag.
     views::View* destination = test_api_->GetButton(destination_index);
     ui::MouseEvent drag_event(ui::ET_MOUSE_DRAGGED,
                               destination->bounds().origin(),
                               destination->GetBoundsInScreen().origin(), 0, 0);
     button_host->PointerDraggedOnButton(button, pointer, drag_event);
     return button;
   }
 
   void SetupForDragTest(
       std::vector<std::pair<ShelfID, views::View*> >* id_map) {
     // Initialize |id_map| with the automatically-created shelf buttons.
     for (size_t i = 0; i < model_->items().size(); ++i) {
-      internal::ShelfButton* button = test_api_->GetButton(i);
+      ShelfButton* button = test_api_->GetButton(i);
       id_map->push_back(std::make_pair(model_->items()[i].id, button));
     }
     ASSERT_NO_FATAL_FAILURE(CheckModelIDs(*id_map));
 
     // Add 5 app shelf buttons for testing.
     for (int i = 0; i < 5; ++i) {
       ShelfID id = AddAppShortcut();
       // App Icon is located at index 0, and browser shortcut is located at
       // index 1. So we should start to add app shortcut at index 2.
       id_map->insert(id_map->begin() + (i + browser_index_ + 1),
@@ skipping 34 matching lines @@
     int second_last_visible_item_id_in_shelf =
         GetItemId(test_api_->GetLastVisibleIndex() - 1);
     int first_visible_item_id_in_overflow =
         GetItemId(test_api_for_overflow.GetFirstVisibleIndex());
     int second_last_visible_item_id_in_overflow =
         GetItemId(test_api_for_overflow.GetLastVisibleIndex() - 1);
 
     int drag_item_index =
         test_api_for_overflow.GetLastVisibleIndex();
     ShelfID drag_item_id = GetItemId(drag_item_index);
-    internal::ShelfButton* drag_button =
-        test_api_for_overflow.GetButton(drag_item_index);
+    ShelfButton* drag_button = test_api_for_overflow.GetButton(drag_item_index);
     gfx::Point center_point_of_drag_item =
         drag_button->GetBoundsInScreen().CenterPoint();
 
     aura::test::EventGenerator generator(ash::Shell::GetPrimaryRootWindow(),
                                          center_point_of_drag_item);
     // Rip an item off to OverflowBubble.
     generator.PressLeftButton();
     gfx::Point rip_off_point(center_point_of_drag_item.x(), 0);
     generator.MoveMouseTo(rip_off_point);
     test_api_for_overflow.RunMessageLoopUntilAnimationsDone();
@@ skipping 60 matching lines @@
     // Replace ShelfDelegate.
     test::ShellTestApi test_api(Shell::GetInstance());
     test_api.SetShelfDelegate(NULL);
     ShelfDelegate* delegate = new TestShelfDelegateForShelfView(model_);
     test_api.SetShelfDelegate(delegate);
     test::ShelfTestAPI(Shelf::ForPrimaryDisplay()).SetShelfDelegate(delegate);
     test_api_->SetShelfDelegate(delegate);
   }
 
   ShelfModel* model_;
-  internal::ShelfView* shelf_view_;
+  ShelfView* shelf_view_;
   int browser_index_;
   ShelfItemDelegateManager* item_manager_;
 
   scoped_ptr<ShelfViewTestAPI> test_api_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ShelfViewTest);
 };
 
 class ShelfViewLegacyShelfLayoutTest : public ShelfViewTest {
@@ skipping 56 matching lines @@
  private:
   ScopedTextDirectionChange text_direction_change_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfViewTextDirectionTest);
 };
 
 // Checks that the ideal item icon bounds match the view's bounds in the screen
 // in both LTR and RTL.
 TEST_P(ShelfViewTextDirectionTest, IdealBoundsOfItemIcon) {
   ShelfID id = AddPlatformApp();
-  internal::ShelfButton* button = GetButtonByID(id);
+  ShelfButton* button = GetButtonByID(id);
   gfx::Rect item_bounds = button->GetBoundsInScreen();
   gfx::Point icon_offset = button->GetIconBounds().origin();
   item_bounds.Offset(icon_offset.OffsetFromOrigin());
   gfx::Rect ideal_bounds = shelf_view_->GetIdealBoundsOfItemIcon(id);
   gfx::Point screen_origin;
   views::View::ConvertPointToScreen(shelf_view_, &screen_origin);
   ideal_bounds.Offset(screen_origin.x(), screen_origin.y());
   EXPECT_EQ(item_bounds.x(), ideal_bounds.x());
   EXPECT_EQ(item_bounds.y(), ideal_bounds.y());
 }
@@ skipping 276 matching lines @@
   }
 
   // ShelfView should be big enough to hold at least 3 new buttons.
   ASSERT_GE(added_count, 3);
 
   // Wait for the last animation to finish.
   test_api_->RunMessageLoopUntilAnimationsDone();
 
   // Verifies non-overflow buttons are visible.
   for (int i = 0; i <= test_api_->GetLastVisibleIndex(); ++i) {
-    internal::ShelfButton* button = test_api_->GetButton(i);
+    ShelfButton* button = test_api_->GetButton(i);
     if (button) {
       EXPECT_TRUE(button->visible()) << "button index=" << i;
       EXPECT_EQ(1.0f, button->layer()->opacity()) << "button index=" << i;
     }
   }
 }
 
 // Check that model changes are handled correctly while a shelf icon is being
 // dragged.
 TEST_F(ShelfViewTest, ModelChangesWhileDragging) {
-  internal::ShelfButtonHost* button_host = shelf_view_;
+  ShelfButtonHost* button_host = shelf_view_;
 
   std::vector<std::pair<ShelfID, views::View*> > id_map;
   SetupForDragTest(&id_map);
 
   // Dragging browser shortcut at index 1.
   EXPECT_TRUE(model_->items()[1].type == TYPE_BROWSER_SHORTCUT);
-  views::View* dragged_button = SimulateDrag(
-      internal::ShelfButtonHost::MOUSE, 1, 3);
+  views::View* dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 1, 3);
   std::rotate(id_map.begin() + 1,
               id_map.begin() + 2,
               id_map.begin() + 4);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
-  button_host->PointerReleasedOnButton(dragged_button,
-                                       internal::ShelfButtonHost::MOUSE,
-                                       false);
+  button_host->PointerReleasedOnButton(
+      dragged_button, ShelfButtonHost::MOUSE, false);
   EXPECT_TRUE(model_->items()[3].type == TYPE_BROWSER_SHORTCUT);
 
   // Dragging changes model order.
-  dragged_button = SimulateDrag(internal::ShelfButtonHost::MOUSE, 1, 3);
+  dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 1, 3);
   std::rotate(id_map.begin() + 1,
               id_map.begin() + 2,
               id_map.begin() + 4);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
   // Cancelling the drag operation restores previous order.
-  button_host->PointerReleasedOnButton(dragged_button,
-                                       internal::ShelfButtonHost::MOUSE,
-                                       true);
+  button_host->PointerReleasedOnButton(
+      dragged_button, ShelfButtonHost::MOUSE, true);
   std::rotate(id_map.begin() + 1,
               id_map.begin() + 3,
               id_map.begin() + 4);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
   // Deleting an item keeps the remaining intact.
-  dragged_button = SimulateDrag(internal::ShelfButtonHost::MOUSE, 1, 3);
+  dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 1, 3);
   model_->RemoveItemAt(1);
   id_map.erase(id_map.begin() + 1);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
-  button_host->PointerReleasedOnButton(dragged_button,
-                                       internal::ShelfButtonHost::MOUSE,
-                                       false);
+  button_host->PointerReleasedOnButton(
+      dragged_button, ShelfButtonHost::MOUSE, false);
 
   // Adding a shelf item cancels the drag and respects the order.
-  dragged_button = SimulateDrag(internal::ShelfButtonHost::MOUSE, 1, 3);
+  dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 1, 3);
   ShelfID new_id = AddAppShortcut();
   id_map.insert(id_map.begin() + 6,
                 std::make_pair(new_id, GetButtonByID(new_id)));
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
-  button_host->PointerReleasedOnButton(dragged_button,
-                                       internal::ShelfButtonHost::MOUSE,
-                                       false);
+  button_host->PointerReleasedOnButton(
+      dragged_button, ShelfButtonHost::MOUSE, false);
 
   // Adding a shelf item at the end (i.e. a panel)  canels drag and respects
   // the order.
-  dragged_button = SimulateDrag(internal::ShelfButtonHost::MOUSE, 1, 3);
+  dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 1, 3);
   new_id = AddPanel();
   id_map.insert(id_map.begin() + 7,
                 std::make_pair(new_id, GetButtonByID(new_id)));
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
-  button_host->PointerReleasedOnButton(dragged_button,
-                                       internal::ShelfButtonHost::MOUSE,
-                                       false);
+  button_host->PointerReleasedOnButton(
+      dragged_button, ShelfButtonHost::MOUSE, false);
 }
 
 TEST_F(ShelfViewLegacyShelfLayoutTest, ModelChangesWhileDragging) {
-  internal::ShelfButtonHost* button_host = shelf_view_;
+  ShelfButtonHost* button_host = shelf_view_;
 
   std::vector<std::pair<ShelfID, views::View*> > id_map;
   SetupForDragTest(&id_map);
 
   // Dragging browser shortcut at index 0.
   EXPECT_TRUE(model_->items()[0].type == TYPE_BROWSER_SHORTCUT);
-  views::View* dragged_button = SimulateDrag(
-      internal::ShelfButtonHost::MOUSE, 0, 2);
+  views::View* dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 0, 2);
   std::rotate(id_map.begin(),
               id_map.begin() + 1,
               id_map.begin() + 3);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
-  button_host->PointerReleasedOnButton(dragged_button,
-                                       internal::ShelfButtonHost::MOUSE,
-                                       false);
+  button_host->PointerReleasedOnButton(
+      dragged_button, ShelfButtonHost::MOUSE, false);
   EXPECT_TRUE(model_->items()[2].type == TYPE_BROWSER_SHORTCUT);
 
   // Dragging changes model order.
-  dragged_button = SimulateDrag(internal::ShelfButtonHost::MOUSE, 0, 2);
+  dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 0, 2);
   std::rotate(id_map.begin(),
               id_map.begin() + 1,
               id_map.begin() + 3);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
   // Cancelling the drag operation restores previous order.
-  button_host->PointerReleasedOnButton(dragged_button,
-                                       internal::ShelfButtonHost::MOUSE,
-                                       true);
+  button_host->PointerReleasedOnButton(
+      dragged_button, ShelfButtonHost::MOUSE, true);
   std::rotate(id_map.begin(),
               id_map.begin() + 2,
               id_map.begin() + 3);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
   // Deleting an item keeps the remaining intact.
-  dragged_button = SimulateDrag(internal::ShelfButtonHost::MOUSE, 0, 2);
+  dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 0, 2);
   model_->RemoveItemAt(1);
   id_map.erase(id_map.begin() + 1);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
-  button_host->PointerReleasedOnButton(dragged_button,
-                                       internal::ShelfButtonHost::MOUSE,
-                                       false);
+  button_host->PointerReleasedOnButton(
+      dragged_button, ShelfButtonHost::MOUSE, false);
 
   // Adding a shelf item cancels the drag and respects the order.
-  dragged_button = SimulateDrag(internal::ShelfButtonHost::MOUSE, 0, 2);
+  dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 0, 2);
   ShelfID new_id = AddAppShortcut();
   id_map.insert(id_map.begin() + 5,
                 std::make_pair(new_id, GetButtonByID(new_id)));
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
-  button_host->PointerReleasedOnButton(dragged_button,
-                                       internal::ShelfButtonHost::MOUSE,
-                                       false);
+  button_host->PointerReleasedOnButton(
+      dragged_button, ShelfButtonHost::MOUSE, false);
 
   // Adding a shelf item at the end (i.e. a panel)  canels drag and respects
   // the order.
-  dragged_button = SimulateDrag(internal::ShelfButtonHost::MOUSE, 0, 2);
+  dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 0, 2);
   new_id = AddPanel();
   id_map.insert(id_map.begin() + 7,
                 std::make_pair(new_id, GetButtonByID(new_id)));
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
-  button_host->PointerReleasedOnButton(dragged_button,
-                                       internal::ShelfButtonHost::MOUSE,
-                                       false);
+  button_host->PointerReleasedOnButton(
+      dragged_button, ShelfButtonHost::MOUSE, false);
 }
 
 // Check that 2nd drag from the other pointer would be ignored.
 TEST_F(ShelfViewTest, SimultaneousDrag) {
-  internal::ShelfButtonHost* button_host = shelf_view_;
+  ShelfButtonHost* button_host = shelf_view_;
 
   std::vector<std::pair<ShelfID, views::View*> > id_map;
   SetupForDragTest(&id_map);
 
   // Start a mouse drag.
-  views::View* dragged_button_mouse = SimulateDrag(
-      internal::ShelfButtonHost::MOUSE, 1, 3);
+  views::View* dragged_button_mouse =
+      SimulateDrag(ShelfButtonHost::MOUSE, 1, 3);
   std::rotate(id_map.begin() + 1,
               id_map.begin() + 2,
               id_map.begin() + 4);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   // Attempt a touch drag before the mouse drag finishes.
-  views::View* dragged_button_touch = SimulateDrag(
-      internal::ShelfButtonHost::TOUCH, 4, 2);
+  views::View* dragged_button_touch =
+      SimulateDrag(ShelfButtonHost::TOUCH, 4, 2);
 
   // Nothing changes since 2nd drag is ignored.
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
   // Finish the mouse drag.
-  button_host->PointerReleasedOnButton(dragged_button_mouse,
-                                       internal::ShelfButtonHost::MOUSE,
-                                       false);
+  button_host->PointerReleasedOnButton(
+      dragged_button_mouse, ShelfButtonHost::MOUSE, false);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
   // Now start a touch drag.
-  dragged_button_touch = SimulateDrag(internal::ShelfButtonHost::TOUCH, 4, 2);
+  dragged_button_touch = SimulateDrag(ShelfButtonHost::TOUCH, 4, 2);
   std::rotate(id_map.begin() + 3,
               id_map.begin() + 4,
               id_map.begin() + 5);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
   // And attempt a mouse drag before the touch drag finishes.
-  dragged_button_mouse = SimulateDrag(internal::ShelfButtonHost::MOUSE, 1, 2);
+  dragged_button_mouse = SimulateDrag(ShelfButtonHost::MOUSE, 1, 2);
 
   // Nothing changes since 2nd drag is ignored.
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
-  button_host->PointerReleasedOnButton(dragged_button_touch,
-                                       internal::ShelfButtonHost::TOUCH,
-                                       false);
+  button_host->PointerReleasedOnButton(
+      dragged_button_touch, ShelfButtonHost::TOUCH, false);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 }
 
 // Check that clicking first on one item and then dragging another works as
 // expected.
 TEST_F(ShelfViewTest, ClickOneDragAnother) {
-  internal::ShelfButtonHost* button_host = shelf_view_;
+  ShelfButtonHost* button_host = shelf_view_;
 
   std::vector<std::pair<ShelfID, views::View*> > id_map;
   SetupForDragTest(&id_map);
 
   // A click on item 1 is simulated.
-  SimulateClick(internal::ShelfButtonHost::MOUSE, 1);
+  SimulateClick(ShelfButtonHost::MOUSE, 1);
 
   // Dragging browser index at 0 should change the model order correctly.
   EXPECT_TRUE(model_->items()[1].type == TYPE_BROWSER_SHORTCUT);
-  views::View* dragged_button = SimulateDrag(
-      internal::ShelfButtonHost::MOUSE, 1, 3);
+  views::View* dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 1, 3);
   std::rotate(id_map.begin() + 1,
               id_map.begin() + 2,
               id_map.begin() + 4);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
-  button_host->PointerReleasedOnButton(dragged_button,
-                                       internal::ShelfButtonHost::MOUSE,
-                                       false);
+  button_host->PointerReleasedOnButton(
+      dragged_button, ShelfButtonHost::MOUSE, false);
   EXPECT_TRUE(model_->items()[3].type == TYPE_BROWSER_SHORTCUT);
 }
 
 // Confirm that item status changes are reflected in the buttons.
 TEST_F(ShelfViewTest, ShelfItemStatus) {
   // All buttons should be visible.
   ASSERT_EQ(test_api_->GetButtonCount(),
             test_api_->GetLastVisibleIndex() + 1);
 
   // Add platform app button.
   ShelfID last_added = AddPlatformApp();
   ShelfItem item = GetItemByID(last_added);
   int index = model_->ItemIndexByID(last_added);
-  internal::ShelfButton* button = GetButtonByID(last_added);
-  ASSERT_EQ(internal::ShelfButton::STATE_RUNNING, button->state());
+  ShelfButton* button = GetButtonByID(last_added);
+  ASSERT_EQ(ShelfButton::STATE_RUNNING, button->state());
   item.status = STATUS_ACTIVE;
   model_->Set(index, item);
-  ASSERT_EQ(internal::ShelfButton::STATE_ACTIVE, button->state());
+  ASSERT_EQ(ShelfButton::STATE_ACTIVE, button->state());
   item.status = STATUS_ATTENTION;
   model_->Set(index, item);
-  ASSERT_EQ(internal::ShelfButton::STATE_ATTENTION, button->state());
+  ASSERT_EQ(ShelfButton::STATE_ATTENTION, button->state());
 }
 
 TEST_F(ShelfViewLegacyShelfLayoutTest,
        ShelfItemPositionReflectedOnStateChanged) {
   // All buttons should be visible.
   ASSERT_EQ(test_api_->GetButtonCount(),
             test_api_->GetLastVisibleIndex() + 1);
 
   // Add 2 items to the shelf.
   ShelfID item1_id = AddPlatformApp();
   ShelfID item2_id = AddPlatformAppNoWait();
-  internal::ShelfButton* item1_button = GetButtonByID(item1_id);
-  internal::ShelfButton* item2_button = GetButtonByID(item2_id);
+  ShelfButton* item1_button = GetButtonByID(item1_id);
+  ShelfButton* item2_button = GetButtonByID(item2_id);
 
-  internal::ShelfButton::State state_mask =
-      static_cast<internal::ShelfButton::State>(
-          internal::ShelfButton::STATE_NORMAL |
-          internal::ShelfButton::STATE_HOVERED |
-          internal::ShelfButton::STATE_RUNNING |
-          internal::ShelfButton::STATE_ACTIVE |
-          internal::ShelfButton::STATE_ATTENTION |
-          internal::ShelfButton::STATE_FOCUSED);
+  ShelfButton::State state_mask = static_cast<ShelfButton::State>(
+      ShelfButton::STATE_NORMAL | ShelfButton::STATE_HOVERED |
+      ShelfButton::STATE_RUNNING | ShelfButton::STATE_ACTIVE |
+      ShelfButton::STATE_ATTENTION | ShelfButton::STATE_FOCUSED);
 
   // Clear the button states.
   item1_button->ClearState(state_mask);
   item2_button->ClearState(state_mask);
 
   // Since default alignment in tests is bottom, state is reflected in y-axis.
   ASSERT_EQ(item1_button->GetIconBounds().y(),
             item2_button->GetIconBounds().y());
-  item1_button->AddState(internal::ShelfButton::STATE_HOVERED);
+  item1_button->AddState(ShelfButton::STATE_HOVERED);
   ASSERT_NE(item1_button->GetIconBounds().y(),
             item2_button->GetIconBounds().y());
-  item1_button->ClearState(internal::ShelfButton::STATE_HOVERED);
+  item1_button->ClearState(ShelfButton::STATE_HOVERED);
 }
 
 // Confirm that item status changes are reflected in the buttons
 // for platform apps.
 TEST_F(ShelfViewTest, ShelfItemStatusPlatformApp) {
   // All buttons should be visible.
   ASSERT_EQ(test_api_->GetButtonCount(),
             test_api_->GetLastVisibleIndex() + 1);
 
   // Add platform app button.
   ShelfID last_added = AddPlatformApp();
   ShelfItem item = GetItemByID(last_added);
   int index = model_->ItemIndexByID(last_added);
-  internal::ShelfButton* button = GetButtonByID(last_added);
-  ASSERT_EQ(internal::ShelfButton::STATE_RUNNING, button->state());
+  ShelfButton* button = GetButtonByID(last_added);
+  ASSERT_EQ(ShelfButton::STATE_RUNNING, button->state());
   item.status = STATUS_ACTIVE;
   model_->Set(index, item);
-  ASSERT_EQ(internal::ShelfButton::STATE_ACTIVE, button->state());
+  ASSERT_EQ(ShelfButton::STATE_ACTIVE, button->state());
   item.status = STATUS_ATTENTION;
   model_->Set(index, item);
-  ASSERT_EQ(internal::ShelfButton::STATE_ATTENTION, button->state());
+  ASSERT_EQ(ShelfButton::STATE_ATTENTION, button->state());
 }
 
 // Confirm that shelf item bounds are correctly updated on shelf changes.
 TEST_F(ShelfViewTest, ShelfItemBoundsCheck) {
   VerifyShelfItemBoundsAreValid();
   shelf_view_->shelf_layout_manager()->SetAutoHideBehavior(
       SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   test_api_->RunMessageLoopUntilAnimationsDone();
   VerifyShelfItemBoundsAreValid();
   shelf_view_->shelf_layout_manager()->SetAutoHideBehavior(
       SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
   test_api_->RunMessageLoopUntilAnimationsDone();
   VerifyShelfItemBoundsAreValid();
 }
 
 TEST_F(ShelfViewTest, ShelfTooltipTest) {
   ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1,
             test_api_->GetButtonCount());
 
   // Prepare some items to the shelf.
   ShelfID app_button_id = AddAppShortcut();
   ShelfID platform_button_id = AddPlatformApp();
 
-  internal::ShelfButton* app_button = GetButtonByID(app_button_id);
-  internal::ShelfButton* platform_button = GetButtonByID(platform_button_id);
+  ShelfButton* app_button = GetButtonByID(app_button_id);
+  ShelfButton* platform_button = GetButtonByID(platform_button_id);
 
-  internal::ShelfButtonHost* button_host = shelf_view_;
-  internal::ShelfTooltipManager* tooltip_manager =
-      shelf_view_->tooltip_manager();
+  ShelfButtonHost* button_host = shelf_view_;
+  ShelfTooltipManager* tooltip_manager = shelf_view_->tooltip_manager();
 
   button_host->MouseEnteredButton(app_button);
   // There's a delay to show the tooltip, so it's not visible yet.
   EXPECT_FALSE(tooltip_manager->IsVisible());
   EXPECT_EQ(app_button, GetTooltipAnchorView());
 
   ShowTooltip();
   EXPECT_TRUE(tooltip_manager->IsVisible());
 
   // Once it's visible, it keeps visibility and is pointing to the same
@@ skipping 15 matching lines @@
   button_host->MouseEnteredButton(app_button);
   button_host->MouseExitedButton(app_button);
   button_host->MouseEnteredButton(platform_button);
   EXPECT_FALSE(tooltip_manager->IsVisible());
   EXPECT_EQ(platform_button, GetTooltipAnchorView());
 }
 
 // Verify a fix for crash caused by a tooltip update for a deletedshelf
 // button, see crbug.com/288838.
 TEST_F(ShelfViewTest, RemovingItemClosesTooltip) {
-  internal::ShelfButtonHost* button_host = shelf_view_;
-  internal::ShelfTooltipManager* tooltip_manager =
-      shelf_view_->tooltip_manager();
+  ShelfButtonHost* button_host = shelf_view_;
+  ShelfTooltipManager* tooltip_manager = shelf_view_->tooltip_manager();
 
   // Add an item to the shelf.
   ShelfID app_button_id = AddAppShortcut();
-  internal::ShelfButton* app_button = GetButtonByID(app_button_id);
+  ShelfButton* app_button = GetButtonByID(app_button_id);
 
   // Spawn a tooltip on that item.
   button_host->MouseEnteredButton(app_button);
   ShowTooltip();
   EXPECT_TRUE(tooltip_manager->IsVisible());
 
   // Remove the app shortcut while the tooltip is open. The tooltip should be
   // closed.
   RemoveByID(app_button_id);
   EXPECT_FALSE(tooltip_manager->IsVisible());
 
   // Change the shelf layout. This should not crash.
   Shell::GetInstance()->SetShelfAlignment(SHELF_ALIGNMENT_LEFT,
                                           Shell::GetPrimaryRootWindow());
 }
 
 // Changing the shelf alignment closes any open tooltip.
 TEST_F(ShelfViewTest, ShelfAlignmentClosesTooltip) {
-  internal::ShelfButtonHost* button_host = shelf_view_;
-  internal::ShelfTooltipManager* tooltip_manager =
-      shelf_view_->tooltip_manager();
+  ShelfButtonHost* button_host = shelf_view_;
+  ShelfTooltipManager* tooltip_manager = shelf_view_->tooltip_manager();
 
   // Add an item to the shelf.
   ShelfID app_button_id = AddAppShortcut();
-  internal::ShelfButton* app_button = GetButtonByID(app_button_id);
+  ShelfButton* app_button = GetButtonByID(app_button_id);
 
   // Spawn a tooltip on the item.
   button_host->MouseEnteredButton(app_button);
   ShowTooltip();
   EXPECT_TRUE(tooltip_manager->IsVisible());
 
   // Changing shelf alignment hides the tooltip.
   Shell::GetInstance()->SetShelfAlignment(SHELF_ALIGNMENT_LEFT,
                                           Shell::GetPrimaryRootWindow());
   EXPECT_FALSE(tooltip_manager->IsVisible());
 }
 
 TEST_F(ShelfViewTest, ShouldHideTooltipTest) {
   ShelfID app_button_id = AddAppShortcut();
   ShelfID platform_button_id = AddPlatformApp();
 
   // The tooltip shouldn't hide if the mouse is on normal buttons.
   for (int i = 0; i < test_api_->GetButtonCount(); i++) {
-    internal::ShelfButton* button = test_api_->GetButton(i);
+    ShelfButton* button = test_api_->GetButton(i);
     if (!button)
       continue;
 
     EXPECT_FALSE(shelf_view_->ShouldHideTooltip(
         button->GetMirroredBounds().CenterPoint()))
         << "ShelfView tries to hide on button " << i;
   }
 
   // The tooltip should not hide on the app-list button.
   views::View* app_list_button = shelf_view_->GetAppListButtonView();
   EXPECT_FALSE(shelf_view_->ShouldHideTooltip(
       app_list_button->GetMirroredBounds().CenterPoint()));
 
   // The tooltip shouldn't hide if the mouse is in the gap between two buttons.
   gfx::Rect app_button_rect = GetButtonByID(app_button_id)->GetMirroredBounds();
   gfx::Rect platform_button_rect =
       GetButtonByID(platform_button_id)->GetMirroredBounds();
   ASSERT_FALSE(app_button_rect.Intersects(platform_button_rect));
   EXPECT_FALSE(shelf_view_->ShouldHideTooltip(
       gfx::UnionRects(app_button_rect, platform_button_rect).CenterPoint()));
 
   // The tooltip should hide if it's outside of all buttons.
   gfx::Rect all_area;
   for (int i = 0; i < test_api_->GetButtonCount(); i++) {
-    internal::ShelfButton* button = test_api_->GetButton(i);
+    ShelfButton* button = test_api_->GetButton(i);
     if (!button)
       continue;
 
     all_area.Union(button->GetMirroredBounds());
   }
   all_area.Union(shelf_view_->GetAppListButtonView()->GetMirroredBounds());
   EXPECT_FALSE(shelf_view_->ShouldHideTooltip(all_area.origin()));
   EXPECT_FALSE(shelf_view_->ShouldHideTooltip(
       gfx::Point(all_area.right() - 1, all_area.bottom() - 1)));
   EXPECT_TRUE(shelf_view_->ShouldHideTooltip(
       gfx::Point(all_area.right(), all_area.y())));
   EXPECT_TRUE(shelf_view_->ShouldHideTooltip(
       gfx::Point(all_area.x() - 1, all_area.y())));
   EXPECT_TRUE(shelf_view_->ShouldHideTooltip(
       gfx::Point(all_area.x(), all_area.y() - 1)));
   EXPECT_TRUE(shelf_view_->ShouldHideTooltip(
       gfx::Point(all_area.x(), all_area.bottom())));
 }
 
 TEST_F(ShelfViewTest, ShouldHideTooltipWithAppListWindowTest) {
   Shell::GetInstance()->ToggleAppList(NULL);
   ASSERT_TRUE(Shell::GetInstance()->GetAppListWindow());
 
   // The tooltip shouldn't hide if the mouse is on normal buttons.
   for (int i = 1; i < test_api_->GetButtonCount(); i++) {
-    internal::ShelfButton* button = test_api_->GetButton(i);
+    ShelfButton* button = test_api_->GetButton(i);
     if (!button)
       continue;
 
     EXPECT_FALSE(shelf_view_->ShouldHideTooltip(
         button->GetMirroredBounds().CenterPoint()))
         << "ShelfView tries to hide on button " << i;
   }
 
   // The tooltip should hide on the app-list button.
   views::View* app_list_button = shelf_view_->GetAppListButtonView();
   EXPECT_TRUE(shelf_view_->ShouldHideTooltip(
       app_list_button->GetMirroredBounds().CenterPoint()));
 }
 
 // Test that by moving the mouse cursor off the button onto the bubble it closes
 // the bubble.
 TEST_F(ShelfViewTest, ShouldHideTooltipWhenHoveringOnTooltip) {
-  internal::ShelfTooltipManager* tooltip_manager =
-      shelf_view_->tooltip_manager();
+  ShelfTooltipManager* tooltip_manager = shelf_view_->tooltip_manager();
   tooltip_manager->CreateZeroDelayTimerForTest();
   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
 
   // Move the mouse off any item and check that no tooltip is shown.
   generator.MoveMouseTo(gfx::Point(0, 0));
   EXPECT_FALSE(tooltip_manager->IsVisible());
 
   // Move the mouse over the button and check that it is visible.
   views::View* app_list_button = shelf_view_->GetAppListButtonView();
   gfx::Rect bounds = app_list_button->GetBoundsInScreen();
@@ skipping 75 matching lines @@
   ShelfViewTestAPI test_for_overflow_view(
       test_api_->overflow_bubble()->shelf_view());
 
   int ripped_index = test_for_overflow_view.GetLastVisibleIndex();
   gfx::Size bubble_size = test_for_overflow_view.GetPreferredSize();
   int item_width = test_for_overflow_view.GetButtonSize() +
       test_for_overflow_view.GetButtonSpacing();
 
   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                        gfx::Point());
-  internal::ShelfButton* button =
-      test_for_overflow_view.GetButton(ripped_index);
+  ShelfButton* button = test_for_overflow_view.GetButton(ripped_index);
   // Rip off the last visible item.
   gfx::Point start_point = button->GetBoundsInScreen().CenterPoint();
   gfx::Point rip_off_point(start_point.x(), 0);
   generator.MoveMouseTo(start_point.x(), start_point.y());
   base::MessageLoop::current()->RunUntilIdle();
   generator.PressLeftButton();
   base::MessageLoop::current()->RunUntilIdle();
   generator.MoveMouseTo(rip_off_point.x(), rip_off_point.y());
   base::MessageLoop::current()->RunUntilIdle();
   test_for_overflow_view.RunMessageLoopUntilAnimationsDone();
@@ skipping 39 matching lines @@
 
   AddButtonsUntilOverflow();
 
   // Show overflow bubble.
   test_api_->ShowOverflowBubble();
   ASSERT_TRUE(test_api_->overflow_bubble() &&
               test_api_->overflow_bubble()->IsShowing());
 
   int item_width = test_api_->GetButtonSize() +
       test_api_->GetButtonSpacing();
-  internal::OverflowBubbleView* bubble_view =
-      test_api_->overflow_bubble()->bubble_view();
+  OverflowBubbleView* bubble_view = test_api_->overflow_bubble()->bubble_view();
   test::OverflowBubbleViewTestAPI bubble_view_api(bubble_view);
 
   // Add more buttons until OverflowBubble is scrollable and it has 3 invisible
   // items.
   while (bubble_view_api.GetContentsSize().width() <
          (bubble_view->GetContentsBounds().width() + 3 * item_width))
     AddAppShortcut();
 
   ASSERT_TRUE(test_api_->overflow_bubble() &&
               test_api_->overflow_bubble()->IsShowing());
 
   ShelfViewTestAPI test_for_overflow_view(
       test_api_->overflow_bubble()->shelf_view());
   int first_index = test_for_overflow_view.GetFirstVisibleIndex();
   int last_index = test_for_overflow_view.GetLastVisibleIndex();
 
-  internal::ShelfButton* first_button =
-      test_for_overflow_view.GetButton(first_index);
-  internal::ShelfButton* last_button =
-      test_for_overflow_view.GetButton(last_index);
+  ShelfButton* first_button = test_for_overflow_view.GetButton(first_index);
+  ShelfButton* last_button = test_for_overflow_view.GetButton(last_index);
   gfx::Point first_point = first_button->GetBoundsInScreen().CenterPoint();
   gfx::Point last_point = last_button->GetBoundsInScreen().CenterPoint();
   gfx::Rect drag_reinsert_bounds =
       test_for_overflow_view.GetBoundsForDragInsertInScreen();
   EXPECT_TRUE(drag_reinsert_bounds.Contains(first_point));
   EXPECT_FALSE(drag_reinsert_bounds.Contains(last_point));
 
   // Scrolls sufficiently to show last item.
   bubble_view_api.ScrollByXOffset(3 * item_width);
   drag_reinsert_bounds =
       test_for_overflow_view.GetBoundsForDragInsertInScreen();
   first_point = first_button->GetBoundsInScreen().CenterPoint();
   last_point = last_button->GetBoundsInScreen().CenterPoint();
   EXPECT_FALSE(drag_reinsert_bounds.Contains(first_point));
   EXPECT_TRUE(drag_reinsert_bounds.Contains(last_point));
 }
 
 // Check the drag insertion bounds of shelf view in multi monitor environment.
 TEST_F(ShelfViewTest, CheckDragInsertBoundsWithMultiMonitor) {
   // win8-aura doesn't support multiple display.
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("800x600,800x600");
   Shelf* secondary_shelf = Shelf::ForWindow(Shell::GetAllRootWindows()[1]);
-  internal::ShelfView* shelf_view_for_secondary =
+  ShelfView* shelf_view_for_secondary =
       ShelfTestAPI(secondary_shelf).shelf_view();
 
   // The bounds should be big enough for 4 buttons + overflow chevron.
-  shelf_view_for_secondary->SetBounds(0, 0, 500,
-      internal::ShelfLayoutManager::GetPreferredShelfSize());
+  shelf_view_for_secondary->SetBounds(
+      0, 0, 500, ShelfLayoutManager::GetPreferredShelfSize());
 
   ShelfViewTestAPI test_api_for_secondary(shelf_view_for_secondary);
   // Speeds up animation for test.
   test_api_for_secondary.SetAnimationDuration(1);
 
   AddButtonsUntilOverflow();
 
   // Test #1: Test drag insertion bounds of primary shelf.
   // Show overflow bubble.
   test_api_->ShowOverflowBubble();
   ASSERT_TRUE(test_api_->overflow_bubble() &&
               test_api_->overflow_bubble()->IsShowing());
 
   ShelfViewTestAPI test_api_for_overflow_view(
       test_api_->overflow_bubble()->shelf_view());
 
-  internal::ShelfButton* button = test_api_for_overflow_view.GetButton(
+  ShelfButton* button = test_api_for_overflow_view.GetButton(
       test_api_for_overflow_view.GetLastVisibleIndex());
 
   // Checks that a point in shelf is contained in drag insert bounds.
   gfx::Point point_in_shelf_view = button->GetBoundsInScreen().CenterPoint();
   gfx::Rect drag_reinsert_bounds =
       test_api_for_overflow_view.GetBoundsForDragInsertInScreen();
   EXPECT_TRUE(drag_reinsert_bounds.Contains(point_in_shelf_view));
   // Checks that a point out of shelf is not contained in drag insert bounds.
   EXPECT_FALSE(drag_reinsert_bounds.Contains(
       gfx::Point(point_in_shelf_view.x(), 0)));
 
   // Test #2: Test drag insertion bounds of secondary shelf.
   // Show overflow bubble.
   test_api_for_secondary.ShowOverflowBubble();
   ASSERT_TRUE(test_api_for_secondary.overflow_bubble() &&
               test_api_for_secondary.overflow_bubble()->IsShowing());
 
   ShelfViewTestAPI test_api_for_overflow_view_of_secondary(
       test_api_for_secondary.overflow_bubble()->shelf_view());
 
-  internal::ShelfButton* button_in_secondary =
+  ShelfButton* button_in_secondary =
       test_api_for_overflow_view_of_secondary.GetButton(
           test_api_for_overflow_view_of_secondary.GetLastVisibleIndex());
 
   // Checks that a point in shelf is contained in drag insert bounds.
   gfx::Point point_in_secondary_shelf_view =
       button_in_secondary->GetBoundsInScreen().CenterPoint();
   gfx::Rect drag_reinsert_bounds_in_secondary =
       test_api_for_overflow_view_of_secondary.GetBoundsForDragInsertInScreen();
   EXPECT_TRUE(drag_reinsert_bounds_in_secondary.Contains(
       point_in_secondary_shelf_view));
@@ skipping 19 matching lines @@
   Shell::GetInstance()->SetShelfAlignment(SHELF_ALIGNMENT_LEFT, second_root);
   ASSERT_EQ(SHELF_ALIGNMENT_LEFT,
             Shell::GetInstance()->GetShelfAlignment(second_root));
 
   // Initially, app list and browser shortcut are added.
   EXPECT_EQ(2, model_->item_count());
   int browser_index = model_->GetItemIndexForType(TYPE_BROWSER_SHORTCUT);
   EXPECT_GT(browser_index, 0);
 
   Shelf* secondary_shelf = Shelf::ForWindow(second_root);
-  internal::ShelfView* shelf_view_for_secondary =
+  ShelfView* shelf_view_for_secondary =
       ShelfTestAPI(secondary_shelf).shelf_view();
 
   ShelfViewTestAPI test_api_for_secondary_shelf_view(shelf_view_for_secondary);
-  internal::ShelfButton* button =
-    test_api_for_secondary_shelf_view.GetButton(browser_index);
+  ShelfButton* button =
+      test_api_for_secondary_shelf_view.GetButton(browser_index);
 
   // Fetch the start point of dragging.
   gfx::Point start_point = button->GetBoundsInScreen().CenterPoint();
   wm::ConvertPointFromScreen(second_root, &start_point);
 
   aura::test::EventGenerator generator(second_root, start_point);
 
   // Rip off the browser item.
   generator.PressLeftButton();
   generator.MoveMouseTo(start_point.x() + 400, start_point.y());
@@ skipping 15 matching lines @@
 class ShelfViewVisibleBoundsTest : public ShelfViewTest,
                                    public testing::WithParamInterface<bool> {
  public:
   ShelfViewVisibleBoundsTest() : text_direction_change_(GetParam()) {}
 
   void CheckAllItemsAreInBounds() {
     gfx::Rect visible_bounds = shelf_view_->GetVisibleItemsBoundsInScreen();
     gfx::Rect shelf_bounds = shelf_view_->GetBoundsInScreen();
     EXPECT_TRUE(shelf_bounds.Contains(visible_bounds));
     for (int i = 0; i < test_api_->GetButtonCount(); ++i)
-      if (internal::ShelfButton* button = test_api_->GetButton(i))
+      if (ShelfButton* button = test_api_->GetButton(i))
         EXPECT_TRUE(visible_bounds.Contains(button->GetBoundsInScreen()));
     CheckAppListButtonIsInBounds();
   }
 
   void CheckAppListButtonIsInBounds() {
     gfx::Rect visible_bounds = shelf_view_->GetVisibleItemsBoundsInScreen();
     gfx::Rect app_list_button_bounds = shelf_view_->GetAppListButtonView()->
        GetBoundsInScreen();
     EXPECT_TRUE(visible_bounds.Contains(app_list_button_bounds));
   }
@@ skipping 19 matching lines @@
   test_api_->RunMessageLoopUntilAnimationsDone();
   CheckAllItemsAreInBounds();
 }
 
 INSTANTIATE_TEST_CASE_P(LtrRtl, ShelfViewTextDirectionTest, testing::Bool());
 INSTANTIATE_TEST_CASE_P(VisibleBounds, ShelfViewVisibleBoundsTest,
     testing::Bool());
 
 }  // namespace test
 }  // namespace ash