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

chrome/browser/resources/cryptotoken/webrequest.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 Does common handling for requests coming from web pages and
  * routes them to the provided handler.
  */
 
 /**
  * FIDO U2F Javascript API Version
  * @const
  * @type {number}
  */
 var JS_API_VERSION = 1.1;
 
 /**
  * Gets the scheme + origin from a web url.
  * @param {string} url Input url
  * @return {?string} Scheme and origin part if url parses
  */
 function getOriginFromUrl(url) {
   var re = new RegExp('^(https?://)[^/]*/?');
   var originarray = re.exec(url);
-  if (originarray == null) return originarray;
+  if (originarray == null)
+    return originarray;
   var origin = originarray[0];
   while (origin.charAt(origin.length - 1) == '/') {
     origin = origin.substring(0, origin.length - 1);
   }
   if (origin == 'http:' || origin == 'https:')
     return null;
   return origin;
 }
 
 /**
@@ skipping 52 matching lines @@
 
 /**
  * Returns whether the array of SignChallenges appears to be valid.
  * @param {Array<SignChallenge>} signChallenges The array of sign challenges.
  * @param {boolean} challengeValueRequired Whether each challenge object
  *     requires a challenge value.
  * @param {boolean} appIdRequired Whether the appId property is required on
  *     each challenge.
  * @return {boolean} Whether the array appears valid.
  */
-function isValidSignChallengeArray(signChallenges, challengeValueRequired,
-    appIdRequired) {
+function isValidSignChallengeArray(
+    signChallenges, challengeValueRequired, appIdRequired) {
   for (var i = 0; i < signChallenges.length; i++) {
     var incomingChallenge = signChallenges[i];
     if (challengeValueRequired &&
         !incomingChallenge.hasOwnProperty('challenge'))
       return false;
     if (!isValidRegisteredKey(incomingChallenge, appIdRequired)) {
       return false;
     }
   }
   return true;
 }
 
 /**
  * @param {Object} request Request object
  * @param {MessageSender} sender Sender frame
  * @param {Function} sendResponse Response callback
  * @return {?Closeable} Optional handler object that should be closed when port
  *     closes
  */
 function handleWebPageRequest(request, sender, sendResponse) {
   switch (request.type) {
     case MessageTypes.U2F_REGISTER_REQUEST:
       return handleU2fEnrollRequest(sender, request, sendResponse);
 
     case MessageTypes.U2F_SIGN_REQUEST:
       return handleU2fSignRequest(sender, request, sendResponse);
 
     case MessageTypes.U2F_GET_API_VERSION_REQUEST:
-      sendResponse(
-          makeU2fGetApiVersionResponse(request, JS_API_VERSION,
-              MessageTypes.U2F_GET_API_VERSION_RESPONSE));
+      sendResponse(makeU2fGetApiVersionResponse(
+          request, JS_API_VERSION, MessageTypes.U2F_GET_API_VERSION_RESPONSE));
       return null;
 
     default:
-      sendResponse(
-          makeU2fErrorResponse(request, ErrorCodes.BAD_REQUEST, undefined,
-              MessageTypes.U2F_REGISTER_RESPONSE));
+      sendResponse(makeU2fErrorResponse(
+          request, ErrorCodes.BAD_REQUEST, undefined,
+          MessageTypes.U2F_REGISTER_RESPONSE));
       return null;
   }
 }
 
 /**
  * Makes a response to a request.
  * @param {Object} request The request to make a response to.
  * @param {string} responseSuffix How to name the response's type.
  * @param {string=} opt_defaultType The default response type, if none is
  *     present in the request.
  * @return {Object} The response object.
  */
 function makeResponseForRequest(request, responseSuffix, opt_defaultType) {
   var type;
   if (request && request.type) {
     type = request.type.replace(/_request$/, responseSuffix);
   } else {
     type = opt_defaultType;
   }
-  var reply = { 'type': type };
+  var reply = {'type': type};
   if (request && request.requestId) {
     reply.requestId = request.requestId;
   }
   return reply;
 }
 
 /**
  * Makes a response to a U2F request with an error code.
  * @param {Object} request The request to make a response to.
  * @param {ErrorCodes} code The error code to return.
@@ skipping 125 matching lines @@
  * @param {!string} type A string representing the "type" of this browser data
  *     object.
  * @param {!string} serverChallenge The server's challenge, as a base64-
  *     encoded string.
  * @param {!string} origin The server's origin, as seen by the browser.
  * @param {Object|string|undefined} opt_tlsChannelId TLS Channel Id
  * @return {string} A string representation of the browser data object.
  */
 function makeBrowserData(type, serverChallenge, origin, opt_tlsChannelId) {
   var browserData = {
-    'typ' : type,
-    'challenge' : serverChallenge,
-    'origin' : origin
+    'typ': type,
+    'challenge': serverChallenge,
+    'origin': origin
   };
   if (BROWSER_SUPPORTS_TLS_CHANNEL_ID) {
     browserData['cid_pubkey'] = tlsChannelIdValue(opt_tlsChannelId);
   }
   return JSON.stringify(browserData);
 }
 
 /**
  * Creates a browser data object for an enroll request with the given values.
  * @param {!string} serverChallenge The server's challenge, as a base64-
@@ skipping 42 matching lines @@
  * @param {string|undefined} opt_defaultChallenge A default sign challenge
  *     value, if a request does not provide one.
  * @param {string=} opt_defaultAppId The app id to use for each challenge, if
  *     the challenge contains none.
  * @param {function(string, string): string=} opt_challengeHashFunction
  *     A function that produces, from a key handle and a raw challenge, a hash
  *     of the raw challenge. If none is provided, a default hash function is
  *     used.
  * @return {!Array<SignHelperChallenge>} The sign challenges, encoded.
  */
-function encodeSignChallenges(signChallenges, opt_defaultChallenge,
-    opt_defaultAppId, opt_challengeHashFunction) {
+function encodeSignChallenges(
+    signChallenges, opt_defaultChallenge, opt_defaultAppId,
+    opt_challengeHashFunction) {
   function encodedSha256(keyHandle, challenge) {
     return B64_encode(sha256HashOfString(challenge));
   }
   var challengeHashFn = opt_challengeHashFunction || encodedSha256;
   var encodedSignChallenges = [];
   if (signChallenges) {
     for (var i = 0; i < signChallenges.length; i++) {
       var challenge = signChallenges[i];
       var keyHandle = challenge['keyHandle'];
       var challengeValue;
@@ skipping 33 matching lines @@
     'type': 'sign_helper_request',
     'signData': challenges,
     'timeout': opt_timeoutSeconds || 0,
     'timeoutSeconds': opt_timeoutSeconds || 0
   };
   if (opt_logMsgUrl !== undefined) {
     request.logMsgUrl = opt_logMsgUrl;
   }
   return request;
 }