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

chrome/browser/resources/chromeos/chromevox/common/spannable.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 Class which allows construction of annotated strings.
  */
 
 goog.provide('Spannable');
 
@@ skipping 19 matching lines @@
    */
   this.spans_ = [];
 
   // Append the initial spannable.
   if (opt_string instanceof Spannable)
     this.append(opt_string);
 
   // Optionally annotate the entire string.
   if (goog.isDef(opt_annotation)) {
     var len = this.string_.length;
-    this.spans_.push({ value: opt_annotation, start: 0, end: len });
+    this.spans_.push({value: opt_annotation, start: 0, end: len});
   }
 };
 
 Spannable.prototype = {
   /** @override */
   toString: function() {
     return this.string_;
   },
 
   /** @return {number} The length of the string */
   get length() {
     return this.string_.length;
   },
 
   /**
    * Adds a span to some region of the string.
    * @param {*} value Annotation.
    * @param {number} start Starting index (inclusive).
    * @param {number} end Ending index (exclusive).
    */
   setSpan: function(value, start, end) {
     this.removeSpan(value);
     if (0 <= start && start <= end && end <= this.string_.length) {
       // Zero-length spans are explicitly allowed, because it is possible to
       // query for position by annotation as well as the reverse.
-      this.spans_.push({ value: value, start: start, end: end });
+      this.spans_.push({value: value, start: start, end: end});
       this.spans_.sort(function(a, b) {
         var ret = a.start - b.start;
         if (ret == 0)
           ret = a.end - b.end;
         return ret;
       });
     } else {
-      throw new RangeError('span out of range (start=' + start +
-          ', end=' + end + ', len=' + this.string_.length + ')');
+      throw new RangeError(
+          'span out of range (start=' + start + ', end=' + end +
+          ', len=' + this.string_.length + ')');
     }
   },
 
   /**
    * Removes a span.
    * @param {*} value Annotation.
    */
   removeSpan: function(value) {
     for (var i = this.spans_.length - 1; i >= 0; i--) {
       if (this.spans_[i].value === value) {
         this.spans_.splice(i, 1);
       }
     }
   },
 
   /**
    * Appends another Spannable or string to this one.
    * @param {string|!Spannable} other String or spannable to concatenate.
    */
   append: function(other) {
     if (other instanceof Spannable) {
       var otherSpannable = /** @type {!Spannable} */ (other);
       var originalLength = this.length;
       this.string_ += otherSpannable.string_;
       other.spans_.forEach(function(span) {
         this.setSpan(
-            span.value,
-            span.start + originalLength,
-            span.end + originalLength);
+            span.value, span.start + originalLength, span.end + originalLength);
       }.bind(this));
     } else if (typeof other === 'string') {
       this.string_ += /** @type {string} */ (other);
     }
   },
 
   /**
    * Returns the first value matching a position.
    * @param {number} position Position to query.
    * @return {*} Value annotating that position, or undefined if none is found.
@@ skipping 12 matching lines @@
   },
 
   /**
    * Returns all span values which are an instance of a given constructor.
    * Spans are returned in the order of their starting index and ending index
    * for spans with equals tarting indices.
    * @param {!Function} constructor Constructor.
    * @return {!Array<Object>} Array of object.
    */
   getSpansInstanceOf: function(constructor) {
-    return (this.spans_.filter(spanInstanceOf(constructor))
-            .map(valueOfSpan));
+    return (this.spans_.filter(spanInstanceOf(constructor)).map(valueOfSpan));
   },
 
   /**
    * Returns all spans matching a position.
    * @param {number} position Position to query.
    * @return {!Array} Values annotating that position.
    */
   getSpans: function(position) {
-    return (this.spans_
-        .filter(spanCoversPosition(position))
-        .map(valueOfSpan));
+    return (this.spans_.filter(spanCoversPosition(position)).map(valueOfSpan));
   },
 
   /**
    * Returns whether a span is contained in this object.
    * @param {*} value Annotation.
    * @return {boolean}
    */
   hasSpan: function(value) {
     return this.spans_.some(spanValueIs(value));
   },
