Run tools/clang-format-js on some of chrome/browser/resources/

chrome/browser/resources/gaia_auth_host/authenticator.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.
 
-<include src="saml_handler.js">
+// <include src="saml_handler.js">
 
 /**
  * @fileoverview An UI component to authenciate to Chrome. The component hosts
  * IdP web pages in a webview. A client who is interested in monitoring
  * authentication events should pass a listener object of type
  * cr.login.GaiaAuthHost.Listener as defined in this file. After initialization,
  * call {@code load} to start the authentication flow.
  */
 
 cr.define('cr.login', function() {
@@ skipping 21 matching lines @@
   /**
    * The source URL parameter for the constrained signin flow.
    */
   var CONSTRAINED_FLOW_SOURCE = 'chrome';
 
   /**
    * Enum for the authorization mode, must match AuthMode defined in
    * chrome/browser/ui/webui/inline_login_ui.cc.
    * @enum {number}
    */
-  var AuthMode = {
-    DEFAULT: 0,
-    OFFLINE: 1,
-    DESKTOP: 2
-  };
+  var AuthMode = {DEFAULT: 0, OFFLINE: 1, DESKTOP: 2};
 
   /**
    * Enum for the authorization type.
    * @enum {number}
    */
-  var AuthFlow = {
-    DEFAULT: 0,
-    SAML: 1
-  };
+  var AuthFlow = {DEFAULT: 0, SAML: 1};
 
   /**
    * Supported Authenticator params.
    * @type {!Array<string>}
    * @const
    */
   var SUPPORTED_PARAMS = [
     'gaiaId',        // Obfuscated GAIA ID to skip the email prompt page
                      // during the re-auth flow.
     'gaiaUrl',       // Gaia url to use.
     'gaiaPath',      // Gaia path to use without a leading slash.
     'hl',            // Language code for the user interface.
     'service',       // Name of Gaia service.
     'continueUrl',   // Continue url to use.
     'frameUrl',      // Initial frame URL to use. If empty defaults to
                      // gaiaUrl.
     'constrained',   // Whether the extension is loaded in a constrained
                      // window.
     'clientId',      // Chrome client id.
     'useEafe',       // Whether to use EAFE.
     'needPassword',  // Whether the host is interested in getting a password.
                      // If this set to |false|, |confirmPasswordCallback| is
                      // not called before dispatching |authCopleted|.
                      // Default is |true|.
     'flow',          // One of 'default', 'enterprise', or 'theftprotection'.

[dschuyler, 2017/01/06 02:16:33]

Could the formatter align the comments in all of SUPPORTED_PARAMS?

[Dan Beam, 2017/01/06 02:36:50]

maybe it could but there's style rules that discourage this, I'm pretty sure

-    'enterpriseDomain',    // Domain in which hosting device is (or should be)
-                           // enrolled.
-    'emailDomain',         // Value used to prefill domain for email.
-    'chromeType',          // Type of Chrome OS device, e.g. "chromebox".
-    'clientVersion',       // Version of the Chrome build.
-    'platformVersion',     // Version of the OS build.
-    'releaseChannel',      // Installation channel.
-    'endpointGen',         // Current endpoint generation.
-    'gapsCookie',          // GAPS cookie
+    'enterpriseDomain',  // Domain in which hosting device is (or should be)
+                         // enrolled.
+    'emailDomain',       // Value used to prefill domain for email.
+    'chromeType',        // Type of Chrome OS device, e.g. "chromebox".
+    'clientVersion',     // Version of the Chrome build.
+    'platformVersion',   // Version of the OS build.
+    'releaseChannel',    // Installation channel.
+    'endpointGen',       // Current endpoint generation.
+    'gapsCookie',        // GAPS cookie
 
     // The email fields allow for the following possibilities:
     //
     // 1/ If 'email' is not supplied, then the email text field is blank and the
     // user must type an email to proceed.
     //
     // 2/ If 'email' is supplied, and 'readOnlyEmail' is truthy, then the email
     // is hardcoded and the user cannot change it.  The user is asked for
     // password.  This is useful for re-auth scenarios, where chrome needs the
     // user to authenticate for a specific account and only that account.
@@ skipping 14 matching lines @@
    *     web pages.
    * @constructor
    */
   function Authenticator(webview) {
     this.webview_ = typeof webview == 'string' ? $(webview) : webview;
     assert(this.webview_);
 
     this.isLoaded_ = false;
     this.email_ = null;
     this.password_ = null;
-    this.gaiaId_ = null,
-    this.sessionIndex_ = null;
+    this.gaiaId_ = null, this.sessionIndex_ = null;

[dschuyler, 2017/01/06 02:16:33]

This looks like a typo in the original file.  s/,/;/

[Dan Beam, 2017/01/06 02:36:50]

yes, it is

     this.chooseWhatToSync_ = false;
     this.skipForNow_ = false;
     this.authFlow = AuthFlow.DEFAULT;
     this.authDomain = '';
     this.videoEnabled = false;
     this.idpOrigin_ = null;
     this.continueUrl_ = null;
     this.continueUrlWithoutParams_ = null;
     this.initialFrameUrl_ = null;
     this.reloadUrl_ = null;
     this.trusted_ = true;
     this.oauthCode_ = null;
     this.gapsCookie_ = null;
     this.gapsCookieSent_ = false;
     this.newGapsCookie_ = null;
     this.readyFired_ = false;
 
     this.useEafe_ = false;
     this.clientId_ = null;
 
     this.samlHandler_ = new cr.login.SamlHandler(this.webview_);
     this.confirmPasswordCallback = null;
     this.noPasswordCallback = null;
     this.insecureContentBlockedCallback = null;
     this.samlApiUsedCallback = null;
     this.missingGaiaInfoCallback = null;
     this.needPassword = true;
     this.samlHandler_.addEventListener(
-        'insecureContentBlocked',
-        this.onInsecureContentBlocked_.bind(this));
+        'insecureContentBlocked', this.onInsecureContentBlocked_.bind(this));
     this.samlHandler_.addEventListener(
-        'authPageLoaded',
-        this.onAuthPageLoaded_.bind(this));
+        'authPageLoaded', this.onAuthPageLoaded_.bind(this));
     this.samlHandler_.addEventListener(
-        'videoEnabled',
-        this.onVideoEnabled_.bind(this));
+        'videoEnabled', this.onVideoEnabled_.bind(this));
     this.samlHandler_.addEventListener(
-        'apiPasswordAdded',
-        this.onSamlApiPasswordAdded_.bind(this));
+        'apiPasswordAdded', this.onSamlApiPasswordAdded_.bind(this));
 
     this.webview_.addEventListener('droplink', this.onDropLink_.bind(this));
