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

chrome/browser/resources/chromeos/chromevox/cvox2/background/background.js

 // Copyright 2014 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.
 
 /**
  * @fileoverview The entry point for all ChromeVox2 related code for the
  * background page.
  */
 
 goog.provide('Background');
@@ skipping 75 matching lines @@
   /** @type {!cvox.AbstractEarcons} @private */
   this.classicEarcons_ = cvox.ChromeVox.earcons || new cvox.ClassicEarcons();
 
   /** @type {!cvox.AbstractEarcons} @private */
   this.nextEarcons_ = new NextEarcons();
 
   // Turn cvox.ChromeVox.earcons into a getter that returns either the
   // Next earcons or the Classic earcons depending on the current mode.
   Object.defineProperty(cvox.ChromeVox, 'earcons', {
     get: (function() {
-      if (this.mode === ChromeVoxMode.FORCE_NEXT ||
-          this.mode === ChromeVoxMode.NEXT) {
-        return this.nextEarcons_;
-      } else {
-        return this.classicEarcons_;
-      }
-    }).bind(this)
+           if (this.mode === ChromeVoxMode.FORCE_NEXT ||
+               this.mode === ChromeVoxMode.NEXT) {
+             return this.nextEarcons_;
+           } else {
+             return this.classicEarcons_;
+           }
+         }).bind(this)
   });
 
   if (cvox.ChromeVox.isChromeOS) {
     Object.defineProperty(cvox.ChromeVox, 'modKeyStr', {
       get: function() {
         return (this.mode == ChromeVoxMode.CLASSIC ||
-            this.mode == ChromeVoxMode.CLASSIC_COMPAT) ?
-                'Search+Shift' : 'Search';
+                this.mode == ChromeVoxMode.CLASSIC_COMPAT) ?
+            'Search+Shift' :
+            'Search';
       }.bind(this)
     });
 
     Object.defineProperty(cvox.ChromeVox, 'typingEcho', {
       get: function() {
         return parseInt(localStorage['typingEcho'], 10);
       }.bind(this),
       set: function(v) {
         localStorage['typingEcho'] = v;
       }.bind(this)
@@ skipping 46 matching lines @@
   this.focusRecoveryMap_ = new WeakMap();
 
   chrome.automation.getDesktop(function(desktop) {
     /** @type {string} */
     this.chromeChannel_ = desktop.chromeChannel;
   }.bind(this));
 
   // Record a metric with the mode we're in on startup.
   var useNext = localStorage['useClassic'] != 'true';
   chrome.metricsPrivate.recordValue(
-      { metricName: 'Accessibility.CrosChromeVoxNext',
+      {
+        metricName: 'Accessibility.CrosChromeVoxNext',
         type: chrome.metricsPrivate.MetricTypeType.HISTOGRAM_LINEAR,
         min: 1,  // According to histogram.h, this should be 1 for enums.
         max: 2,  // Maximum should be exclusive.
-        buckets: 3 },  // Number of buckets: 0, 1 and overflowing 2.
+        buckets: 3
+      },  // Number of buckets: 0, 1 and overflowing 2.
       useNext ? 1 : 0);
 };
 
 /**
  * Map from gesture names (AXGesture defined in ui/accessibility/ax_enums.idl)
  *     to commands when in Classic mode.
  * @type {Object<string, string>}
  * @const
  */
 Background.GESTURE_CLASSIC_COMMAND_MAP = {
@@ skipping 46 matching lines @@
       });
     } else {
       target = this.getCurrentRange().start.node;
     }
 
     if (!target)
       return useNext ? ChromeVoxMode.FORCE_NEXT : ChromeVoxMode.CLASSIC;
 
     // Closure complains, but clearly, |target| is not null.
     var topLevelRoot =
-        AutomationUtil.getTopLevelRoot(/** @type {!AutomationNode} */(target));
+        AutomationUtil.getTopLevelRoot(/** @type {!AutomationNode} */ (target));
     if (!topLevelRoot)
-      return useNext ? ChromeVoxMode.FORCE_NEXT :
-          ChromeVoxMode.CLASSIC_COMPAT;
+      return useNext ? ChromeVoxMode.FORCE_NEXT : ChromeVoxMode.CLASSIC_COMPAT;
 
     var docUrl = topLevelRoot.docUrl || '';
     var nextSite = this.isWhitelistedForNext_(docUrl);