@@ skipping 58 matching lines @@
 
     if (start < 0 || end > this.string_.length || start > end) {
       throw new RangeError('substring indices out of range');
     }
 
     var result = new Spannable(this.string_.substring(start, end));
     this.spans_.forEach(function(span) {
       if (span.start <= end && span.end >= start) {
         var newStart = Math.max(0, span.start - start);
         var newEnd = Math.min(end - start, span.end - start);
-        result.spans_.push({ value: span.value, start: newStart, end: newEnd });
+        result.spans_.push({value: span.value, start: newStart, end: newEnd});
       }
     });
     return result;
   },
 
   /**
    * Trims whitespace from the beginning.
    * @return {!Spannable} String with whitespace removed.
    */
   trimLeft: function() {
@@ skipping 32 matching lines @@
     // As an arbitrary decision, we treat this as trimming the whitespace off
     // the end, rather than the beginning, of the string.
     // This choice affects which spans are kept.
     if (/^\s*$/.test(this.string_)) {
       return this.substring(0, 0);
     }
 
     // Otherwise, we have at least one non-whitespace character to use as an
     // anchor when trimming.
     var trimmedStart = trimStart ? this.string_.match(/^\s*/)[0].length : 0;
-    var trimmedEnd = trimEnd ?
-        this.string_.match(/\s*$/).index : this.string_.length;
+    var trimmedEnd =
+        trimEnd ? this.string_.match(/\s*$/).index : this.string_.length;
     return this.substring(trimmedStart, trimmedEnd);
   },
 
   /**
    * Returns this spannable to a json serializable form, including the text and
    * span objects whose types have been registered with registerSerializableSpan
    * or registerStatelessSerializableSpan.
    * @return {!SerializedSpannable} the json serializable form.
    */
   toJson: function() {
     var result = {};
     result.string = this.string_;
     result.spans = [];
     this.spans_.forEach(function(span) {
-      var serializeInfo = serializableSpansByConstructor.get(
-          span.value.constructor);
+      var serializeInfo =
+          serializableSpansByConstructor.get(span.value.constructor);
       if (serializeInfo) {
-        var spanObj = {type: serializeInfo.name,
-                       start: span.start,
-                       end: span.end};
+        var spanObj = {
+          type: serializeInfo.name,
+          start: span.start,
+          end: span.end
+        };
         if (serializeInfo.toJson) {
           spanObj.value = serializeInfo.toJson.apply(span.value);
         }
         result.spans.push(spanObj);
       }
     });
     return result;
   }
 };
 
 /**
  * Creates a spannable from a json serializable representation.
  * @param {!SerializedSpannable} obj object containing the serializable
  *     representation.
  * @return {!Spannable}
  */
 Spannable.fromJson = function(obj) {
   if (typeof obj.string !== 'string') {
-    throw new Error(
-        'Invalid spannable json object: string field not a string');
+    throw new Error('Invalid spannable json object: string field not a string');
   }
   if (!(obj.spans instanceof Array)) {
     throw new Error('Invalid spannable json object: no spans array');
   }
   var result = new Spannable(obj.string);
   result.spans_ = obj.spans.map(function(span) {
     if (typeof span.type !== 'string') {
       throw new Error(
           'Invalid span in spannable json object: type not a string');
     }
@@ skipping 34 matching lines @@
  *     new objects.
  * @param {string} name Name of the type used in the serializable object.
  */
 Spannable.registerStatelessSerializableSpan = function(constructor, name) {
   var obj = {name: name, toJson: undefined};
   /**
    * @param {!Object} obj
    * @return {!Object}
    */
   obj.fromJson = function(obj) {
-     return new constructor();
+    return new constructor();
   };
   serializableSpansByName.set(name, obj);
   serializableSpansByConstructor.set(constructor, obj);
 };
 
 /**
  * An annotation with its start and end points.
  * @typedef {{value: *, start: number, end: number}}
  */
 var SpanStruct;
@@ skipping 65 matching lines @@
 
 /**
  * @param {!SpanStruct|undefined} span
  * @return {*}
  */
 function valueOfSpan(span) {
   return span ? span.value : undefined;
 }
 
 });