clang-format all of //ash

ash/sticky_keys/sticky_keys_unittest.cc

 // Copyright 2013 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 "ash/sticky_keys/sticky_keys_controller.h"
 
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 16 matching lines @@
 
 #if defined(USE_X11)
 // The device id of the test touchpad device.
 const unsigned int kTouchPadDeviceId = 1;
 #endif
 
 }  // namespace
 
 class StickyKeysTest : public test::AshTestBase {
  protected:
-  StickyKeysTest()
-      : target_(NULL),
-        root_window_(NULL) {}
+  StickyKeysTest() : target_(NULL), root_window_(NULL) {}
 
   void SetUp() override {
     test::AshTestBase::SetUp();
 
     // |target_| owned by root window of shell. It is still safe to delete
     // it ourselves.
     target_ = CreateTestWindowInShellWithId(0);
     root_window_ = target_->GetRootWindow();
 
 #if defined(USE_X11)
@@ skipping 23 matching lines @@
   // This is the standard native event on Chromebooks.
   ui::MouseEvent* GenerateMouseEvent(ui::EventType type) {
     return GenerateMouseEventAt(type, gfx::Point());
   }
 
   // Creates a mouse event backed by a native XInput2 generic button event.
   // The |location| should be in physical pixels.
   ui::MouseEvent* GenerateMouseEventAt(ui::EventType type,
                                        const gfx::Point& location) {
 #if defined(USE_X11)
-    scoped_xevent_.InitGenericButtonEvent(
-        kTouchPadDeviceId,
-        type,
-        location,
-        0);
+    scoped_xevent_.InitGenericButtonEvent(kTouchPadDeviceId, type, location, 0);
     return new ui::MouseEvent(scoped_xevent_);
 #else
     return GenerateSynthesizedMouseEventAt(type, location);
 #endif
   }
 
   ui::MouseWheelEvent* GenerateMouseWheelEvent(int wheel_delta) {
 #if defined(USE_X11)
     EXPECT_NE(0, wheel_delta);
-    scoped_xevent_.InitGenericMouseWheelEvent(
-        kTouchPadDeviceId, wheel_delta, 0);
+    scoped_xevent_.InitGenericMouseWheelEvent(kTouchPadDeviceId, wheel_delta,
+                                              0);
     ui::MouseWheelEvent* event = new ui::MouseWheelEvent(scoped_xevent_);
     ui::Event::DispatcherApi dispatcher(event);
     dispatcher.set_target(target_);
     return event;
 #else
     return GenerateSynthesizedMouseWheelEvent(wheel_delta);
 #endif
   }
 
   ui::ScrollEvent* GenerateScrollEvent(int scroll_delta) {
 #if defined(USE_X11)
-    scoped_xevent_.InitScrollEvent(kTouchPadDeviceId, // deviceid
-                                   0,               // x_offset
-                                   scroll_delta,    // y_offset
-                                   0,               // x_offset_ordinal
-                                   scroll_delta,    // y_offset_ordinal
-                                   2);              // finger_count
+    scoped_xevent_.InitScrollEvent(kTouchPadDeviceId,  // deviceid
+                                   0,                  // x_offset
+                                   scroll_delta,       // y_offset
+                                   0,                  // x_offset_ordinal
+                                   scroll_delta,       // y_offset_ordinal
+                                   2);                 // finger_count
     ui::ScrollEvent* event = new ui::ScrollEvent(scoped_xevent_);
     ui::Event::DispatcherApi dispatcher(event);
     dispatcher.set_target(target_);
     return event;
 #else
     ui::ScrollEvent* event = new ui::ScrollEvent(
         ui::ET_SCROLL, gfx::Point(0, 0), ui::EventTimeForNow(), ui::EF_NONE,
         0,             // x_offset
         scroll_delta,  // y_offset
         0,             // x_offset_ordinal
         scroll_delta,  // y_offset_ordinal
         2);            // finger_count
     ui::Event::DispatcherApi dispatcher(event);
     dispatcher.set_target(target_);
     return event;
 #endif
   }
 
-  ui::ScrollEvent* GenerateFlingScrollEvent(int fling_delta,
-                                            bool is_cancel) {
+  ui::ScrollEvent* GenerateFlingScrollEvent(int fling_delta, bool is_cancel) {
 #if defined(USE_X11)
-    scoped_xevent_.InitFlingScrollEvent(
-        kTouchPadDeviceId, // deviceid
-        0,               // x_velocity
-        fling_delta,     // y_velocity
-        0,               // x_velocity_ordinal
-        fling_delta,     // y_velocity_ordinal
-        is_cancel);      // is_cancel
+    scoped_xevent_.InitFlingScrollEvent(kTouchPadDeviceId,  // deviceid
+                                        0,                  // x_velocity
+                                        fling_delta,        // y_velocity
+                                        0,            // x_velocity_ordinal
+                                        fling_delta,  // y_velocity_ordinal
+                                        is_cancel);   // is_cancel
     ui::ScrollEvent* event = new ui::ScrollEvent(scoped_xevent_);
     ui::Event::DispatcherApi dispatcher(event);
     dispatcher.set_target(target_);
     return event;
 #else
     ui::ScrollEvent* event = new ui::ScrollEvent(
         is_cancel ? ui::ET_SCROLL_FLING_CANCEL : ui::ET_SCROLL_FLING_START,
         gfx::Point(0, 0), ui::EventTimeForNow(), ui::EF_NONE,
         0,            // x_velocity
         fling_delta,  // y_velocity
@@ skipping 390 matching lines @@
 
   // Mouse events should not disable locked mode.
   for (int i = 0; i < 3; ++i) {
     bool released = false;
     int mod_down_flags = 0;
     ev.reset(GenerateMouseEvent(ui::ET_MOUSE_PRESSED));
     sticky_key.HandleMouseEvent(*ev.get(), &mod_down_flags, &released);
     EXPECT_TRUE(mod_down_flags & ui::EF_CONTROL_DOWN);
     ev.reset(GenerateMouseEvent(ui::ET_MOUSE_RELEASED));
     released = false;
-  mod_down_flags = 0;
+    mod_down_flags = 0;
     sticky_key.HandleMouseEvent(*ev.get(), &mod_down_flags, &released);
     EXPECT_TRUE(mod_down_flags & ui::EF_CONTROL_DOWN);
     EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state());
   }
 
   // Test with mouse wheel.
   for (int i = 0; i < 3; ++i) {
     bool released = false;
     int mod_down_flags = 0;
     ev.reset(GenerateMouseWheelEvent(ui::MouseWheelEvent::kWheelDelta));
     sticky_key.HandleMouseEvent(*ev.get(), &mod_down_flags, &released);
     ev.reset(GenerateMouseWheelEvent(-ui::MouseWheelEvent::kWheelDelta));
     released = false;
-  mod_down_flags = 0;
+    mod_down_flags = 0;
     sticky_key.HandleMouseEvent(*ev.get(), &mod_down_flags, &released);
     EXPECT_TRUE(mod_down_flags & ui::EF_CONTROL_DOWN);
     EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state());
   }
 
   // Test mixed case with mouse events and key events.
   ev.reset(GenerateMouseWheelEvent(ui::MouseWheelEvent::kWheelDelta));
   bool released = false;
   int mod_down_flags = 0;
   sticky_key.HandleMouseEvent(*ev.get(), &mod_down_flags, &released);
@@ skipping 25 matching lines @@
     bool released = false;
     int mod_down_flags = 0;
     sticky_key.HandleScrollEvent(*ev.get(), &mod_down_flags, &released);
     EXPECT_TRUE(mod_down_flags & ui::EF_CONTROL_DOWN);
     EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 
     // Scrolls should all be modified but not disable sticky keys.
     for (int j = 0; j < 3; ++j) {
       ev.reset(GenerateScrollEvent(scroll_deltas[i]));
       released = false;
-  mod_down_flags = 0;
+      mod_down_flags = 0;
       sticky_key.HandleScrollEvent(*ev.get(), &mod_down_flags, &released);
       EXPECT_TRUE(mod_down_flags & ui::EF_CONTROL_DOWN);
       EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
     }
 
     // Fling start event ends scroll sequence.
     ev.reset(GenerateFlingScrollEvent(scroll_deltas[i], false));
     released = false;
-  mod_down_flags = 0;
+    mod_down_flags = 0;
     sticky_key.HandleScrollEvent(*ev.get(), &mod_down_flags, &released);
     EXPECT_TRUE(mod_down_flags & ui::EF_CONTROL_DOWN);
     EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 
     std::unique_ptr<ui::Event> up_event;
     EXPECT_TRUE(released);
     ASSERT_EQ(0, sticky_key.GetModifierUpEvent(&up_event));
     EXPECT_TRUE(up_event.get());
     EXPECT_EQ(ui::ET_KEY_RELEASED, up_event->type());
     EXPECT_EQ(ui::VKEY_CONTROL,
@@ skipping 17 matching lines @@
     bool released = false;
     int mod_down_flags = 0;
     sticky_key.HandleScrollEvent(*ev.get(), &mod_down_flags, &released);
     EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
 
     // Test that changing directions in a scroll sequence will
     // return sticky keys to DISABLED state.
     for (int j = 0; j < 3; ++j) {
       ev.reset(GenerateScrollEvent(10));
       released = false;
-  mod_down_flags = 0;
+      mod_down_flags = 0;
       sticky_key.HandleScrollEvent(*ev.get(), &mod_down_flags, &released);
       EXPECT_TRUE(mod_down_flags & ui::EF_CONTROL_DOWN);
       EXPECT_EQ(STICKY_KEY_STATE_ENABLED, sticky_key.current_state());
     }
 
     ev.reset(GenerateScrollEvent(direction_change_values[i]));
     released = false;
-  mod_down_flags = 0;
+    mod_down_flags = 0;
     sticky_key.HandleScrollEvent(*ev.get(), &mod_down_flags, &released);
     EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
   }
 }
 
 TEST_F(StickyKeysTest, ScrollEventLocked) {
   std::unique_ptr<ui::ScrollEvent> ev;
   std::unique_ptr<ui::KeyEvent> kev;
   StickyKeysHandler sticky_key(ui::EF_CONTROL_DOWN);
 
   // Lock sticky keys.
   SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL);
   SendActivateStickyKeyPattern(&sticky_key, ui::VKEY_CONTROL);
   EXPECT_EQ(STICKY_KEY_STATE_LOCKED, sticky_key.current_state());
 
   // Test scroll events are correctly modified in locked state.
   for (int i = 0; i < 5; ++i) {
     // Fling cancel starts scroll sequence.
     ev.reset(GenerateFlingScrollEvent(0, true));
     bool released = false;
     int mod_down_flags = 0;
     sticky_key.HandleScrollEvent(*ev.get(), &mod_down_flags, &released);
 
     ev.reset(GenerateScrollEvent(10));
     released = false;
-  mod_down_flags = 0;
+    mod_down_flags = 0;
     sticky_key.HandleScrollEvent(*ev.get(), &mod_down_flags, &released);
     EXPECT_TRUE(mod_down_flags & ui::EF_CONTROL_DOWN);
     ev.reset(GenerateScrollEvent(-10));
     sticky_key.HandleScrollEvent(*ev.get(), &mod_down_flags, &released);
     EXPECT_TRUE(mod_down_flags & ui::EF_CONTROL_DOWN);
 
     // Fling start ends scroll sequence.
     ev.reset(GenerateFlingScrollEvent(-10, false));
     sticky_key.HandleScrollEvent(*ev.get(), &mod_down_flags, &released);
   }
@@ skipping 37 matching lines @@
                                                gfx::Point(0, 0)));
   released = false;
   mod_down_flags = 0;
   sticky_key.HandleMouseEvent(*mev.get(), &mod_down_flags, &released);
   EXPECT_TRUE(mod_down_flags & ui::EF_CONTROL_DOWN);
   EXPECT_TRUE(released);
   EXPECT_EQ(STICKY_KEY_STATE_DISABLED, sticky_key.current_state());
 }
 
 }  // namespace ash