wip: Add ui::EventType parameter.

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 "base/utf_string_conversions.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/views/controls/button/text_button.h"
 #include "ui/views/controls/textfield/textfield.h"
 #include "ui/views/focus/accelerator_handler.h"
@@ skipping 196 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);
 };
 
 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);
+  ui::Accelerator return_accelerator(ui::VKEY_RETURN,
+                                     ui::EF_NONE,
+                                     ui::ET_KEY_PRESSED);
+  ui::Accelerator escape_accelerator(ui::VKEY_ESCAPE,
+                                     ui::EF_NONE,
+                                     ui::ET_KEY_PRESSED);
 
   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));
 
@@ skipping 78 matching lines @@
   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);
+  ui::Accelerator escape_accelerator(ui::VKEY_ESCAPE,
+                                     ui::EF_NONE,
+                                     ui::ET_KEY_PRESSED);
 
   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_FALSE(focus_manager->HasPriorityHandler(escape_accelerator));
 
   // Register high priority target.
@@ skipping 68 matching lines @@
   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();
-  ui::Accelerator return_accelerator(ui::VKEY_RETURN, ui::EF_NONE);
+  ui::Accelerator return_accelerator(ui::VKEY_RETURN,
+                                     ui::EF_NONE,
+                                     ui::ET_KEY_PRESSED);
 
   TestAcceleratorTarget return_target1(true);
   TestAcceleratorTarget return_target2(true);
 
   focus_manager->RegisterAccelerator(return_accelerator,
                                      ui::AcceleratorManager::kNormalPriority,
                                      &return_target1);
   focus_manager->RegisterAccelerator(return_accelerator,
                                      ui::AcceleratorManager::kNormalPriority,
                                      &return_target2);
@@ skipping 47 matching lines @@
  private:
   ui::Accelerator accelerator_;
   FocusManager* focus_manager_;
   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);
+  ui::Accelerator return_accelerator(ui::VKEY_RETURN,
+                                     ui::EF_NONE,
+                                     ui::ET_KEY_PRESSED);
   SelfUnregisteringAcceleratorTarget target(return_accelerator, focus_manager);
   EXPECT_EQ(target.accelerator_count(), 0);
   EXPECT_EQ(NULL,
             focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
 
   // Register the target.
   focus_manager->RegisterAccelerator(return_accelerator,
                                      ui::AcceleratorManager::kNormalPriority,
                                      &target);
   EXPECT_EQ(&target,
@@ skipping 113 matching lines @@
 
   // Test window, button and focus manager should all be destructed.
   ASSERT_EQ(3, static_cast<int>(dtor_tracker_.size()));
 
   // Focus manager should be the last one to destruct.
   ASSERT_STREQ("FocusManagerDtorTracked", dtor_tracker_[2].c_str());
 }
 #endif
 
 }  // namespace views