Add tests for the BrowserActionsContainer in overflow mode

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/chrome_notification_types.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_browsertest.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/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/toolbar/browser_action_view.h"
 #include "chrome/browser/ui/views/toolbar/toolbar_view.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/common/extension.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/views/view.h"
 
 using extensions::Extension;
+using extensions::ExtensionToolbarModel;
+using testing::AssertionFailure;
+using testing::AssertionSuccess;
 
 class BrowserActionsContainerTest : public ExtensionBrowserTest {
  public:
   BrowserActionsContainerTest() {
   }
   virtual ~BrowserActionsContainerTest() {}
 
   virtual void SetUpCommandLine(base::CommandLine* command_line) OVERRIDE {
     BrowserActionsContainer::disable_animations_during_testing_ = true;
     ExtensionBrowserTest::SetUpCommandLine(command_line);
@@ skipping 250 matching lines @@
   action_view = container->GetBrowserActionViewAt(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);
   EXPECT_TRUE(container->CanStartDragForView(action_view, point, point));
 }
+
+// Test the behavior of the overflow container for Extension Actions.
+class BrowserActionsContainerOverflowTest : public BrowserActionsContainerTest {
+ public:
+  BrowserActionsContainerOverflowTest() : main_bar_(NULL), model_(NULL) {
+  }
+  virtual ~BrowserActionsContainerOverflowTest() {
+  }
+
+ protected:
+  // Returns true if the order of the BrowserActionViews 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.
+  BrowserActionsContainer* main_bar() { return main_bar_; }
+  BrowserActionsContainer* overflow_bar() { return overflow_bar_.get(); }
+  ExtensionToolbarModel* model() { return model_; }
+
+ private:
+  virtual void SetUpCommandLine(base::CommandLine* command_line) OVERRIDE;
+  virtual void SetUpOnMainThread() OVERRIDE;
+  virtual void TearDownOnMainThread() OVERRIDE;
+
+  // The main BrowserActionsContainer (owned by the browser view).
+  BrowserActionsContainer* main_bar_;
+
+  // The overflow BrowserActionsContainer. We manufacture this so that we don't
+  // have to open the wrench menu.
+  scoped_ptr<BrowserActionsContainer> overflow_bar_;
+
+  // The associated toolbar model.
+  ExtensionToolbarModel* model_;
+
+  // Enable the feature redesign switch.
+  scoped_ptr<extensions::FeatureSwitch::ScopedOverride> enable_redesign_;
+};
+
+void BrowserActionsContainerOverflowTest::SetUpCommandLine(
+    base::CommandLine* command_line) {
+  BrowserActionsContainerTest::SetUpCommandLine(command_line);
+  enable_redesign_.reset(new extensions::FeatureSwitch::ScopedOverride(
+      extensions::FeatureSwitch::extension_action_redesign(),
+      true));
+}
+
+void BrowserActionsContainerOverflowTest::SetUpOnMainThread() {
+  BrowserActionsContainerTest::SetUpOnMainThread();
+  main_bar_ = BrowserView::GetBrowserViewForBrowser(browser())
+                  ->toolbar()->browser_actions();
+  overflow_bar_.reset(new BrowserActionsContainer(browser(), NULL, main_bar_));
+  overflow_bar_->set_owned_by_client();
+  model_ = ExtensionToolbarModel::Get(profile());
+}
+
+void BrowserActionsContainerOverflowTest::TearDownOnMainThread() {
+  overflow_bar_.reset();
+  enable_redesign_.reset();
+  BrowserActionsContainerTest::TearDownOnMainThread();
+}
+
+bool BrowserActionsContainerOverflowTest::ViewOrdersMatch() {
+  if (main_bar_->num_browser_actions() !=
+      overflow_bar_->num_browser_actions())
+    return false;
+  for (size_t i = 0; i < main_bar_->num_browser_actions(); ++i) {
+    if (main_bar_->GetBrowserActionViewAt(i)->extension() !=
+        overflow_bar_->GetBrowserActionViewAt(i)->extension())
+      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 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) {
+    bool visible = i < expected_visible;
+    if (main_bar_->GetBrowserActionViewAt(i)->visible() != visible) {
+      return AssertionFailure() << "Index " << i <<
+          " has improper visibility in main: " << visible;

[Finnur, 2014/08/22 16:54:58]

Don't you want main_bar_->GetBrowserActionViewAt(i)->visible() instead of
|visible| here (because you should point out what it is, not what you expect it
to be)?

[Devlin, 2014/08/22 17:00:15]

Yeah, probably. :)  Done.  (For ease, just made this !visible)

+    }
+    if (overflow_bar_->GetBrowserActionViewAt(i)->visible() == visible) {
+      return AssertionFailure() << "Index " << i <<
+          " has improper visibility in overflow: " << visible;
+    }
+  }
+  return AssertionSuccess();
+}
+
+// Test the basic functionality of the BrowserActionsContainer in overflow mode.
+IN_PROC_BROWSER_TEST_F(BrowserActionsContainerOverflowTest,
+                       TestBasicActionOverflow) {
+  // Load three extensions with browser actions.
+  // TODO(devlin): Make a method to load these, and generate them rather than
+  // using files.

[Finnur, 2014/08/22 16:54:58]

Yup, I like that idea.

[Devlin, 2014/08/22 17:00:15]

Mmkay, will do in a follow up :)

