MacViews: Fix duplicate definition of ExtensionKeyBindingRegistry::SetShortcutHandlingSuspended

ui/views/focus/focus_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/views/focus/focus_manager.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/window.h"
 #include "ui/base/accelerators/accelerator.h"
+#include "ui/base/accelerators/accelerator_processor.h"
 #include "ui/base/ime/dummy_text_input_client.h"
 #include "ui/base/ime/text_input_focus_manager.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/views/accessible_pane_view.h"
 #include "ui/views/controls/button/label_button.h"
 #include "ui/views/focus/focus_manager_factory.h"
 #include "ui/views/focus/widget_focus_manager.h"
 #include "ui/views/test/focus_manager_test.h"
 #include "ui/views/widget/widget.h"
@@ skipping 156 matching lines @@
   }
 
  private:
   int accelerator_count_;  // number of times that the accelerator is activated
   bool process_accelerator_;  // return value of AcceleratorPressed
   bool can_handle_accelerators_;  // return value of CanHandleAccelerators
 
   DISALLOW_COPY_AND_ASSIGN(TestAcceleratorTarget);
 };
 
+// Consumes and counts accelerator calls.
+class TestAcceleratorProcessor : public ui::AcceleratorProcessor {
+ public:
+  TestAcceleratorProcessor() : accelerator_count_(0) {}
+
+  int accelerator_count() const { return accelerator_count_; }
+
+  bool ProcessAccelerator(const ui::Accelerator& accelerator) override {
+    ++accelerator_count_;
+    return true;
+  }
+
+  ui::AcceleratorTarget* GetTargetForAccelerator(
+      const ui::Accelerator& accelerator) const override {
+    return nullptr;
+  }
+
+ private:
+  int accelerator_count_;  // number of times that the accelerator is activated
+
+  DISALLOW_COPY_AND_ASSIGN(TestAcceleratorProcessor);
+};
+
 TEST_F(FocusManagerTest, CallsNormalAcceleratorTarget) {
   FocusManager* focus_manager = GetFocusManager();
   ui::Accelerator return_accelerator(ui::VKEY_RETURN, ui::EF_NONE);
   ui::Accelerator escape_accelerator(ui::VKEY_ESCAPE, ui::EF_NONE);
 
   TestAcceleratorTarget return_target(true);
   TestAcceleratorTarget escape_target(true);
   EXPECT_EQ(return_target.accelerator_count(), 0);
   EXPECT_EQ(escape_target.accelerator_count(), 0);
-  EXPECT_EQ(NULL,
-            focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
-  EXPECT_EQ(NULL,
-            focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
+  EXPECT_EQ(NULL, focus_manager->GetTargetForAccelerator(return_accelerator));
+  EXPECT_EQ(NULL, focus_manager->GetTargetForAccelerator(escape_accelerator));
 
   // Register targets.
   focus_manager->RegisterAccelerator(return_accelerator,
                                      ui::AcceleratorManager::kNormalPriority,
                                      &return_target);
   focus_manager->RegisterAccelerator(escape_accelerator,
                                      ui::AcceleratorManager::kNormalPriority,
                                      &escape_target);
 
   // Checks if the correct target is registered.
   EXPECT_EQ(&return_target,
-            focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
+            focus_manager->GetTargetForAccelerator(return_accelerator));
   EXPECT_EQ(&escape_target,
-            focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
+            focus_manager->GetTargetForAccelerator(escape_accelerator));
 
   // Hitting the return key.
   EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator));
   EXPECT_EQ(return_target.accelerator_count(), 1);
   EXPECT_EQ(escape_target.accelerator_count(), 0);
 
   // Hitting the escape key.
   EXPECT_TRUE(focus_manager->ProcessAccelerator(escape_accelerator));
   EXPECT_EQ(return_target.accelerator_count(), 1);
   EXPECT_EQ(escape_target.accelerator_count(), 1);
 
   // Register another target for the return key.
   TestAcceleratorTarget return_target2(true);
   EXPECT_EQ(return_target2.accelerator_count(), 0);
   focus_manager->RegisterAccelerator(return_accelerator,
                                      ui::AcceleratorManager::kNormalPriority,
                                      &return_target2);
   EXPECT_EQ(&return_target2,
-            focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
+            focus_manager->GetTargetForAccelerator(return_accelerator));
 
   // Hitting the return key; return_target2 has the priority.
   EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator));
   EXPECT_EQ(return_target.accelerator_count(), 1);
   EXPECT_EQ(return_target2.accelerator_count(), 1);
 
   // Register a target that does not process the accelerator event.
   TestAcceleratorTarget return_target3(false);
   EXPECT_EQ(return_target3.accelerator_count(), 0);
   focus_manager->RegisterAccelerator(return_accelerator,
                                      ui::AcceleratorManager::kNormalPriority,
                                      &return_target3);
   EXPECT_EQ(&return_target3,
-            focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
+            focus_manager->GetTargetForAccelerator(return_accelerator));
 
   // Hitting the return key.
   // Since the event handler of return_target3 returns false, return_target2
   // should be called too.
   EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator));
   EXPECT_EQ(return_target.accelerator_count(), 1);
   EXPECT_EQ(return_target2.accelerator_count(), 2);
   EXPECT_EQ(return_target3.accelerator_count(), 1);
 
   // Unregister return_target2.
   focus_manager->UnregisterAccelerator(return_accelerator, &return_target2);
   EXPECT_EQ(&return_target3,
-            focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
+            focus_manager->GetTargetForAccelerator(return_accelerator));
 
   // Hitting the return key. return_target3 and return_target should be called.
   EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator));
   EXPECT_EQ(return_target.accelerator_count(), 2);
   EXPECT_EQ(return_target2.accelerator_count(), 2);
   EXPECT_EQ(return_target3.accelerator_count(), 2);
 
   // Unregister targets.
   focus_manager->UnregisterAccelerator(return_accelerator, &return_target);
   focus_manager->UnregisterAccelerator(return_accelerator, &return_target3);
   focus_manager->UnregisterAccelerator(escape_accelerator, &escape_target);
 
   // Now there is no target registered.
