accelerators: Remove deprecated Accelerator ctor that takes booleans.

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 "base/compiler_specific.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/events.h"
 #include "ui/base/keycodes/keyboard_codes.h"
@@ skipping 29 matching lines @@
 bool TestTarget::AcceleratorPressed(const Accelerator& accelerator) {
   ++accelerator_pressed_count_;
   return true;
 }
 
 bool TestTarget::CanHandleAccelerators() const {
   return true;
 }
 
 Accelerator GetAccelerator(KeyboardCode code, int mask) {
-  return Accelerator(code, mask & (1 << 0), mask & (1 << 1), mask & (1 << 2));
+  return Accelerator(code, mask);
 }
 
 }  // namespace
 
 class AcceleratorManagerTest : public testing::Test {
  public:
   AcceleratorManagerTest() {}
   virtual ~AcceleratorManagerTest() {}
 
   AcceleratorManager manager_;
 };
 
 TEST_F(AcceleratorManagerTest, Register) {
-  const Accelerator accelerator_a(VKEY_A, false, false, false);
+  const Accelerator accelerator_a(VKEY_A, EF_NONE);
   TestTarget target;
   manager_.Register(accelerator_a, AcceleratorManager::kNormalPriority,
                     &target);
 
   // 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, false, false, false);
+  const Accelerator accelerator_a(VKEY_A, EF_NONE);
   TestTarget target1;
   manager_.Register(accelerator_a, AcceleratorManager::kNormalPriority,
                     &target1);
   TestTarget target2;
   manager_.Register(accelerator_a, AcceleratorManager::kNormalPriority,
                     &target2);
 
   // 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, false, false, false);
+  const Accelerator accelerator_a(VKEY_A, EF_NONE);
   TestTarget target;
   manager_.Register(accelerator_a, AcceleratorManager::kNormalPriority,
                     &target);
-  const Accelerator accelerator_b(VKEY_B, false, false, false);
+  const Accelerator accelerator_b(VKEY_B, EF_NONE);
   manager_.Register(accelerator_b, AcceleratorManager::kNormalPriority,
                     &target);
 
   // Unregistering a different accelerator does not affect the other
   // accelerator.
   manager_.Unregister(accelerator_b, &target);
   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_FALSE(manager_.Process(accelerator_a));
   EXPECT_EQ(0, target.accelerator_pressed_count());
 }
 
 TEST_F(AcceleratorManagerTest, UnregisterAll) {
-  const Accelerator accelerator_a(VKEY_A, false, false, false);
+  const Accelerator accelerator_a(VKEY_A, EF_NONE);
   TestTarget target1;
   manager_.Register(accelerator_a, AcceleratorManager::kNormalPriority,
                     &target1);
-  const Accelerator accelerator_b(VKEY_B, false, false, false);
+  const Accelerator accelerator_b(VKEY_B, EF_NONE);
   manager_.Register(accelerator_b, AcceleratorManager::kNormalPriority,
                     &target1);
-  const Accelerator accelerator_c(VKEY_C, false, false, false);
+  const Accelerator accelerator_c(VKEY_C, EF_NONE);
   TestTarget target2;
   manager_.Register(accelerator_c, AcceleratorManager::kNormalPriority,
                     &target2);
   manager_.UnregisterAll(&target1);
 
   // 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());
 
@@ skipping 43 matching lines @@
           << text << ", " << test_text;  // different modifiers
     }
 
     EXPECT_EQ(last_count + 1, target.accelerator_pressed_count()) << text;
     manager_.UnregisterAll(&target);
   }
 }
 
 }  // namespace test
 }  // namespace ui