+  const Extension* extension_a =
+      LoadExtension(test_data_dir_.AppendASCII("api_test")
+                                  .AppendASCII("browser_action")
+                                  .AppendASCII("basics"));
+  const Extension* extension_b =
+      LoadExtension(test_data_dir_.AppendASCII("api_test")
+                                  .AppendASCII("browser_action")
+                                  .AppendASCII("add_popup"));
+  const Extension* extension_c =
+      LoadExtension(test_data_dir_.AppendASCII("api_test")
+                                  .AppendASCII("browser_action")
+                                  .AppendASCII("remove_popup"));
+
+  // Since the overflow bar isn't attached to a view, we kinda have to kick it
+  // from time to time.
+  overflow_bar()->Layout();
+
+  // Sanity checks:
+  // All extensions loaded.
+  ASSERT_TRUE(extension_a);
+  ASSERT_TRUE(extension_b);
+  ASSERT_TRUE(extension_c);
+
+  // All actions are showing, and are in the installation order.
+  EXPECT_EQ(-1, model()->GetVisibleIconCount());
+  ASSERT_EQ(3u, main_bar()->num_browser_actions());
+  EXPECT_EQ(extension_a, main_bar()->GetBrowserActionViewAt(0)->extension());
+  EXPECT_EQ(extension_b, main_bar()->GetBrowserActionViewAt(1)->extension());
+  EXPECT_EQ(extension_c, main_bar()->GetBrowserActionViewAt(2)->extension());
+  EXPECT_TRUE(VerifyVisibleCount(3u));
+
+  // Views should always match.
+  EXPECT_TRUE(ViewOrdersMatch());
+
+  // 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()->SetVisibleIconCountForTest(2u);
+  overflow_bar()->Layout();  // Kick.
+  EXPECT_EQ(extension_a, main_bar()->GetBrowserActionViewAt(0)->extension());
+  EXPECT_EQ(extension_b, main_bar()->GetBrowserActionViewAt(1)->extension());
+  EXPECT_EQ(extension_c, main_bar()->GetBrowserActionViewAt(2)->extension());
+  EXPECT_TRUE(ViewOrdersMatch());

[Finnur, 2014/08/22 16:54:58]

This call is redundant, it is implied by calling VerifyVisibleCount().

[Devlin, 2014/08/22 17:00:15]

Yeah... I went back and forth on this.  My basic thinking was that we want to
explicitly show that we're testing it, but I guess it is kinda superfluous. 
Removed.

+  EXPECT_TRUE(VerifyVisibleCount(2u));
+
+  // Move extension C to the first position. Order should now be C A B, with
+  // C and A visible in the main bar.
+  model()->MoveExtensionIcon(extension_c, 0);
+  overflow_bar()->Layout();  // Kick.
+  EXPECT_EQ(extension_c, main_bar()->GetBrowserActionViewAt(0)->extension());
+  EXPECT_EQ(extension_a, main_bar()->GetBrowserActionViewAt(1)->extension());
+  EXPECT_EQ(extension_b, main_bar()->GetBrowserActionViewAt(2)->extension());
+  EXPECT_TRUE(ViewOrdersMatch());
+  EXPECT_TRUE(VerifyVisibleCount(2u));
+
+  // Hide action A. This results in it being sent to overflow, and reducing the
+  // visible size to 1, so the order should be C A B, with only C visible in the
+  // main bar.
+  extensions::ExtensionActionAPI::SetBrowserActionVisibility(
+      extensions::ExtensionPrefs::Get(profile()),
+      extension_a->id(),
+      false);
+  overflow_bar()->Layout();  // Kick.
+  EXPECT_EQ(extension_c, main_bar()->GetBrowserActionViewAt(0)->extension());
+  EXPECT_EQ(extension_a, main_bar()->GetBrowserActionViewAt(1)->extension());
+  EXPECT_EQ(extension_b, main_bar()->GetBrowserActionViewAt(2)->extension());
+  EXPECT_TRUE(ViewOrdersMatch());
+  EXPECT_TRUE(VerifyVisibleCount(1u));
+}