Make mash register initial batch of accelerators in single shot.

ui/base/accelerators/accelerator_manager_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 "ui/base/accelerators/accelerator_manager.h"
 
 #include <map>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
@@ skipping 78 matching lines @@
     std::swap(commands, commands_);
     return commands;
   }
 
   // AcceleratorManagerDelegate:
   void OnAcceleratorRegistered(const Accelerator& accelerator) override {
     if (!commands_.empty())
       commands_ += " ";
     commands_ += "Register " + accelerator_to_id_[accelerator];
   }
+
   void OnAcceleratorUnregistered(const Accelerator& accelerator) override {
     if (!commands_.empty())
       commands_ += " ";
     commands_ += "Unregister " + accelerator_to_id_[accelerator];
   }
 
+  void OnAcceleratorVectorRegistered(
+      const std::vector<ui::Accelerator>& accelerators) override {
+    for (auto iter = accelerators.begin(); iter != accelerators.end(); ++iter)
+      OnAcceleratorRegistered(*iter);
+  }
+
  private:
   std::map<Accelerator, std::string> accelerator_to_id_;
   std::string commands_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAcceleratorManagerDelegate);
 };
 
 }  // namespace
 
 class AcceleratorManagerTest : public testing::Test {
  public:
   AcceleratorManagerTest() : manager_(&delegate_) {}
   ~AcceleratorManagerTest() override {}
 
  protected:
   TestAcceleratorManagerDelegate delegate_;
   AcceleratorManager manager_;
 };
 
 TEST_F(AcceleratorManagerTest, Register) {
   const Accelerator accelerator_a(VKEY_A, EF_NONE);
   TestTarget target;
   delegate_.SetIdForAccelerator(accelerator_a, "a");
-  manager_.Register(accelerator_a, AcceleratorManager::kNormalPriority,
-                    &target);
+  const std::vector<ui::Accelerator>& accelerators = {accelerator_a};

[mfomitchev, 2017/01/24 22:56:03]

remove

[thanhph1, 2017/01/25 20:12:37]

Done.

+  manager_.Register(accelerators, AcceleratorManager::kNormalPriority, &target);
   EXPECT_EQ("Register a", delegate_.GetAndClearCommands());
 
   // The registered accelerator is processed.
   EXPECT_TRUE(manager_.Process(accelerator_a));
   EXPECT_EQ(1, target.accelerator_pressed_count());
 }
 
 TEST_F(AcceleratorManagerTest, RegisterMultipleTarget) {
   const Accelerator accelerator_a(VKEY_A, EF_NONE);
   delegate_.SetIdForAccelerator(accelerator_a, "a");
   TestTarget target1;
-  manager_.Register(accelerator_a, AcceleratorManager::kNormalPriority,
+  const std::vector<ui::Accelerator>& accelerators = {accelerator_a};

[mfomitchev, 2017/01/24 22:56:03]

remove

[thanhph1, 2017/01/25 20:12:37]

Done.

+  manager_.Register(accelerators, AcceleratorManager::kNormalPriority,
                     &target1);
   EXPECT_EQ("Register a", delegate_.GetAndClearCommands());
   TestTarget target2;
-  manager_.Register(accelerator_a, AcceleratorManager::kNormalPriority,
+  manager_.Register(accelerators, AcceleratorManager::kNormalPriority,
                     &target2);
   // Registering the same command shouldn't notify the delegate.
   EXPECT_TRUE(delegate_.GetAndClearCommands().empty());
 
   // If multiple targets are registered with the same accelerator, the target
   // registered later processes the accelerator.
   EXPECT_TRUE(manager_.Process(accelerator_a));
   EXPECT_EQ(0, target1.accelerator_pressed_count());
   EXPECT_EQ(1, target2.accelerator_pressed_count());
 }
 
 TEST_F(AcceleratorManagerTest, Unregister) {
   const Accelerator accelerator_a(VKEY_A, EF_NONE);
   delegate_.SetIdForAccelerator(accelerator_a, "a");
   TestTarget target;
-  manager_.Register(accelerator_a, AcceleratorManager::kNormalPriority,
-                    &target);
-  EXPECT_EQ("Register a", delegate_.GetAndClearCommands());
+
   const Accelerator accelerator_b(VKEY_B, EF_NONE);
   delegate_.SetIdForAccelerator(accelerator_b, "b");
-  manager_.Register(accelerator_b, AcceleratorManager::kNormalPriority,
-                    &target);
-  EXPECT_EQ("Register b", delegate_.GetAndClearCommands());
+
+  const std::vector<ui::Accelerator>& accelerators = {accelerator_a,

[mfomitchev, 2017/01/24 22:56:03]

Remove here and all the cases below. 
In the future, it might be a good idea to review your CL on
codereview.chromium.org after uploading but before mailing comments to catch
obvious nits like this. If you wish you can also do it even before uploading
using "git meld" or "git diff".

[thanhph1, 2017/01/25 20:12:37]

Done, thanks! It's a nice GUI good tool indeed.

+                                                      accelerator_b};
+
+  manager_.Register(accelerators, AcceleratorManager::kNormalPriority, &target);
+
+  EXPECT_EQ("Register a Register b", delegate_.GetAndClearCommands());
 
   // Unregistering a different accelerator does not affect the other
   // accelerator.
   manager_.Unregister(accelerator_b, &target);
   EXPECT_EQ("Unregister b", delegate_.GetAndClearCommands());
   EXPECT_TRUE(manager_.Process(accelerator_a));
   EXPECT_EQ(1, target.accelerator_pressed_count());
 
   // The unregistered accelerator is no longer processed.
   target.set_accelerator_pressed_count(0);
   manager_.Unregister(accelerator_a, &target);
   EXPECT_EQ("Unregister a", delegate_.GetAndClearCommands());
   EXPECT_FALSE(manager_.Process(accelerator_a));
   EXPECT_EQ(0, target.accelerator_pressed_count());
 }
 
 TEST_F(AcceleratorManagerTest, UnregisterAll) {
   const Accelerator accelerator_a(VKEY_A, EF_NONE);
   delegate_.SetIdForAccelerator(accelerator_a, "a");
   TestTarget target1;
-  manager_.Register(accelerator_a, AcceleratorManager::kNormalPriority,
-                    &target1);
+
   const Accelerator accelerator_b(VKEY_B, EF_NONE);
   delegate_.SetIdForAccelerator(accelerator_b, "b");
-  manager_.Register(accelerator_b, AcceleratorManager::kNormalPriority,
+
+  const std::vector<ui::Accelerator>& accelerators = {accelerator_a,
+                                                      accelerator_b};
+
+  manager_.Register(accelerators, AcceleratorManager::kNormalPriority,
                     &target1);
+
   const Accelerator accelerator_c(VKEY_C, EF_NONE);
   delegate_.SetIdForAccelerator(accelerator_c, "c");
+
+  const std::vector<ui::Accelerator>& accelerators_2 = {accelerator_c};
+
   TestTarget target2;
-  manager_.Register(accelerator_c, AcceleratorManager::kNormalPriority,
+  manager_.Register(accelerators_2, AcceleratorManager::kNormalPriority,
                     &target2);
+
   EXPECT_EQ("Register a Register b Register c",
             delegate_.GetAndClearCommands());
   manager_.UnregisterAll(&target1);
   {
     const std::string commands = delegate_.GetAndClearCommands();
     // Ordering is not guaranteed.
     EXPECT_TRUE(commands == "Unregister a Unregister b" ||
                 commands == "Unregister b Unregister a");
   }
 
   // All the accelerators registered for |target1| are no longer processed.
   EXPECT_FALSE(manager_.Process(accelerator_a));
   EXPECT_FALSE(manager_.Process(accelerator_b));
   EXPECT_EQ(0, target1.accelerator_pressed_count());
 
   // UnregisterAll with a different target does not affect the other target.
   EXPECT_TRUE(manager_.Process(accelerator_c));
   EXPECT_EQ(1, target2.accelerator_pressed_count());
 }
 
 TEST_F(AcceleratorManagerTest, Process) {
   TestTarget target;
 
   // Test all cases of possible modifiers.
   for (size_t i = 0; i < (1 << arraysize(kAcceleratorModifiers)); ++i) {
     const int modifiers = BuildAcceleratorModifier(i);
     Accelerator accelerator(GetAccelerator(VKEY_A, modifiers));
-    manager_.Register(accelerator, AcceleratorManager::kNormalPriority,
+    const std::vector<ui::Accelerator>& accelerators = {accelerator};
+    manager_.Register(accelerators, AcceleratorManager::kNormalPriority,
                       &target);
 
     // The registered accelerator is processed.
     const int last_count = target.accelerator_pressed_count();
     EXPECT_TRUE(manager_.Process(accelerator)) << i;
     EXPECT_EQ(last_count + 1, target.accelerator_pressed_count()) << i;
 
     // The non-registered accelerators are not processed.
     accelerator.set_type(ET_UNKNOWN);
     EXPECT_FALSE(manager_.Process(accelerator)) << i;  // different type
@@ skipping 22 matching lines @@
     manager_.UnregisterAll(&target);
   }
 }
 
 // Verifies delegate is notifed correctly when unregistering and registering
 // with the same accelerator.
 TEST_F(AcceleratorManagerTest, Reregister) {
   const Accelerator accelerator_a(VKEY_A, EF_NONE);
   TestTarget target;
   delegate_.SetIdForAccelerator(accelerator_a, "a");
-  manager_.Register(accelerator_a, AcceleratorManager::kNormalPriority,
-                    &target);
+  const std::vector<ui::Accelerator>& accelerators = {accelerator_a};
+  manager_.Register(accelerators, AcceleratorManager::kNormalPriority, &target);
   EXPECT_EQ("Register a", delegate_.GetAndClearCommands());
   manager_.UnregisterAll(&target);
   EXPECT_EQ("Unregister a", delegate_.GetAndClearCommands());
-  manager_.Register(accelerator_a, AcceleratorManager::kNormalPriority,
-                    &target);
+  manager_.Register(accelerators, AcceleratorManager::kNormalPriority, &target);
   EXPECT_EQ("Register a", delegate_.GetAndClearCommands());
 }
 
 }  // namespace test
 }  // namespace ui