-    this.webview_.addEventListener(
-        'newwindow', this.onNewWindow_.bind(this));
+    this.webview_.addEventListener('newwindow', this.onNewWindow_.bind(this));
     this.webview_.addEventListener(
         'contentload', this.onContentLoad_.bind(this));
-    this.webview_.addEventListener(
-        'loadabort', this.onLoadAbort_.bind(this));
-    this.webview_.addEventListener(
-        'loadstop', this.onLoadStop_.bind(this));
-    this.webview_.addEventListener(
-        'loadcommit', this.onLoadCommit_.bind(this));
+    this.webview_.addEventListener('loadabort', this.onLoadAbort_.bind(this));
+    this.webview_.addEventListener('loadstop', this.onLoadStop_.bind(this));
+    this.webview_.addEventListener('loadcommit', this.onLoadCommit_.bind(this));
     this.webview_.request.onCompleted.addListener(
         this.onRequestCompleted_.bind(this),
-        {urls: ['<all_urls>'], types: ['main_frame']},
-        ['responseHeaders']);
+        {urls: ['<all_urls>'], types: ['main_frame']}, ['responseHeaders']);
     this.webview_.request.onHeadersReceived.addListener(
         this.onHeadersReceived_.bind(this),
         {urls: ['<all_urls>'], types: ['main_frame', 'xmlhttprequest']},
         ['responseHeaders']);
     window.addEventListener(
         'message', this.onMessageFromWebview_.bind(this), false);