-    var classicCompat =
-        this.isWhitelistedForClassicCompat_(docUrl);
+    var classicCompat = this.isWhitelistedForClassicCompat_(docUrl);
     if (classicCompat && !useNext)
       return ChromeVoxMode.CLASSIC_COMPAT;
     else if (nextSite)
       return ChromeVoxMode.NEXT;
     else if (!useNext)
       return ChromeVoxMode.CLASSIC;
     else
       return ChromeVoxMode.FORCE_NEXT;
   },
 
@@ skipping 16 matching lines @@
 
     // Classic modes do not use the new focus highlight.
     if (newMode == ChromeVoxMode.CLASSIC)
       chrome.accessibilityPrivate.setFocusRing([]);
 
     // Switch on/off content scripts.
     // note that |this.currentRange_| can *change* because the request is
     // async. Save it to ensure we're looking at the currentRange at this moment
     // in time.
     var cur = this.currentRange_;
-    chrome.tabs.query({active: true,
-                       lastFocusedWindow: true}, function(tabs) {
+    chrome.tabs.query({active: true, lastFocusedWindow: true}, function(tabs) {
       if (newMode == ChromeVoxMode.CLASSIC) {
         // Generally, we don't want to inject classic content scripts as it is
         // done by the extension system at document load. The exception is when
         // we toggle classic on manually as part of a user command.
         if (oldMode == ChromeVoxMode.FORCE_NEXT) {
           cvox.ChromeVox.injectChromeVoxIntoTabs(tabs);
         }
       } else if (newMode === ChromeVoxMode.FORCE_NEXT) {
         this.disableClassicChromeVox_();
       } else {
@@ skipping 50 matching lines @@
       chrome.metricsPrivate.recordUserAction(
           'Accessibility.ChromeVox.ToggleNextOff');
     }
 
     localStorage['useClassic'] = !useNext;
     if (useNext)
       this.setCurrentRangeToFocus_();
     else
       this.setCurrentRange(null);
 
-    var announce = Msgs.getMsg(useNext ?
-        'switch_to_next' : 'switch_to_classic');
+    var announce =
+        Msgs.getMsg(useNext ? 'switch_to_next' : 'switch_to_classic');
     cvox.ChromeVox.tts.speak(
         announce, cvox.QueueMode.FLUSH, {doNotInterrupt: true});
 
     // If the new mode is Classic, return false now so we don't announce
     // anything more.
     return useNext;
   },
 
   /**
    * @override
@@ skipping 55 matching lines @@
     opt_focus = opt_focus === undefined ? true : opt_focus;
     opt_speechProps = opt_speechProps || {};
     var prevRange = this.currentRange_;
     if (opt_focus)
       this.setFocusToRange_(range, prevRange);
 
     this.setCurrentRange(range);
 
     var o = new Output();
     var selectedRange;
-    if (this.pageSel_ &&
-        this.pageSel_.isValid() &&
-        range.isValid()) {
+    if (this.pageSel_ && this.pageSel_.isValid() && range.isValid()) {
       // Compute the direction of the endpoints of each range.
 
       // Casts are ok because isValid checks node start and end nodes are
       // non-null; Closure just doesn't eval enough to see it.
-      var startDir =
-          AutomationUtil.getDirection(this.pageSel_.start.node,
-              /** @type {!AutomationNode} */ (range.start.node));
-      var endDir =
-          AutomationUtil.getDirection(this.pageSel_.end.node,
-              /** @type {!AutomationNode} */ (range.end.node));
+      var startDir = AutomationUtil.getDirection(
+          this.pageSel_.start.node,
+          /** @type {!AutomationNode} */ (range.start.node));
+      var endDir = AutomationUtil.getDirection(
+          this.pageSel_.end.node,
+          /** @type {!AutomationNode} */ (range.end.node));
 
       // Selection across roots isn't supported.
       var pageRootStart = this.pageSel_.start.node.root;
       var pageRootEnd = this.pageSel_.end.node.root;
       var curRootStart = range.start.node.root;
       var curRootEnd = range.end.node.root;
 
       // Disallow crossing over the start of the page selection and roots.
-      if (startDir == Dir.BACKWARD ||
-          pageRootStart != pageRootEnd ||
-          pageRootStart != curRootStart ||
-          pageRootEnd != curRootEnd) {
+      if (startDir == Dir.BACKWARD || pageRootStart != pageRootEnd ||
+          pageRootStart != curRootStart || pageRootEnd != curRootEnd) {
         o.format('@end_selection');
         this.pageSel_ = null;
       } else {
         // Expand or shrink requires different feedback.
         var msg;
         if (endDir == Dir.FORWARD &&
             (this.pageSel_.end.node != range.end.node ||
-                this.pageSel_.end.index <= range.end.index)) {
+             this.pageSel_.end.index <= range.end.index)) {
           msg = '@selected';
         } else {
           msg = '@unselected';
           selectedRange = prevRange;
         }
-        this.pageSel_ = new cursors.Range(
-            this.pageSel_.start,
-            range.end
-            );
+        this.pageSel_ = new cursors.Range(this.pageSel_.start, range.end);
         if (this.pageSel_)
           this.pageSel_.select();
       }
     } else {
       // Ensure we don't select the editable when we first encounter it.
       var lca = null;
       if (range.start.node && prevRange.start.node) {
-        lca = AutomationUtil.getLeastCommonAncestor(prevRange.start.node,
-                                                    range.start.node);
+        lca = AutomationUtil.getLeastCommonAncestor(
+            prevRange.start.node, range.start.node);
       }
       if (!lca || lca.state[StateType.EDITABLE] ||
           !range.start.node.state[StateType.EDITABLE])
         range.select();
     }
 
     o.withRichSpeechAndBraille(
-        selectedRange || range, prevRange, Output.EventType.NAVIGATE)
-            .withQueueMode(cvox.QueueMode.FLUSH);
+         selectedRange || range, prevRange, Output.EventType.NAVIGATE)
+        .withQueueMode(cvox.QueueMode.FLUSH);
 
     if (msg)
       o.format(msg);
 
     for (var prop in opt_speechProps)
       o.format('!' + prop);
 
     o.go();
   },
 
