DO NOT SUBMIT: what chrome/browser/resources/ could eventually look like with clang-format

chrome/browser/resources/extensions/shortcut_util.js

 // Copyright 2016 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.
 
 cr.define('extensions', function() {
   'use strict';
 
   /**
    * @enum {number}
    */
@@ skipping 16 matching lines @@
     Right: 39,
     Space: 32,
     Tab: 9,
     Up: 38,
   };
 
   /**
    * Enum for whether we require modifiers of a keycode.
    * @enum {number}
    */
-  var ModifierPolicy = {
-    NOT_ALLOWED: 0,
-    REQUIRED: 1
-  };
+  var ModifierPolicy = {NOT_ALLOWED: 0, REQUIRED: 1};
 
   /**
    * Gets the ModifierPolicy. Currently only "MediaNextTrack", "MediaPrevTrack",
    * "MediaStop", "MediaPlayPause" are required to be used without any modifier.
    * @param {number} keyCode
    * @return {ModifierPolicy}
    */
   function getModifierPolicy(keyCode) {
     switch (keyCode) {
       case Key.MediaNextTrack:
       case Key.MediaPlayPause:
       case Key.MediaPrevTrack:
       case Key.MediaStop:
         return ModifierPolicy.NOT_ALLOWED;
       default:
         return ModifierPolicy.REQUIRED;
     }
   }
 
   /**
    * Returns whether the keyboard event has a key modifier, which could affect
    * how it's handled.
    * @param {!KeyboardEvent} e
    * @param {boolean} countShiftAsModifier Whether the 'Shift' key should be
    *     counted as modifier.
    * @return {boolean} True if the event has any modifiers.
    */
   function hasModifier(e, countShiftAsModifier) {
     return e.ctrlKey || e.altKey ||
-           // Meta key is only relevant on Mac and CrOS, where we treat Command
-           // and Search (respectively) as modifiers.
-           (cr.isMac && e.metaKey) ||
-           (cr.isChromeOS && e.metaKey) ||
-           (countShiftAsModifier && e.shiftKey);
+        // Meta key is only relevant on Mac and CrOS, where we treat Command
+        // and Search (respectively) as modifiers.
+        (cr.isMac && e.metaKey) || (cr.isChromeOS && e.metaKey) ||
+        (countShiftAsModifier && e.shiftKey);
   }
 
   /**
    * Checks whether the passed in |keyCode| is a valid extension command key.
    * @param {number} keyCode
    * @return {boolean} Whether the key is valid.
    */
   function isValidKeyCode(keyCode) {
     if (keyCode == Key.Escape)
       return false;
     for (var k in Key) {
       if (Key[k] == keyCode)
         return true;
     }
     return (keyCode >= 'A'.charCodeAt(0) && keyCode <= 'Z'.charCodeAt(0)) ||
-           (keyCode >= '0'.charCodeAt(0) && keyCode <= '9'.charCodeAt(0));
+        (keyCode >= '0'.charCodeAt(0) && keyCode <= '9'.charCodeAt(0));
   }
 
   /**
    * Converts a keystroke event to string form, ignoring invalid extension
    * commands.
    * @param {!KeyboardEvent} e
    * @return {string} The keystroke as a string.
    */
   function keystrokeToString(e) {
     var output = [];
@@ skipping 10 matching lines @@
       output.push('Shift');
 
     var keyCode = e.keyCode;
     if (isValidKeyCode(keyCode)) {
       if ((keyCode >= 'A'.charCodeAt(0) && keyCode <= 'Z'.charCodeAt(0)) ||
           (keyCode >= '0'.charCodeAt(0) && keyCode <= '9'.charCodeAt(0))) {
         output.push(String.fromCharCode(keyCode));
       } else {
         switch (keyCode) {
           case Key.Comma:
-            output.push('Comma'); break;
+            output.push('Comma');
+            break;
           case Key.Del:
-            output.push('Delete'); break;
+            output.push('Delete');
+            break;
           case Key.Down:
-            output.push('Down'); break;
+            output.push('Down');
+            break;
           case Key.End:
-            output.push('End'); break;
+            output.push('End');
+            break;
           case Key.Home:
-            output.push('Home'); break;
+            output.push('Home');
+            break;
           case Key.Ins:
-            output.push('Insert'); break;
+            output.push('Insert');
+            break;
           case Key.Left:
-            output.push('Left'); break;
+            output.push('Left');
+            break;
           case Key.MediaNextTrack:
-            output.push('MediaNextTrack'); break;
+            output.push('MediaNextTrack');
+            break;
           case Key.MediaPlayPause:
-            output.push('MediaPlayPause'); break;
+            output.push('MediaPlayPause');
+            break;
           case Key.MediaPrevTrack:
-            output.push('MediaPrevTrack'); break;
+            output.push('MediaPrevTrack');
+            break;
           case Key.MediaStop:
-            output.push('MediaStop'); break;
+            output.push('MediaStop');
+            break;
           case Key.PageDown:
-            output.push('PageDown'); break;
+            output.push('PageDown');
+            break;
           case Key.PageUp:
-            output.push('PageUp'); break;
+            output.push('PageUp');
+            break;
           case Key.Period:
-            output.push('Period'); break;
+            output.push('Period');
+            break;
           case Key.Right:
-            output.push('Right'); break;
+            output.push('Right');
+            break;
           case Key.Space:
-            output.push('Space'); break;
+            output.push('Space');
+            break;
           case Key.Tab:
-            output.push('Tab'); break;
+            output.push('Tab');
+            break;
           case Key.Up:
-            output.push('Up'); break;
+            output.push('Up');
+            break;
         }
       }
     }
 
     return output.join('+');
   }
 
   /**
    * Returns true if the event has valid modifiers.
    * @param {!KeyboardEvent} e The keyboard event to consider.
    * @return {boolean} True if the event is valid.
    */
   function hasValidModifiers(e) {
     switch (getModifierPolicy(e.keyCode)) {
       case ModifierPolicy.REQUIRED:
         return hasModifier(e, false);
       case ModifierPolicy.NOT_ALLOWED:
         return !hasModifier(e, true);
     }
     assertNotReached();
   }
 
   return {
     isValidKeyCode: isValidKeyCode,
     keystrokeToString: keystrokeToString,
     hasValidModifiers: hasValidModifiers,
     Key: Key,
   };
 });