-    window.addEventListener(
-        'focus', this.onFocus_.bind(this), false);
-    window.addEventListener(
-        'popstate', this.onPopState_.bind(this), false);
+    window.addEventListener('focus', this.onFocus_.bind(this), false);
+    window.addEventListener('popstate', this.onPopState_.bind(this), false);
   }
 
   Authenticator.prototype = Object.create(cr.EventTarget.prototype);
 
   /**
    * Reinitializes authentication parameters so that a failed login attempt
    * would not result in an infinite loop.
    */
   Authenticator.prototype.resetStates = function() {
     this.isLoaded_ = false;
@@ skipping 42 matching lines @@
     this.clientId_ = data.clientId;
     this.gapsCookie_ = data.gapsCookie;
     this.gapsCookieSent_ = false;
     this.newGapsCookie_ = null;
     this.dontResizeNonEmbeddedPages = data.dontResizeNonEmbeddedPages;
 
     this.initialFrameUrl_ = this.constructInitialFrameUrl_(data);
     this.reloadUrl_ = data.frameUrl || this.initialFrameUrl_;
     // Don't block insecure content for desktop flow because it lands on
     // http. Otherwise, block insecure content as long as gaia is https.
-    this.samlHandler_.blockInsecureContent = authMode != AuthMode.DESKTOP &&
-        this.idpOrigin_.startsWith('https://');
+    this.samlHandler_.blockInsecureContent =
+        authMode != AuthMode.DESKTOP && this.idpOrigin_.startsWith('https://');
     this.needPassword = !('needPassword' in data) || data.needPassword;
 
     if (this.isNewGaiaFlow) {
       this.webview_.contextMenus.onShow.addListener(function(e) {
         e.preventDefault();
       });
 
       if (!this.onBeforeSetHeadersSet_) {
         this.onBeforeSetHeadersSet_ = true;
         var filterPrefix = this.idpOrigin_ + EMBEDDED_SETUP_CHROMEOS_ENDPOINT;
@@ skipping 15 matching lines @@
   Authenticator.prototype.reload = function() {
     this.resetStates();
     this.webview_.src = this.reloadUrl_;
     this.isLoaded_ = true;
   };
 
   Authenticator.prototype.constructInitialFrameUrl_ = function(data) {
     if (data.doSamlRedirect) {
       var url = this.idpOrigin_ + SAML_REDIRECTION_PATH;
       url = appendParam(url, 'domain', data.enterpriseDomain);
-      url = appendParam(url, 'continue', data.gaiaUrl +
-          'o/oauth2/programmatic_auth?hl=' + data.hl +
-          '&scope=https%3A%2F%2Fwww.google.com%2Faccounts%2FOAuthLogin&' +
-          'client_id=' + encodeURIComponent(data.clientId) +
-          '&access_type=offline');
+      url = appendParam(
+          url, 'continue', data.gaiaUrl + 'o/oauth2/programmatic_auth?hl=' +
+              data.hl +
+              '&scope=https%3A%2F%2Fwww.google.com%2Faccounts%2FOAuthLogin&' +
+              'client_id=' + encodeURIComponent(data.clientId) +
+              '&access_type=offline');
 
       return url;
     }
 
     var path = data.gaiaPath;
     if (!path && this.isNewGaiaFlow)
       path = EMBEDDED_SETUP_CHROMEOS_ENDPOINT;
     if (!path)
       path = IDP_PATH;
     var url = this.idpOrigin_ + path;
@@ skipping 152 matching lines @@
         });
         // Removes "" around.
         this.email_ = signinDetails['email'].slice(1, -1);
         this.gaiaId_ = signinDetails['obfuscatedid'].slice(1, -1);
         this.sessionIndex_ = signinDetails['sessionindex'];
       } else if (headerName == LOCATION_HEADER) {
         // If the "choose what to sync" checkbox was clicked, then the continue
         // URL will contain a source=3 field.
         var location = decodeURIComponent(header.value);
         this.chooseWhatToSync_ = !!location.match(/(\?|&)source=3($|&)/);
-      } else if (
-          this.isNewGaiaFlow && headerName == SET_COOKIE_HEADER) {
+      } else if (this.isNewGaiaFlow && headerName == SET_COOKIE_HEADER) {
         var headerValue = header.value;
         if (headerValue.startsWith(OAUTH_CODE_COOKIE + '=')) {
           this.oauthCode_ =
               headerValue.substring(OAUTH_CODE_COOKIE.length + 1).split(';')[0];
         }
         if (headerValue.startsWith(GAPS_COOKIE + '=')) {
           this.newGapsCookie_ =
               headerValue.substring(GAPS_COOKIE.length + 1).split(';')[0];
         }
       }
@@ skipping 34 matching lines @@
     // We should re-send cookie if first request was unsuccessful (i.e. no new
     // GAPS cookie was received).
     if (this.isNewGaiaFlow && this.gapsCookie_ &&
         (!this.gapsCookieSent_ || !this.newGapsCookie_)) {
       var headers = details.requestHeaders;
       var found = false;
       var gapsCookie = this.gapsCookie_;
 
       for (var i = 0, l = headers.length; i < l; ++i) {
         if (headers[i].name == COOKIE_HEADER) {
-          headers[i].value = this.updateCookieValue_(headers[i].value,
-                                                     GAPS_COOKIE, gapsCookie);
+          headers[i].value = this.updateCookieValue_(
+              headers[i].value, GAPS_COOKIE, gapsCookie);
           found = true;
           break;
         }
       }
       if (!found) {
         details.requestHeaders.push(
             {name: COOKIE_HEADER, value: GAPS_COOKIE + '=' + gapsCookie});
       }
       this.gapsCookieSent_ = true;
     }
-    return {
-      requestHeaders: details.requestHeaders
-    };
+    return {requestHeaders: details.requestHeaders};
   };
 
   /**
    * Returns true if given HTML5 message is received from the webview element.
    * @param {object} e Payload of the received HTML5 message.
    */
   Authenticator.prototype.isGaiaMessage = function(e) {
     if (!this.isWebviewEvent_(e))
       return false;
 
     // The event origin does not have a trailing slash.
     if (e.origin != this.idpOrigin_.substring(0, this.idpOrigin_.length - 1)) {
       return false;
     }
 
     // EAFE passes back auth code via message.
-    if (this.useEafe_ &&
-        typeof e.data == 'object' &&
+    if (this.useEafe_ && typeof e.data == 'object' &&
         e.data.hasOwnProperty('authorizationCode')) {
       assert(!this.oauthCode_);
       this.oauthCode_ = e.data.authorizationCode;
-      this.dispatchEvent(
-          new CustomEvent('authCompleted',
-                          {
-                            detail: {
-                              authCodeOnly: true,
-                              authCode: this.oauthCode_
-                            }
-                          }));
+      this.dispatchEvent(new CustomEvent(
+          'authCompleted',
+          {detail: {authCodeOnly: true, authCode: this.oauthCode_}}));
       return;
     }
 
     // Gaia messages must be an object with 'method' property.
     if (typeof e.data != 'object' || !e.data.hasOwnProperty('method')) {
       return false;
     }
     return true;
   };
 
   /**
    * Invoked when an HTML5 message is received from the webview element.
    * @param {object} e Payload of the received HTML5 message.
    * @private
    */
   Authenticator.prototype.onMessageFromWebview_ = function(e) {
     if (!this.isGaiaMessage(e))
       return;
 
     var msg = e.data;
     if (msg.method == 'attemptLogin') {
       this.email_ = msg.email;
       if (this.authMode == AuthMode.DESKTOP)
         this.password_ = msg.password;
 
       this.chooseWhatToSync_ = msg.chooseWhatToSync;
       // We need to dispatch only first event, before user enters password.
-      this.dispatchEvent(
-          new CustomEvent('attemptLogin', {detail: msg.email}));
+      this.dispatchEvent(new CustomEvent('attemptLogin', {detail: msg.email}));
     } else if (msg.method == 'dialogShown') {
       this.dispatchEvent(new Event('dialogShown'));
     } else if (msg.method == 'dialogHidden') {
       this.dispatchEvent(new Event('dialogHidden'));
     } else if (msg.method == 'backButton') {
       this.dispatchEvent(new CustomEvent('backButton', {detail: msg.show}));
     } else if (msg.method == 'showView') {
       this.dispatchEvent(new Event('showView'));
     } else if (msg.method == 'identifierEntered') {
       this.dispatchEvent(new CustomEvent(
           'identifierEntered',
           {detail: {accountIdentifier: msg.accountIdentifier}}));
     } else {
       console.warn('Unrecognized message from GAIA: ' + msg.method);
     }
   };
 
   /**
    * Invoked by the hosting page to verify the Saml password.
    */
   Authenticator.prototype.verifyConfirmedPassword = function(password) {
     if (!this.samlHandler_.verifyConfirmedPassword(password)) {
       // Invoke confirm password callback asynchronously because the
       // verification was based on messages and caller (GaiaSigninScreen)
       // does not expect it to be called immediately.
       // TODO(xiyuan): Change to synchronous call when iframe based code
       // is removed.
-      var invokeConfirmPassword = (function() {
-        this.confirmPasswordCallback(this.email_,
-                                     this.samlHandler_.scrapedPasswordCount);
-      }).bind(this);
+      var invokeConfirmPassword =
+          (function() {
+            this.confirmPasswordCallback(
+                this.email_, this.samlHandler_.scrapedPasswordCount);
+          }).bind(this);
       window.setTimeout(invokeConfirmPassword, 0);
       return;
     }
 
     this.password_ = password;
     this.onAuthCompleted_();
   };
 
   /**
    * Check Saml flow and start password confirmation flow if needed. Otherwise,
@@ skipping 34 matching lines @@
         // If we scraped exactly one password, we complete the authentication
         // right away.
         this.password_ = this.samlHandler_.firstScrapedPassword;
         this.onAuthCompleted_();
         return;
       }
 
       if (this.confirmPasswordCallback) {
         // Confirm scraped password. The flow follows in
         // verifyConfirmedPassword.
-        this.confirmPasswordCallback(this.email_,
-                                     this.samlHandler_.scrapedPasswordCount);
+        this.confirmPasswordCallback(
+            this.email_, this.samlHandler_.scrapedPasswordCount);
         return;
       }
     }
 
     this.onAuthCompleted_();
   };
 
   /**
    * Invoked to complete the authentication using the password the user enters
    * manually for non-principals API SAML IdPs that we couldn't scrape their
    * password input.
    */
   Authenticator.prototype.completeAuthWithManualPassword = function(password) {
     this.password_ = password;
     this.onAuthCompleted_();
   };
 
   /**
    * Invoked to process authentication completion.
    * @private
    */
   Authenticator.prototype.onAuthCompleted_ = function() {
-    assert(this.skipForNow_ ||
-           (this.email_ && this.gaiaId_ && this.sessionIndex_));
+    assert(
+        this.skipForNow_ ||
+        (this.email_ && this.gaiaId_ && this.sessionIndex_));
     this.dispatchEvent(new CustomEvent(
         'authCompleted',
         // TODO(rsorokin): get rid of the stub values.
         {
           detail: {
             email: this.email_ || '',
             gaiaId: this.gaiaId_ || '',
             password: this.password_ || '',
             authCode: this.oauthCode_,
             usingSAML: this.authFlow == AuthFlow.SAML,
@@ skipping 102 matching lines @@
     } else if (currentUrl == BLANK_PAGE_URL) {
       this.fireReadyEvent_();
     }
   };
 
   /**
    * Invoked when the webview fails loading a page.
    * @private
    */
   Authenticator.prototype.onLoadAbort_ = function(e) {
-    this.dispatchEvent(new CustomEvent('loadAbort',
-        {detail: {error: e.reason, src: e.url}}));
+    this.dispatchEvent(
+        new CustomEvent('loadAbort', {detail: {error: e.reason, src: e.url}}));
   };
 
   /**
    * Invoked when the webview finishes loading a page.
    * @private
    */
   Authenticator.prototype.onLoadStop_ = function(e) {
     // Sends client id to EAFE on every loadstop after a small timeout. This is
     // needed because EAFE sits behind SSO and initialize asynchrounouly
     // and we don't know for sure when it is loaded and ready to listen
     // for message. The postMessage is guarded by EAFE's origin.
     if (this.useEafe_) {
       // An arbitrary small timeout for delivering the initial message.
       var EAFE_INITIAL_MESSAGE_DELAY_IN_MS = 500;
-      window.setTimeout((function() {
-        var msg = {
-          'clientId': this.clientId_
-        };
-        this.webview_.contentWindow.postMessage(msg, this.idpOrigin_);
-      }).bind(this), EAFE_INITIAL_MESSAGE_DELAY_IN_MS);
+      window.setTimeout(
+          (function() {
+            var msg = {'clientId': this.clientId_};
+            this.webview_.contentWindow.postMessage(msg, this.idpOrigin_);
+          }).bind(this),
+          EAFE_INITIAL_MESSAGE_DELAY_IN_MS);
     }
   };
 
   /**
    * Invoked when the webview navigates withing the current document.
    * @private
    */
   Authenticator.prototype.onLoadCommit_ = function(e) {
     if (this.oauthCode_)
       this.maybeCompleteAuth_();
@@ skipping 33 matching lines @@
   Authenticator.AuthMode = AuthMode;
   Authenticator.SUPPORTED_PARAMS = SUPPORTED_PARAMS;
 
   return {
     // TODO(guohui, xiyuan): Rename GaiaAuthHost to Authenticator once the old
     // iframe-based flow is deprecated.
     GaiaAuthHost: Authenticator,
     Authenticator: Authenticator
   };
 });