@@ skipping 54 matching lines @@
     return true;
   },
 
   /**
    * Returns true if the url should have Classic running.
    * @return {boolean}
    * @private
    */
   shouldEnableClassicForUrl_: function(url) {
     return this.mode != ChromeVoxMode.FORCE_NEXT &&
-         !this.isBlacklistedForClassic_(url) &&
-        !this.isWhitelistedForNext_(url);
+        !this.isBlacklistedForClassic_(url) && !this.isWhitelistedForNext_(url);
   },
 
   /**
    * Compat mode is on if any of the following are true:
    * 1. a url is blacklisted for Classic.
    * 2. the current range is not within web content.
    * @param {string} url
    * @return {boolean}
    */
   isWhitelistedForClassicCompat_: function(url) {
-    return (this.isBlacklistedForClassic_(url) || (this.getCurrentRange() &&
-        !this.getCurrentRange().isWebRange() &&
-        this.getCurrentRange().start.node.state[StateType.FOCUSED])) || false;
+    return (this.isBlacklistedForClassic_(url) ||
+            (this.getCurrentRange() && !this.getCurrentRange().isWebRange() &&
+             this.getCurrentRange().start.node.state[StateType.FOCUSED])) ||
+        false;
   },
 
   /**
    * @param {string} url
    * @return {boolean}
    * @private
    */
   isBlacklistedForClassic_: function(url) {
     if (this.classicBlacklistRegExp_.test(url))
       return true;
@@ skipping 70 matching lines @@
    */
   onMessage_: function(msg, port) {
     var target = msg['target'];
     var action = msg['action'];
 
     switch (target) {
       case 'next':
         if (action == 'getIsClassicEnabled') {
           var url = msg['url'];
           var isClassicEnabled = this.shouldEnableClassicForUrl_(url);
-          port.postMessage({
-            target: 'next',
-            isClassicEnabled: isClassicEnabled
-          });
+          port.postMessage(
+              {target: 'next', isClassicEnabled: isClassicEnabled});
         } else if (action == 'enableClassicCompatForUrl') {
           var url = msg['url'];
           this.classicBlacklist_.add(url);
           if (this.currentRange_ && this.currentRange_.start.node)
             this.setCurrentRange(this.currentRange_);
         } else if (action == 'onCommand') {
           CommandHandler.onCommand(msg['command']);
         } else if (action == 'flushNextUtterance') {
           Output.forceModeForNextSpeechUtterance(cvox.QueueMode.FLUSH);
         }
@@ skipping 39 matching lines @@
    * @param {string} gesture The gesture to handle, based on the AXGesture enum
    *     defined in ui/accessibility/ax_enums.idl
    * @return {boolean} True if this gesture was handled.
    * @private
    */
   handleClassicGesture_: function(gesture) {
     var command = Background.GESTURE_CLASSIC_COMMAND_MAP[gesture];
     if (!command)
       return false;
 
-    var msg = {
-      'message': 'USER_COMMAND',
-      'command': command
-    };
+    var msg = {'message': 'USER_COMMAND', 'command': command};
     cvox.ExtensionBridge.send(msg);
     return true;
   },
 
   /** @private */
   setCurrentRangeToFocus_: function() {
     chrome.automation.getFocus(function(focus) {
       if (focus)
         this.setCurrentRange(cursors.Range.fromNode(focus));
       else
         this.setCurrentRange(null);
     }.bind(this));
   },
 
   /**
    * @param {!cursors.Range} range
    * @param {cursors.Range} prevRange
    * @private
    */
   setFocusToRange_: function(range, prevRange) {
     var start = range.start.node;
     var end = range.end.node;
 
     // First, see if we've crossed a root. Remove once webview handles focus
     // correctly.
     if (prevRange && prevRange.start.node && start) {
-      var entered = AutomationUtil.getUniqueAncestors(
-          prevRange.start.node, start);
+      var entered =
+          AutomationUtil.getUniqueAncestors(prevRange.start.node, start);
       var embeddedObject = entered.find(function(f) {
-        return f.role == RoleType.EMBEDDED_OBJECT; });
+        return f.role == RoleType.EMBEDDED_OBJECT;
+      });
       if (embeddedObject && !embeddedObject.state[StateType.FOCUSED])
         embeddedObject.focus();
     }
 
     if (start.state[StateType.FOCUSED] || end.state[StateType.FOCUSED])
       return;
 
     var isFocusableLinkOrControl = function(node) {
       return node.state[StateType.FOCUSABLE] &&
           AutomationPredicate.linkOrControl(node);
     };
 
     // Next, try to focus the start or end node.
     if (!AutomationPredicate.structuralContainer(start) &&
         start.state[StateType.FOCUSABLE]) {
       if (!start.state[StateType.FOCUSED])
         start.focus();
       return;
-    } else if (!AutomationPredicate.structuralContainer(end) &&
+    } else if (
+        !AutomationPredicate.structuralContainer(end) &&
         end.state[StateType.FOCUSABLE]) {
       if (!end.state[StateType.FOCUSED])
         end.focus();
       return;
     }
 
     // If a common ancestor of |start| and |end| is a link, focus that.
     var ancestor = AutomationUtil.getLeastCommonAncestor(start, end);
     while (ancestor && ancestor.root == start.root) {
       if (isFocusableLinkOrControl(ancestor)) {
@@ skipping 13 matching lines @@
 };
 
 /**
  * Converts a list of globs, as used in the extension manifest, to a regular
  * expression that matches if and only if any of the globs in the list matches.
  * @param {!Array<string>} globs
  * @return {!RegExp}
  * @private
  */
 Background.globsToRegExp_ = function(globs) {
-  return new RegExp('^(' + globs.map(function(glob) {
-    return glob.replace(/[.+^$(){}|[\]\\]/g, '\\$&')
-        .replace(/\*/g, '.*')
-        .replace(/\?/g, '.');
-  }).join('|') + ')$');
+  return new RegExp(
+      '^(' +
+      globs
+          .map(function(glob) {
+            return glob.replace(/[.+^$(){}|[\]\\]/g, '\\$&')
+                .replace(/\*/g, '.*')
+                .replace(/\?/g, '.');
+          })
+          .join('|') +
+      ')$');
 };
 
 new Background();
 
 });  // goog.scope