Rename BrowserActionView to ToolbarActionView

chrome/browser/ui/views/toolbar/browser_actions_container_browsertest.cc

 // Copyright 2013 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/views/toolbar/browser_actions_container.h"
 
 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 #include "chrome/browser/extensions/browser_action_test_util.h"
 #include "chrome/browser/extensions/extension_toolbar_model.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/browser_window_testing_views.h"
 #include "chrome/browser/ui/toolbar/browser_actions_bar_browsertest.h"
 #include "chrome/browser/ui/views/extensions/browser_action_drag_data.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
-#include "chrome/browser/ui/views/toolbar/browser_action_view.h"
+#include "chrome/browser/ui/views/toolbar/toolbar_action_view.h"
 #include "chrome/browser/ui/views/toolbar/toolbar_view.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/common/extension.h"
 #include "ui/base/dragdrop/drop_target_event.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/views/view.h"
 
 // TODO(devlin): Continue moving any tests that should be platform independent
 // from this file to the crossplatform tests in
@@ skipping 14 matching lines @@
 
   BrowserActionsContainer* container =
       BrowserView::GetBrowserViewForBrowser(browser())
           ->toolbar()->browser_actions();
 
   // Simulate a drag and drop to the right.
   ui::OSExchangeData drop_data;
   // Drag extension A from index 0...
   BrowserActionDragData browser_action_drag_data(extension_a()->id(), 0u);
   browser_action_drag_data.Write(profile(), &drop_data);
-  BrowserActionView* view = container->GetViewForExtension(extension_b());
+  ToolbarActionView* view = container->GetViewForExtension(extension_b());
   // ...to the right of extension B.
   gfx::Point location(view->x() + view->width(), view->y());
   ui::DropTargetEvent target_event(
       drop_data, location, location, ui::DragDropTypes::DRAG_MOVE);
 
   // Drag and drop.
   container->OnDragUpdated(target_event);
   container->OnPerformDrop(target_event);
 
   // The order should now be B A C, since A was dragged to the right of B.
@@ skipping 185 matching lines @@
   EXPECT_EQ(extension_b()->id(), first->GetIdAt(1u));
   EXPECT_EQ(extension_b()->id(), second->GetIdAt(1u));
   EXPECT_EQ(extension_c()->id(), first->GetIdAt(2u));
   EXPECT_EQ(extension_c()->id(), second->GetIdAt(2u));
 
   // Simulate a drag and drop to the right.
   ui::OSExchangeData drop_data;
   // Drag extension A from index 0...
   BrowserActionDragData browser_action_drag_data(extension_a()->id(), 0u);
   browser_action_drag_data.Write(profile(), &drop_data);
-  BrowserActionView* view = first->GetViewForExtension(extension_b());
+  ToolbarActionView* view = first->GetViewForExtension(extension_b());
   // ...to the right of extension B.
   gfx::Point location(view->x() + view->width(), view->y());
   ui::DropTargetEvent target_event(
       drop_data, location, location, ui::DragDropTypes::DRAG_MOVE);
 
   // Drag and drop.
   first->OnDragUpdated(target_event);
   first->OnPerformDrop(target_event);
 
   // The new order, B A C, should be reflected in *both* containers, even
@@ skipping 22 matching lines @@
   EXPECT_EQ(3, browser_actions_bar()->VisibleBrowserActions());
   EXPECT_EQ(3, browser_actions_bar()->NumberOfBrowserActions());
 
   BrowserActionsContainer* container = browser()
                                            ->window()
                                            ->GetBrowserWindowTesting()
                                            ->GetToolbarView()
                                            ->browser_actions();
 
   // Currently, dragging should be enabled.