-  EXPECT_EQ(NULL,
-            focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
-  EXPECT_EQ(NULL,
-            focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
+  EXPECT_EQ(NULL, focus_manager->GetTargetForAccelerator(return_accelerator));
+  EXPECT_EQ(NULL, focus_manager->GetTargetForAccelerator(escape_accelerator));
 
   // Hitting the return key and the escape key. Nothing should happen.
   EXPECT_FALSE(focus_manager->ProcessAccelerator(return_accelerator));
   EXPECT_EQ(return_target.accelerator_count(), 2);
   EXPECT_EQ(return_target2.accelerator_count(), 2);
   EXPECT_EQ(return_target3.accelerator_count(), 2);
   EXPECT_FALSE(focus_manager->ProcessAccelerator(escape_accelerator));
   EXPECT_EQ(escape_target.accelerator_count(), 1);
 }
 
 TEST_F(FocusManagerTest, HighPriorityHandlers) {
   FocusManager* focus_manager = GetFocusManager();
   ui::Accelerator escape_accelerator(ui::VKEY_ESCAPE, ui::EF_NONE);
 
   TestAcceleratorTarget escape_target_high(true);
   TestAcceleratorTarget escape_target_normal(true);
   EXPECT_EQ(escape_target_high.accelerator_count(), 0);
   EXPECT_EQ(escape_target_normal.accelerator_count(), 0);
-  EXPECT_EQ(NULL,
-      focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
+  EXPECT_EQ(NULL, focus_manager->GetTargetForAccelerator(escape_accelerator));
   EXPECT_FALSE(focus_manager->HasPriorityHandler(escape_accelerator));
 
   // Register high priority target.
   focus_manager->RegisterAccelerator(escape_accelerator,
                                      ui::AcceleratorManager::kHighPriority,
                                      &escape_target_high);
   EXPECT_EQ(&escape_target_high,
-     focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
+            focus_manager->GetTargetForAccelerator(escape_accelerator));
   EXPECT_TRUE(focus_manager->HasPriorityHandler(escape_accelerator));
 
   // Hit the escape key.
   EXPECT_TRUE(focus_manager->ProcessAccelerator(escape_accelerator));
   EXPECT_EQ(escape_target_high.accelerator_count(), 1);
   EXPECT_EQ(escape_target_normal.accelerator_count(), 0);
 
   // Add a normal priority target and make sure it doesn't see the key.
   focus_manager->RegisterAccelerator(escape_accelerator,
                                      ui::AcceleratorManager::kNormalPriority,
                                      &escape_target_normal);
 
   // Checks if the correct target is registered (same as before, the high
   // priority one).
   EXPECT_EQ(&escape_target_high,
-      focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
+            focus_manager->GetTargetForAccelerator(escape_accelerator));
   EXPECT_TRUE(focus_manager->HasPriorityHandler(escape_accelerator));
 
   // Hit the escape key.
   EXPECT_TRUE(focus_manager->ProcessAccelerator(escape_accelerator));
   EXPECT_EQ(escape_target_high.accelerator_count(), 2);
   EXPECT_EQ(escape_target_normal.accelerator_count(), 0);
 
   // Unregister the high priority accelerator.
   focus_manager->UnregisterAccelerator(escape_accelerator, &escape_target_high);
   EXPECT_EQ(&escape_target_normal,
-      focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
+            focus_manager->GetTargetForAccelerator(escape_accelerator));
   EXPECT_FALSE(focus_manager->HasPriorityHandler(escape_accelerator));
 
   // Hit the escape key.
   EXPECT_TRUE(focus_manager->ProcessAccelerator(escape_accelerator));
   EXPECT_EQ(escape_target_high.accelerator_count(), 2);
   EXPECT_EQ(escape_target_normal.accelerator_count(), 1);
 
   // Add the high priority target back and make sure it starts seeing the key.
   focus_manager->RegisterAccelerator(escape_accelerator,
                                      ui::AcceleratorManager::kHighPriority,
                                      &escape_target_high);
   EXPECT_EQ(&escape_target_high,
-      focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
+            focus_manager->GetTargetForAccelerator(escape_accelerator));
   EXPECT_TRUE(focus_manager->HasPriorityHandler(escape_accelerator));
 
   // Hit the escape key.
   EXPECT_TRUE(focus_manager->ProcessAccelerator(escape_accelerator));
   EXPECT_EQ(escape_target_high.accelerator_count(), 3);
   EXPECT_EQ(escape_target_normal.accelerator_count(), 1);
 
   // Unregister the normal priority accelerator.
   focus_manager->UnregisterAccelerator(
       escape_accelerator, &escape_target_normal);
   EXPECT_EQ(&escape_target_high,
-      focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
+            focus_manager->GetTargetForAccelerator(escape_accelerator));
   EXPECT_TRUE(focus_manager->HasPriorityHandler(escape_accelerator));
 
   // Hit the escape key.
   EXPECT_TRUE(focus_manager->ProcessAccelerator(escape_accelerator));
   EXPECT_EQ(escape_target_high.accelerator_count(), 4);
   EXPECT_EQ(escape_target_normal.accelerator_count(), 1);
 
   // Unregister the high priority accelerator.
   focus_manager->UnregisterAccelerator(escape_accelerator, &escape_target_high);
-  EXPECT_EQ(NULL,
-      focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
+  EXPECT_EQ(NULL, focus_manager->GetTargetForAccelerator(escape_accelerator));
   EXPECT_FALSE(focus_manager->HasPriorityHandler(escape_accelerator));
 
   // Hit the escape key (no change, no targets registered).
   EXPECT_FALSE(focus_manager->ProcessAccelerator(escape_accelerator));
   EXPECT_EQ(escape_target_high.accelerator_count(), 4);
   EXPECT_EQ(escape_target_normal.accelerator_count(), 1);
 }
 
 TEST_F(FocusManagerTest, CallsEnabledAcceleratorTargetsOnly) {
   FocusManager* focus_manager = GetFocusManager();
@@ skipping 26 matching lines @@
   EXPECT_EQ(1, return_target2.accelerator_count());
 
   // Enabling the target again causes the accelerators to be processed again.
   return_target1.set_can_handle_accelerators(true);
   return_target2.set_can_handle_accelerators(true);
   EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator));
   EXPECT_EQ(1, return_target1.accelerator_count());
   EXPECT_EQ(2, return_target2.accelerator_count());
 }
 
+TEST_F(FocusManagerTest, CallsAcceleratorPreProcessor) {
+  FocusManager* focus_manager = GetFocusManager();
+  ui::Accelerator return_accelerator(ui::VKEY_RETURN, ui::EF_NONE);
+  TestAcceleratorTarget return_target(true);
+  focus_manager->RegisterAccelerator(return_accelerator,
+                                     ui::AcceleratorManager::kNormalPriority,
+                                     &return_target);
+
+  TestAcceleratorProcessor pre_processor;
+  focus_manager->AddAcceleratorPreProcessor(&pre_processor);
+  EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator));
+  EXPECT_EQ(1, pre_processor.accelerator_count());
+  EXPECT_EQ(0, return_target.accelerator_count());
+
+  focus_manager->RemoveAcceleratorProcessor(&pre_processor);
+  EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator));
+  EXPECT_EQ(1, pre_processor.accelerator_count());
+  EXPECT_EQ(1, return_target.accelerator_count());
+}
+
+TEST_F(FocusManagerTest, CallsAcceleratorPostProcessor) {
+  FocusManager* focus_manager = GetFocusManager();
+  ui::Accelerator return_accelerator(ui::VKEY_RETURN, ui::EF_NONE);
+
+  TestAcceleratorProcessor post_processor;
+  focus_manager->AddAcceleratorPostProcessor(&post_processor);
+  EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator));
+  EXPECT_EQ(1, post_processor.accelerator_count());
+
+  focus_manager->RemoveAcceleratorProcessor(&post_processor);
+  EXPECT_FALSE(focus_manager->ProcessAccelerator(return_accelerator));
+  EXPECT_EQ(1, post_processor.accelerator_count());
+}
+
 // Unregisters itself when its accelerator is invoked.
 class SelfUnregisteringAcceleratorTarget : public ui::AcceleratorTarget {
  public:
   SelfUnregisteringAcceleratorTarget(ui::Accelerator accelerator,
                                      FocusManager* focus_manager)
       : accelerator_(accelerator),
         focus_manager_(focus_manager),
         accelerator_count_(0) {
   }
 
@@ skipping 13 matching lines @@
   int accelerator_count_;
 
   DISALLOW_COPY_AND_ASSIGN(SelfUnregisteringAcceleratorTarget);
 };
 
 TEST_F(FocusManagerTest, CallsSelfDeletingAcceleratorTarget) {
   FocusManager* focus_manager = GetFocusManager();
   ui::Accelerator return_accelerator(ui::VKEY_RETURN, ui::EF_NONE);
   SelfUnregisteringAcceleratorTarget target(return_accelerator, focus_manager);
   EXPECT_EQ(target.accelerator_count(), 0);
-  EXPECT_EQ(NULL,
-            focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
+  EXPECT_EQ(NULL, focus_manager->GetTargetForAccelerator(return_accelerator));
 
   // Register the target.
   focus_manager->RegisterAccelerator(return_accelerator,
                                      ui::AcceleratorManager::kNormalPriority,
                                      &target);
   EXPECT_EQ(&target,
-            focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
+            focus_manager->GetTargetForAccelerator(return_accelerator));
 
   // Hitting the return key. The target will be unregistered.
   EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator));
   EXPECT_EQ(target.accelerator_count(), 1);
