clang-format all of //ash

ash/sticky_keys/sticky_keys_controller.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/sticky_keys/sticky_keys_overlay.h"
 #include "base/debug/stack_trace.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tracker.h"
@@ skipping 27 matching lines @@
   if (changed_down_flags)
     return ui::EVENT_REWRITE_REWRITTEN;
   return ui::EVENT_REWRITE_CONTINUE;
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 //  StickyKeys
 StickyKeysController::StickyKeysController()
-    : enabled_(false),
-      mod3_enabled_(false),
-      altgr_enabled_(false) {
-}
+    : enabled_(false), mod3_enabled_(false), altgr_enabled_(false) {}
 
-StickyKeysController::~StickyKeysController() {
-}
+StickyKeysController::~StickyKeysController() {}
 
 void StickyKeysController::Enable(bool enabled) {
   if (enabled_ != enabled) {
     enabled_ = enabled;
 
     // Reset key handlers when activating sticky keys to ensure all
     // the handlers' states are reset.
     if (enabled_) {
       shift_sticky_key_.reset(new StickyKeysHandler(ui::EF_SHIFT_DOWN));
       alt_sticky_key_.reset(new StickyKeysHandler(ui::EF_ALT_DOWN));
@@ skipping 18 matching lines @@
   if (overlay_) {
     overlay_->SetModifierVisible(ui::EF_ALTGR_DOWN, altgr_enabled_);
     overlay_->SetModifierVisible(ui::EF_MOD3_DOWN, mod3_enabled_);
   }
 }
 
 bool StickyKeysController::HandleKeyEvent(const ui::KeyEvent& event,
                                           ui::KeyboardCode key_code,
                                           int* mod_down_flags,
                                           bool* released) {
-  return shift_sticky_key_->HandleKeyEvent(
-             event, key_code, mod_down_flags, released) ||
-         alt_sticky_key_->HandleKeyEvent(
-             event, key_code, mod_down_flags, released) ||
-         altgr_sticky_key_->HandleKeyEvent(
-             event, key_code, mod_down_flags, released) ||
-         ctrl_sticky_key_->HandleKeyEvent(
-             event, key_code, mod_down_flags, released) ||
-         mod3_sticky_key_->HandleKeyEvent(
-             event, key_code, mod_down_flags, released) ||
-         search_sticky_key_->HandleKeyEvent(
-             event, key_code, mod_down_flags, released);
+  return shift_sticky_key_->HandleKeyEvent(event, key_code, mod_down_flags,
+                                           released) ||
+         alt_sticky_key_->HandleKeyEvent(event, key_code, mod_down_flags,
+                                         released) ||
+         altgr_sticky_key_->HandleKeyEvent(event, key_code, mod_down_flags,
+                                           released) ||
+         ctrl_sticky_key_->HandleKeyEvent(event, key_code, mod_down_flags,
+                                          released) ||
+         mod3_sticky_key_->HandleKeyEvent(event, key_code, mod_down_flags,
+                                          released) ||
+         search_sticky_key_->HandleKeyEvent(event, key_code, mod_down_flags,
+                                            released);
 }
 
 bool StickyKeysController::HandleMouseEvent(const ui::MouseEvent& event,
                                             int* mod_down_flags,
                                             bool* released) {
-  return shift_sticky_key_->HandleMouseEvent(
-             event, mod_down_flags, released) ||
-         alt_sticky_key_->HandleMouseEvent(
-             event, mod_down_flags, released) ||
-         altgr_sticky_key_->HandleMouseEvent(
-             event, mod_down_flags, released) ||
-         ctrl_sticky_key_->HandleMouseEvent(
-             event, mod_down_flags, released) ||
-         mod3_sticky_key_->HandleMouseEvent(
-             event, mod_down_flags, released);
+  return shift_sticky_key_->HandleMouseEvent(event, mod_down_flags, released) ||
+         alt_sticky_key_->HandleMouseEvent(event, mod_down_flags, released) ||
+         altgr_sticky_key_->HandleMouseEvent(event, mod_down_flags, released) ||
+         ctrl_sticky_key_->HandleMouseEvent(event, mod_down_flags, released) ||
+         mod3_sticky_key_->HandleMouseEvent(event, mod_down_flags, released);
 }
 
 bool StickyKeysController::HandleScrollEvent(const ui::ScrollEvent& event,
                                              int* mod_down_flags,
                                              bool* released) {
-  return shift_sticky_key_->HandleScrollEvent(
-             event, mod_down_flags, released) ||
-         alt_sticky_key_->HandleScrollEvent(
-             event, mod_down_flags, released) ||
-         altgr_sticky_key_->HandleScrollEvent(
-             event, mod_down_flags, released) ||
-         ctrl_sticky_key_->HandleScrollEvent(
-             event, mod_down_flags, released) ||
-         mod3_sticky_key_->HandleScrollEvent(
-             event, mod_down_flags, released);
+  return shift_sticky_key_->HandleScrollEvent(event, mod_down_flags,
+                                              released) ||
+         alt_sticky_key_->HandleScrollEvent(event, mod_down_flags, released) ||
+         altgr_sticky_key_->HandleScrollEvent(event, mod_down_flags,
+                                              released) ||
+         ctrl_sticky_key_->HandleScrollEvent(event, mod_down_flags, released) ||
+         mod3_sticky_key_->HandleScrollEvent(event, mod_down_flags, released);
 }
 
 ui::EventRewriteStatus StickyKeysController::RewriteKeyEvent(
     const ui::KeyEvent& event,
     ui::KeyboardCode key_code,
     int* flags) {
   if (!enabled_)
     return ui::EVENT_REWRITE_CONTINUE;
   int mod_down_flags = 0;
   bool released = false;
@@ skipping 37 matching lines @@
                   mod3_sticky_key_->GetModifierUpEvent(new_event) +
                   search_sticky_key_->GetModifierUpEvent(new_event);
   if (!new_event)
     return ui::EVENT_REWRITE_CONTINUE;
   if (remaining)
     return ui::EVENT_REWRITE_DISPATCH_ANOTHER;
   return ui::EVENT_REWRITE_REWRITTEN;
 }
 
 void StickyKeysController::UpdateOverlay() {
-  overlay_->SetModifierKeyState(
-      ui::EF_SHIFT_DOWN, shift_sticky_key_->current_state());
-  overlay_->SetModifierKeyState(
-      ui::EF_CONTROL_DOWN, ctrl_sticky_key_->current_state());
-  overlay_->SetModifierKeyState(
-      ui::EF_ALT_DOWN, alt_sticky_key_->current_state());
-  overlay_->SetModifierKeyState(
-      ui::EF_COMMAND_DOWN, search_sticky_key_->current_state());
-  overlay_->SetModifierKeyState(
-      ui::EF_ALTGR_DOWN, altgr_sticky_key_->current_state());
-  overlay_->SetModifierKeyState(
-      ui::EF_MOD3_DOWN, mod3_sticky_key_->current_state());
+  overlay_->SetModifierKeyState(ui::EF_SHIFT_DOWN,
+                                shift_sticky_key_->current_state());
+  overlay_->SetModifierKeyState(ui::EF_CONTROL_DOWN,
+                                ctrl_sticky_key_->current_state());
+  overlay_->SetModifierKeyState(ui::EF_ALT_DOWN,
+                                alt_sticky_key_->current_state());
+  overlay_->SetModifierKeyState(ui::EF_COMMAND_DOWN,
+                                search_sticky_key_->current_state());
+  overlay_->SetModifierKeyState(ui::EF_ALTGR_DOWN,
+                                altgr_sticky_key_->current_state());
+  overlay_->SetModifierKeyState(ui::EF_MOD3_DOWN,
+                                mod3_sticky_key_->current_state());
 
   bool key_in_use =
       shift_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
       alt_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
       altgr_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
       ctrl_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
       search_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
       mod3_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED;
 
   overlay_->Show(enabled_ && key_in_use);
 }
 
 StickyKeysOverlay* StickyKeysController::GetOverlayForTest() {
   return overlay_.get();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //  StickyKeysHandler
 StickyKeysHandler::StickyKeysHandler(ui::EventFlags modifier_flag)
     : modifier_flag_(modifier_flag),
       current_state_(STICKY_KEY_STATE_DISABLED),
       preparing_to_enable_(false),
-      scroll_delta_(0) {
-}
+      scroll_delta_(0) {}
 
-StickyKeysHandler::~StickyKeysHandler() {
-}
+StickyKeysHandler::~StickyKeysHandler() {}
 
 bool StickyKeysHandler::HandleKeyEvent(const ui::KeyEvent& event,
                                        ui::KeyboardCode key_code,
                                        int* mod_down_flags,
                                        bool* released) {
   switch (current_state_) {
     case STICKY_KEY_STATE_DISABLED:
       return HandleDisabledState(event, key_code);
     case STICKY_KEY_STATE_ENABLED:
       return HandleEnabledState(event, key_code, mod_down_flags, released);
     case STICKY_KEY_STATE_LOCKED:
       return HandleLockedState(event, key_code, mod_down_flags, released);
   }
   NOTREACHED();
   return false;
 }
 
-bool StickyKeysHandler::HandleMouseEvent(
-    const ui::MouseEvent& event,
-    int* mod_down_flags,
-    bool* released) {
+bool StickyKeysHandler::HandleMouseEvent(const ui::MouseEvent& event,
+                                         int* mod_down_flags,
+                                         bool* released) {
   if (ShouldModifyMouseEvent(event))
     preparing_to_enable_ = false;
 
   if (current_state_ == STICKY_KEY_STATE_DISABLED ||
       !ShouldModifyMouseEvent(event)) {
     return false;
   }
   DCHECK(current_state_ == STICKY_KEY_STATE_ENABLED ||
          current_state_ == STICKY_KEY_STATE_LOCKED);
 
   *mod_down_flags |= modifier_flag_;
   // Only disable on the mouse released event in normal, non-locked mode.
   if (current_state_ == STICKY_KEY_STATE_ENABLED &&
       event.type() != ui::ET_MOUSE_PRESSED) {
     current_state_ = STICKY_KEY_STATE_DISABLED;
     *released = true;
     return false;
   }
 
   return false;
 }
 
-bool StickyKeysHandler::HandleScrollEvent(
-    const ui::ScrollEvent& event,
-    int* mod_down_flags,
-    bool* released) {
+bool StickyKeysHandler::HandleScrollEvent(const ui::ScrollEvent& event,
+                                          int* mod_down_flags,
+                                          bool* released) {
   preparing_to_enable_ = false;
   if (current_state_ == STICKY_KEY_STATE_DISABLED)
     return false;
   DCHECK(current_state_ == STICKY_KEY_STATE_ENABLED ||
          current_state_ == STICKY_KEY_STATE_LOCKED);
 
   // We detect a direction change if the current |scroll_delta_| is assigned
   // and the offset of the current scroll event has the opposing sign.
   bool direction_changed = false;
   if (current_state_ == STICKY_KEY_STATE_ENABLED &&
@@ skipping 29 matching lines @@
   if (*new_event)
     return 1;
   new_event->reset(modifier_up_event_.release());
   return 0;
 }
 
 StickyKeysHandler::KeyEventType StickyKeysHandler::TranslateKeyEvent(
     ui::EventType type,
     ui::KeyboardCode key_code) {
   bool is_target_key = false;
-  if (key_code == ui::VKEY_SHIFT ||
-      key_code == ui::VKEY_LSHIFT ||
+  if (key_code == ui::VKEY_SHIFT || key_code == ui::VKEY_LSHIFT ||
       key_code == ui::VKEY_RSHIFT) {
     is_target_key = (modifier_flag_ == ui::EF_SHIFT_DOWN);
-  } else if (key_code == ui::VKEY_CONTROL ||
-      key_code == ui::VKEY_LCONTROL ||
-      key_code == ui::VKEY_RCONTROL) {
+  } else if (key_code == ui::VKEY_CONTROL || key_code == ui::VKEY_LCONTROL ||
+             key_code == ui::VKEY_RCONTROL) {
     is_target_key = (modifier_flag_ == ui::EF_CONTROL_DOWN);
-  } else if (key_code == ui::VKEY_MENU ||
-      key_code == ui::VKEY_LMENU ||
-      key_code == ui::VKEY_RMENU) {
+  } else if (key_code == ui::VKEY_MENU || key_code == ui::VKEY_LMENU ||
+             key_code == ui::VKEY_RMENU) {
     is_target_key = (modifier_flag_ == ui::EF_ALT_DOWN);
   } else if (key_code == ui::VKEY_ALTGR) {
     is_target_key = (modifier_flag_ == ui::EF_ALTGR_DOWN);
   } else if (key_code == ui::VKEY_OEM_8) {
     is_target_key = (modifier_flag_ == ui::EF_MOD3_DOWN);
   } else if (key_code == ui::VKEY_LWIN) {
     is_target_key = (modifier_flag_ == ui::EF_COMMAND_DOWN);
   } else {
-    return type == ui::ET_KEY_PRESSED ?
-        NORMAL_KEY_DOWN : NORMAL_KEY_UP;
+    return type == ui::ET_KEY_PRESSED ? NORMAL_KEY_DOWN : NORMAL_KEY_UP;
   }
 
   if (is_target_key) {
-    return type == ui::ET_KEY_PRESSED ?
-        TARGET_MODIFIER_DOWN : TARGET_MODIFIER_UP;
+    return type == ui::ET_KEY_PRESSED ? TARGET_MODIFIER_DOWN
+                                      : TARGET_MODIFIER_UP;
   }
-  return type == ui::ET_KEY_PRESSED ?
-      OTHER_MODIFIER_DOWN : OTHER_MODIFIER_UP;
+  return type == ui::ET_KEY_PRESSED ? OTHER_MODIFIER_DOWN : OTHER_MODIFIER_UP;
 }
 
 bool StickyKeysHandler::HandleDisabledState(const ui::KeyEvent& event,
                                             ui::KeyboardCode key_code) {
   switch (TranslateKeyEvent(event.type(), key_code)) {
     case TARGET_MODIFIER_UP:
       if (preparing_to_enable_) {
         preparing_to_enable_ = false;
         scroll_delta_ = 0;
         current_state_ = STICKY_KEY_STATE_ENABLED;
@@ skipping 58 matching lines @@
       return false;
     case OTHER_MODIFIER_DOWN:
     case OTHER_MODIFIER_UP:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace ash