-  BrowserActionView* action_view = container->GetBrowserActionViewAt(0);
+  ToolbarActionView* action_view = container->GetToolbarActionViewAt(0);
   ASSERT_TRUE(action_view);
   gfx::Point point(action_view->x(), action_view->y());
   EXPECT_TRUE(container->CanStartDragForView(action_view, point, point));
 
   extensions::ExtensionToolbarModel* model =
       extensions::ExtensionToolbarModel::Get(profile());
 
   extensions::ExtensionIdList extension_ids;
   extension_ids.push_back(extension_a()->id());
   extension_ids.push_back(extension_b()->id());
   model->HighlightExtensions(extension_ids);
 
   // Only two browser actions should be visible.
   EXPECT_EQ(2, browser_actions_bar()->VisibleBrowserActions());
   EXPECT_EQ(2, browser_actions_bar()->NumberOfBrowserActions());
 
   // We shouldn't be able to drag in highlight mode.
-  action_view = container->GetBrowserActionViewAt(0);
+  action_view = container->GetToolbarActionViewAt(0);
   EXPECT_FALSE(container->CanStartDragForView(action_view, point, point));
 
   // We should go back to normal after leaving highlight mode.
   model->StopHighlighting();
   EXPECT_EQ(3, browser_actions_bar()->VisibleBrowserActions());
   EXPECT_EQ(3, browser_actions_bar()->NumberOfBrowserActions());