-  EXPECT_EQ(NULL,
-            focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
+  EXPECT_EQ(NULL, focus_manager->GetTargetForAccelerator(return_accelerator));
 
   // Hitting the return key again; nothing should happen.
   EXPECT_FALSE(focus_manager->ProcessAccelerator(return_accelerator));
   EXPECT_EQ(target.accelerator_count(), 1);
 }
 
 class FocusManagerDtorTest : public FocusManagerTest {
  protected:
   typedef std::vector<std::string> DtorTrackVector;
 
   class FocusManagerDtorTracked : public FocusManager {
    public:
     FocusManagerDtorTracked(Widget* widget, DtorTrackVector* dtor_tracker)
-      : FocusManager(widget, NULL /* delegate */),
-        dtor_tracker_(dtor_tracker) {
-    }
+        : FocusManager(widget), dtor_tracker_(dtor_tracker) {}
 
     ~FocusManagerDtorTracked() override {
       dtor_tracker_->push_back("FocusManagerDtorTracked");
     }
 
     DtorTrackVector* dtor_tracker_;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(FocusManagerDtorTracked);
   };
@@ skipping 417 matching lines @@
   EXPECT_EQ(view1, GetFocusManager()->GetFocusedView());
 
   // Allow focus to go to the parent, and focus backwards which should now move
   // up |widget_view| (in the parent).
   delegate->set_should_advance_focus_to_parent(true);
   GetFocusManager()->AdvanceFocus(true);
   EXPECT_EQ(widget_view, GetFocusManager()->GetFocusedView());
 }
 
 }  // namespace views