Clean up event flags a bit:

ui/events/event_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 <stddef.h>
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
@@ skipping 172 matching lines @@
 }
 
 TEST(EventTest, KeyEvent) {
   static const struct {
     KeyboardCode key_code;
     int flags;
     uint16_t character;
   } kTestData[] = {
     { VKEY_A, 0, 'a' },
     { VKEY_A, EF_SHIFT_DOWN, 'A' },
-    { VKEY_A, EF_CAPS_LOCK_DOWN, 'A' },
-    { VKEY_A, EF_SHIFT_DOWN | EF_CAPS_LOCK_DOWN, 'a' },
+    { VKEY_A, EF_CAPS_LOCK_ON, 'A' },
+    { VKEY_A, EF_SHIFT_DOWN | EF_CAPS_LOCK_ON, 'a' },
     { VKEY_A, EF_CONTROL_DOWN, 0x01 },
     { VKEY_A, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\x01' },
     { VKEY_Z, 0, 'z' },
     { VKEY_Z, EF_SHIFT_DOWN, 'Z' },
-    { VKEY_Z, EF_CAPS_LOCK_DOWN, 'Z' },
-    { VKEY_Z, EF_SHIFT_DOWN | EF_CAPS_LOCK_DOWN, 'z' },
+    { VKEY_Z, EF_CAPS_LOCK_ON, 'Z' },
+    { VKEY_Z, EF_SHIFT_DOWN | EF_CAPS_LOCK_ON, 'z' },
     { VKEY_Z, EF_CONTROL_DOWN, '\x1A' },
     { VKEY_Z, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\x1A' },
 
     { VKEY_2, EF_CONTROL_DOWN, '\0' },
     { VKEY_2, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0' },
     { VKEY_6, EF_CONTROL_DOWN, '\0' },
     { VKEY_6, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\x1E' },
     { VKEY_OEM_MINUS, EF_CONTROL_DOWN, '\0' },
     { VKEY_OEM_MINUS, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\x1F' },
     { VKEY_OEM_4, EF_CONTROL_DOWN, '\x1B' },
     { VKEY_OEM_4, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0' },
     { VKEY_OEM_5, EF_CONTROL_DOWN, '\x1C' },
     { VKEY_OEM_5, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0' },
     { VKEY_OEM_6, EF_CONTROL_DOWN, '\x1D' },
     { VKEY_OEM_6, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0' },
     { VKEY_RETURN, EF_CONTROL_DOWN, '\x0A' },
 
     { VKEY_0, 0, '0' },
     { VKEY_0, EF_SHIFT_DOWN, ')' },
-    { VKEY_0, EF_SHIFT_DOWN | EF_CAPS_LOCK_DOWN, ')' },
+    { VKEY_0, EF_SHIFT_DOWN | EF_CAPS_LOCK_ON, ')' },
     { VKEY_0, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0' },
 
     { VKEY_9, 0, '9' },
     { VKEY_9, EF_SHIFT_DOWN, '(' },
-    { VKEY_9, EF_SHIFT_DOWN | EF_CAPS_LOCK_DOWN, '(' },
+    { VKEY_9, EF_SHIFT_DOWN | EF_CAPS_LOCK_ON, '(' },
     { VKEY_9, EF_SHIFT_DOWN | EF_CONTROL_DOWN, '\0' },
 
     { VKEY_NUMPAD0, EF_CONTROL_DOWN, '\0' },
     { VKEY_NUMPAD0, EF_SHIFT_DOWN, '0' },
 
     { VKEY_NUMPAD9, EF_CONTROL_DOWN, '\0' },
     { VKEY_NUMPAD9, EF_SHIFT_DOWN, '9' },
 
     { VKEY_TAB, EF_NONE, '\t' },
     { VKEY_TAB, EF_CONTROL_DOWN, '\t' },
@@ skipping 234 matching lines @@
   MSG native_event_a_pressed_1500 = { NULL, WM_KEYDOWN, VKEY_A, lParam_a };
   MSG native_event_a_pressed_3000 = { NULL, WM_KEYDOWN, VKEY_A, lParam_a };
   MSG native_event_a_released = { NULL, WM_KEYUP, VKEY_A, lParam_a };
   MSG native_event_b_pressed = { NULL, WM_KEYUP, VKEY_B, lParam_b };
 #endif
   SetKeyEventTimestamp(native_event_a_pressed_1500, 1500);
   SetKeyEventTimestamp(native_event_a_pressed_3000, 3000);
 
   {
     KeyEvent key_a1(native_event_a_pressed);
-    EXPECT_FALSE(key_a1.IsRepeat());
+    EXPECT_FALSE(key_a1.is_repeat());
 
     KeyEvent key_a1_with_same_event(native_event_a_pressed);
-    EXPECT_FALSE(key_a1_with_same_event.IsRepeat());
+    EXPECT_FALSE(key_a1_with_same_event.is_repeat());
 
     KeyEvent key_a1_released(native_event_a_released);
-    EXPECT_FALSE(key_a1_released.IsRepeat());
+    EXPECT_FALSE(key_a1_released.is_repeat());
 
     KeyEvent key_a2(native_event_a_pressed);
-    EXPECT_FALSE(key_a2.IsRepeat());
+    EXPECT_FALSE(key_a2.is_repeat());
 
     AdvanceKeyEventTimestamp(native_event_a_pressed);
     KeyEvent key_a2_repeated(native_event_a_pressed);
-    EXPECT_TRUE(key_a2_repeated.IsRepeat());
+    EXPECT_TRUE(key_a2_repeated.is_repeat());
 
     KeyEvent key_a2_released(native_event_a_released);
-    EXPECT_FALSE(key_a2_released.IsRepeat());
+    EXPECT_FALSE(key_a2_released.is_repeat());
   }
 
   // Interleaved with different key press.
   {
     KeyEvent key_a3(native_event_a_pressed);
-    EXPECT_FALSE(key_a3.IsRepeat());
+    EXPECT_FALSE(key_a3.is_repeat());
 
     KeyEvent key_b(native_event_b_pressed);
-    EXPECT_FALSE(key_b.IsRepeat());
+    EXPECT_FALSE(key_b.is_repeat());
 
     AdvanceKeyEventTimestamp(native_event_a_pressed);
     KeyEvent key_a3_again(native_event_a_pressed);
-    EXPECT_FALSE(key_a3_again.IsRepeat());
+    EXPECT_FALSE(key_a3_again.is_repeat());
 
     AdvanceKeyEventTimestamp(native_event_a_pressed);
     KeyEvent key_a3_repeated(native_event_a_pressed);
-    EXPECT_TRUE(key_a3_repeated.IsRepeat());
+    EXPECT_TRUE(key_a3_repeated.is_repeat());
 
     AdvanceKeyEventTimestamp(native_event_a_pressed);
     KeyEvent key_a3_repeated2(native_event_a_pressed);
-    EXPECT_TRUE(key_a3_repeated2.IsRepeat());
+    EXPECT_TRUE(key_a3_repeated2.is_repeat());
 
     KeyEvent key_a3_released(native_event_a_released);
-    EXPECT_FALSE(key_a3_released.IsRepeat());
+    EXPECT_FALSE(key_a3_released.is_repeat());
   }
 
   // Hold the key longer than max auto repeat timeout.
   {
     KeyEvent key_a4_0(native_event_a_pressed);
-    EXPECT_FALSE(key_a4_0.IsRepeat());
+    EXPECT_FALSE(key_a4_0.is_repeat());
 
     KeyEvent key_a4_1500(native_event_a_pressed_1500);
-    EXPECT_TRUE(key_a4_1500.IsRepeat());
+    EXPECT_TRUE(key_a4_1500.is_repeat());
 
     KeyEvent key_a4_3000(native_event_a_pressed_3000);
-    EXPECT_TRUE(key_a4_3000.IsRepeat());
+    EXPECT_TRUE(key_a4_3000.is_repeat());
 
     KeyEvent key_a4_released(native_event_a_released);
-    EXPECT_FALSE(key_a4_released.IsRepeat());
+    EXPECT_FALSE(key_a4_released.is_repeat());
   }
 
 #if defined(USE_X11)
   {
     KeyEvent key_a4_pressed(native_event_a_pressed);
-    EXPECT_FALSE(key_a4_pressed.IsRepeat());
+    EXPECT_FALSE(key_a4_pressed.is_repeat());
 
     KeyEvent key_a4_pressed_nonstandard_state(
         native_event_a_pressed_nonstandard_state);
-    EXPECT_FALSE(key_a4_pressed_nonstandard_state.IsRepeat());
+    EXPECT_FALSE(key_a4_pressed_nonstandard_state.is_repeat());
   }
 #endif
 }
 #endif  // USE_X11 || OS_WIN
 
 TEST(EventTest, TouchEventRadiusDefaultsToOtherAxis) {
   const base::TimeDelta time = base::TimeDelta::FromMilliseconds(0);
   const float non_zero_length1 = 30;
   const float non_zero_length2 = 46;
 
@@ skipping 135 matching lines @@
   EXPECT_EQ(EventPointerType::POINTER_TYPE_PEN,
             stylus_event_copy.pointer_details().pointer_type());
   EXPECT_EQ(21.0f, stylus_event_copy.pointer_details().force());
   EXPECT_EQ(45.0f, stylus_event_copy.pointer_details().tilt_x());
   EXPECT_EQ(-45.0f, stylus_event_copy.pointer_details().tilt_y());
   EXPECT_EQ(0.0f, stylus_event_copy.pointer_details().radius_x());
   EXPECT_EQ(0.0f, stylus_event_copy.pointer_details().radius_y());
 }
 
 }  // namespace ui