-  action_view = container->GetBrowserActionViewAt(0);
+  action_view = container->GetToolbarActionViewAt(0);
   EXPECT_TRUE(container->CanStartDragForView(action_view, point, point));
 }
 
 // Test the behavior of the overflow container for Extension Actions.
 class BrowserActionsContainerOverflowTest
     : public BrowserActionsBarBrowserTest {
  public:
   BrowserActionsContainerOverflowTest() : main_bar_(NULL), model_(NULL) {
   }
   virtual ~BrowserActionsContainerOverflowTest() {
   }
 
  protected:
-  // Returns true if the order of the BrowserActionViews in |main_bar_|
+  // Returns true if the order of the ToolbarActionViews in |main_bar_|
   // and |overflow_bar_| match.
   bool ViewOrdersMatch();
 
   // Returns Success if the visible count matches |expected_visible|. This means
   // that the number of visible browser actions in |main_bar_| is
   // |expected_visible| and shows the first icons, and that the overflow bar
   // shows all (and only) the remainder.
   testing::AssertionResult VerifyVisibleCount(size_t expected_visible);
 
   // Accessors.
@@ skipping 39 matching lines @@
   model_ = extensions::ExtensionToolbarModel::Get(profile());
 }
 
 void BrowserActionsContainerOverflowTest::TearDownOnMainThread() {
   overflow_bar_.reset();
   enable_redesign_.reset();
   BrowserActionsBarBrowserTest::TearDownOnMainThread();
 }
 
 bool BrowserActionsContainerOverflowTest::ViewOrdersMatch() {
-  if (main_bar_->num_browser_actions() !=
-      overflow_bar_->num_browser_actions())
+  if (main_bar_->num_toolbar_actions() !=
+      overflow_bar_->num_toolbar_actions())
     return false;
-  for (size_t i = 0; i < main_bar_->num_browser_actions(); ++i) {
+  for (size_t i = 0; i < main_bar_->num_toolbar_actions(); ++i) {
     if (main_bar_->GetIdAt(i) != overflow_bar_->GetIdAt(i))
       return false;
   }
   return true;
 }
 
 testing::AssertionResult
 BrowserActionsContainerOverflowTest::VerifyVisibleCount(
     size_t expected_visible) {
   // Views order should always match (as it is based directly off the model).
   if (!ViewOrdersMatch())
     return testing::AssertionFailure() << "View orders don't match";
 
   // Loop through and check each browser action for proper visibility (which
   // implicitly also guarantees that the proper number are visible).
-  for (size_t i = 0; i < overflow_bar_->num_browser_actions(); ++i) {
+  for (size_t i = 0; i < overflow_bar_->num_toolbar_actions(); ++i) {
     bool visible = i < expected_visible;
-    if (main_bar_->GetBrowserActionViewAt(i)->visible() != visible) {
+    if (main_bar_->GetToolbarActionViewAt(i)->visible() != visible) {
       return testing::AssertionFailure() << "Index " << i <<
           " has improper visibility in main: " << !visible;
     }
-    if (overflow_bar_->GetBrowserActionViewAt(i)->visible() == visible) {
+    if (overflow_bar_->GetToolbarActionViewAt(i)->visible() == visible) {
       return testing::AssertionFailure() << "Index " << i <<
           " has improper visibility in overflow: " << visible;
     }
   }
   return testing::AssertionSuccess();
 }
 
 // Test the basic functionality of the BrowserActionsContainer in overflow mode.
 IN_PROC_BROWSER_TEST_F(BrowserActionsContainerOverflowTest,
                        TestBasicActionOverflow) {
   LoadExtensions();
 
   // Since the overflow bar isn't attached to a view, we have to kick it in
   // order to retrigger layout each time we change the number of icons in the
   // bar.
   overflow_bar()->Layout();
 
   // All actions are showing, and are in the installation order.
   EXPECT_EQ(-1, model()->GetVisibleIconCount());
-  ASSERT_EQ(3u, main_bar()->num_browser_actions());
+  ASSERT_EQ(3u, main_bar()->num_toolbar_actions());
   EXPECT_EQ(extension_a()->id(), main_bar()->GetIdAt(0u));
   EXPECT_EQ(extension_b()->id(), main_bar()->GetIdAt(1u));
   EXPECT_EQ(extension_c()->id(), main_bar()->GetIdAt(2u));
   EXPECT_TRUE(VerifyVisibleCount(3u));
 
   // Reduce the visible count to 2. Order should be unchanged (A B C), but
   // only A and B should be visible on the main bar.
   model()->SetVisibleIconCount(2u);
   overflow_bar()->Layout();  // Kick.
   EXPECT_EQ(extension_a()->id(), main_bar()->GetIdAt(0u));
@@ skipping 27 matching lines @@
 // Test drag and drop between the overflow container and the main container.
 IN_PROC_BROWSER_TEST_F(BrowserActionsContainerOverflowTest,
                        TestOverflowDragging) {
   LoadExtensions();
 
   // Start with one extension in overflow.
   model()->SetVisibleIconCount(2u);
   overflow_bar()->Layout();
 
   // Verify starting state is A B [C].
-  ASSERT_EQ(3u, main_bar()->num_browser_actions());
+  ASSERT_EQ(3u, main_bar()->num_toolbar_actions());
   EXPECT_EQ(extension_a()->id(), main_bar()->GetIdAt(0u));
   EXPECT_EQ(extension_b()->id(), main_bar()->GetIdAt(1u));
   EXPECT_EQ(extension_c()->id(), main_bar()->GetIdAt(2u));
   EXPECT_TRUE(VerifyVisibleCount(2u));
 
   // Drag extension A (on the main bar) to the left of extension C (in
   // overflow).
   ui::OSExchangeData drop_data;
   BrowserActionDragData browser_action_drag_data(extension_a()->id(), 0u);
   browser_action_drag_data.Write(profile(), &drop_data);
-  BrowserActionView* view = overflow_bar()->GetViewForExtension(extension_c());
+  ToolbarActionView* view = overflow_bar()->GetViewForExtension(extension_c());
   gfx::Point location(view->x(), view->y());
   ui::DropTargetEvent target_event(
       drop_data, location, location, ui::DragDropTypes::DRAG_MOVE);
 
   overflow_bar()->OnDragUpdated(target_event);
   overflow_bar()->OnPerformDrop(target_event);
   overflow_bar()->Layout();
 
   // Order should now be B [A C].
   EXPECT_EQ(extension_b()->id(), main_bar()->GetIdAt(0u));
@@ skipping 29 matching lines @@
 
   main_bar()->OnDragUpdated(target_event3);
   main_bar()->OnPerformDrop(target_event3);
 
   // Order should be A C B, and there should be no extensions in overflow.
   EXPECT_EQ(extension_a()->id(), main_bar()->GetIdAt(0u));
   EXPECT_EQ(extension_c()->id(), main_bar()->GetIdAt(1u));
   EXPECT_EQ(extension_b()->id(), main_bar()->GetIdAt(2u));
   VerifyVisibleCount(3u);
 }