WIP: run clang-format-js on lots of things

chrome/browser/resources/print_preview/cloud_print_interface.js

 // Copyright (c) 2012 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('cloudprint', function() {
   'use strict';
 
   /**
    * API to the Google Cloud Print service.
    * @param {string} baseUrl Base part of the Google Cloud Print service URL
@@ skipping 133 matching lines @@
    * @const
    * @private
    */
   CloudPrintInterface.VERSION_REGEXP_ = /.*Chrome\/([\d\.]+)/i;
 
   /**
    * Enumeration of JSON response fields from Google Cloud Print API.
    * @enum {string}
    * @private
    */
-  CloudPrintInterface.JsonFields_ = {
-    PRINTER: 'printer'
-  };
+  CloudPrintInterface.JsonFields_ = {PRINTER: 'printer'};
 
   /**
    * Could Print origins used to search printers.
    * @type {!Array<!print_preview.Destination.Origin>}
    * @const
    * @private
    */
   CloudPrintInterface.CLOUD_ORIGINS_ = [
-      print_preview.Destination.Origin.COOKIES,
-      print_preview.Destination.Origin.DEVICE
-      // TODO(vitalybuka): Enable when implemented.
-      // ready print_preview.Destination.Origin.PROFILE
+    print_preview.Destination.Origin.COOKIES,
+    print_preview.Destination.Origin.DEVICE
+    // TODO(vitalybuka): Enable when implemented.
+    // ready print_preview.Destination.Origin.PROFILE
   ];
 
   CloudPrintInterface.prototype = {
     __proto__: cr.EventTarget.prototype,
 
     /** @return {string} Base URL of the Google Cloud Print service. */
     get baseUrl() {
       return this.baseUrl_;
     },
 
@@ skipping 33 matching lines @@
      * @param {string} account Account the search is sent for. It matters for
      *     COOKIES origin only, and can be empty (sent on behalf of the primary
      *     user in this case).
      * @param {!Array<!print_preview.Destination.Origin>} origins Origins to
      *     search printers for.
      * @private
      */
     search_: function(isRecent, account, origins) {
       var params = [
         new HttpParam('connection_status', 'ALL'),
-        new HttpParam('client', 'chrome'),
-        new HttpParam('use_cdd', 'true')
+        new HttpParam('client', 'chrome'), new HttpParam('use_cdd', 'true')
       ];
       if (isRecent) {
         params.push(new HttpParam('q', '^recent'));
       }
       origins.forEach(function(origin) {
         var cpRequest = this.buildRequest_(
-            'GET',
-            'search',
-            params,
-            origin,
-            account,
+            'GET', 'search', params, origin, account,
             this.onSearchDone_.bind(this, isRecent));
         this.outstandingCloudSearchRequests_.push(cpRequest);
         this.sendOrQueueRequest_(cpRequest);
       }, this);
     },
 
     /**
      * Sends Google Cloud Print printer sharing invitations API requests.
      * @param {string} account Account the request is sent for.
      */
     invites: function(account) {
       var params = [
         new HttpParam('client', 'chrome'),
       ];
       this.sendOrQueueRequest_(this.buildRequest_(
-          'GET',
-          'invites',
-          params,
-          print_preview.Destination.Origin.COOKIES,
-          account,
-          this.onInvitesDone_.bind(this)));
+          'GET', 'invites', params, print_preview.Destination.Origin.COOKIES,
+          account, this.onInvitesDone_.bind(this)));
     },
 
     /**
      * Accepts or rejects printer sharing invitation.
      * @param {!print_preview.Invitation} invitation Invitation to process.
      * @param {boolean} accept Whether to accept this invitation.
      */
     processInvite: function(invitation, accept) {
       var params = [
         new HttpParam('printerid', invitation.destination.id),
         new HttpParam('email', invitation.scopeId),
         new HttpParam('accept', accept),
         new HttpParam('use_cdd', true),
       ];
       this.sendOrQueueRequest_(this.buildRequest_(
-          'POST',
-          'processinvite',
-          params,
-          invitation.destination.origin,
+          'POST', 'processinvite', params, invitation.destination.origin,
           invitation.destination.account,
           this.onProcessInviteDone_.bind(this, invitation, accept)));
     },
 
     /**
      * Sends a Google Cloud Print submit API request.
      * @param {!print_preview.Destination} destination Cloud destination to
      *     print to.
      * @param {!print_preview.PrintTicketStore} printTicketStore Contains the
      *     print ticket to print.
      * @param {!print_preview.DocumentInfo} documentInfo Document data model.
      * @param {string} data Base64 encoded data of the document.
      */
     submit: function(destination, printTicketStore, documentInfo, data) {
       var result =
           CloudPrintInterface.VERSION_REGEXP_.exec(navigator.userAgent);
       var chromeVersion = 'unknown';
       if (result && result.length == 2) {
         chromeVersion = result[1];
       }
       var params = [
         new HttpParam('printerid', destination.id),
         new HttpParam('contentType', 'dataUrl'),
         new HttpParam('title', documentInfo.title),
-        new HttpParam('ticket',
-                      printTicketStore.createPrintTicket(destination)),
+        new HttpParam(
+            'ticket', printTicketStore.createPrintTicket(destination)),
         new HttpParam('content', 'data:application/pdf;base64,' + data),
-        new HttpParam('tag',
-                      '__google__chrome_version=' + chromeVersion),
+        new HttpParam('tag', '__google__chrome_version=' + chromeVersion),
         new HttpParam('tag', '__google__os=' + navigator.platform)
       ];
       var cpRequest = this.buildRequest_(
-          'POST',
-          'submit',
-          params,
-          destination.origin,
-          destination.account,
+          'POST', 'submit', params, destination.origin, destination.account,
           this.onSubmitDone_.bind(this));
       this.sendOrQueueRequest_(cpRequest);
     },
 
     /**
      * Sends a Google Cloud Print printer API request.
      * @param {string} printerId ID of the printer to lookup.
      * @param {!print_preview.Destination.Origin} origin Origin of the printer.
      * @param {string=} account Account this printer is registered for. When
      *     provided for COOKIES {@code origin}, and users sessions are still not
      *     known, will be checked against the response (both success and failure
      *     to get printer) and, if the active user account is not the one
      *     requested, {@code account} is activated and printer request reissued.
      */
     printer: function(printerId, origin, account) {
       var params = [
-        new HttpParam('printerid', printerId),
-        new HttpParam('use_cdd', 'true'),
+        new HttpParam('printerid', printerId), new HttpParam('use_cdd', 'true'),
         new HttpParam('printer_connection_status', 'true')
       ];
       this.sendOrQueueRequest_(this.buildRequest_(
-          'GET',
-          'printer',
-          params,
-          origin,
-          account,
+          'GET', 'printer', params, origin, account,
           this.onPrinterDone_.bind(this, printerId)));
     },
 
     /**
      * Sends a Google Cloud Print update API request to accept (or reject) the
      * terms-of-service of the given printer.
      * @param {!print_preview.Destination} destination Destination to accept ToS
      *     for.
      * @param {boolean} isAccepted Whether the user accepted ToS or not.
      */
     updatePrinterTosAcceptance: function(destination, isAccepted) {
       var params = [
         new HttpParam('printerid', destination.id),
         new HttpParam('is_tos_accepted', isAccepted)
       ];
       this.sendOrQueueRequest_(this.buildRequest_(
-          'POST',
-          'update',
-          params,
-          destination.origin,
-          destination.account,
+          'POST', 'update', params, destination.origin, destination.account,
           this.onUpdatePrinterTosAcceptanceDone_.bind(this)));
     },
 
     /**
      * Adds event listeners to relevant events.
      * @private
      */
     addEventListeners_: function() {
       this.tracker_.add(
           this.nativeLayer_,
@@ skipping 155 matching lines @@
      */
     onAccessTokenReady_: function(event) {
       // TODO(vitalybuka): remove when other Origins implemented.
       assert(event.authType == print_preview.Destination.Origin.DEVICE);
       this.requestQueue_ = this.requestQueue_.filter(function(request) {
         assert(request.origin == print_preview.Destination.Origin.DEVICE);
         if (request.origin != event.authType) {
           return true;
         }
         if (event.accessToken) {
-          request.xhr.setRequestHeader('Authorization',
-                                       'Bearer ' + event.accessToken);
+          request.xhr.setRequestHeader(
+              'Authorization', 'Bearer ' + event.accessToken);
           this.sendRequest_(request);
         } else {  // No valid token.
           // Without abort status does not exist.
           request.xhr.abort();
           request.callback(request);
         }
         return false;
       }, this);
     },
 
@@ skipping 29 matching lines @@
       var lastRequestForThisOrigin = true;
       this.outstandingCloudSearchRequests_ =
           this.outstandingCloudSearchRequests_.filter(function(item) {
             if (item != request && item.origin == request.origin) {
               lastRequestForThisOrigin = false;
             }
             return item != request;
           });
       var activeUser = '';
       if (request.origin == print_preview.Destination.Origin.COOKIES) {
-        activeUser =
-            request.result &&
-            request.result['request'] &&
+        activeUser = request.result && request.result['request'] &&
             request.result['request']['user'];
       }
       var event = null;
       if (request.xhr.status == 200 && request.result['success']) {
         // Extract printers.
         var printerListJson = request.result['printers'] || [];
         var printerList = [];
         printerListJson.forEach(function(printerJson) {
           try {
             printerList.push(cloudprint.CloudDestinationParser.parse(
                 printerJson, request.origin, activeUser));
           } catch (err) {
             console.error('Unable to parse cloud print destination: ' + err);
           }
         });
         // Extract and store users.
         this.setUsers_(request);
         // Dispatch SEARCH_DONE event.
         event = new Event(CloudPrintInterface.EventType.SEARCH_DONE);
         event.origin = request.origin;
         event.printers = printerList;
         event.isRecent = isRecent;
       } else {
         event = this.createErrorEvent_(
-            CloudPrintInterface.EventType.SEARCH_FAILED,
-            request);
+            CloudPrintInterface.EventType.SEARCH_FAILED, request);
       }
       event.user = activeUser;
       event.searchDone = lastRequestForThisOrigin;
       this.dispatchEvent(event);
     },
 
     /**
      * Called when invitations search request completes.
      * @param {!CloudPrintRequest} request Request that has been completed.
      * @private
      */
     onInvitesDone_: function(request) {
       var event = null;
-      var activeUser =
-          (request.result &&
-           request.result['request'] &&
-           request.result['request']['user']) || '';
+      var activeUser = (request.result && request.result['request'] &&
+                        request.result['request']['user']) ||
+          '';
       if (request.xhr.status == 200 && request.result['success']) {
         // Extract invitations.
         var invitationListJson = request.result['invites'] || [];
         var invitationList = [];
         invitationListJson.forEach(function(invitationJson) {
           try {
-            invitationList.push(cloudprint.InvitationParser.parse(
-                invitationJson, activeUser));
+            invitationList.push(
+                cloudprint.InvitationParser.parse(invitationJson, activeUser));
           } catch (e) {
             console.error('Unable to parse invitation: ' + e);
           }
         });
         // Dispatch INVITES_DONE event.
         event = new Event(CloudPrintInterface.EventType.INVITES_DONE);
         event.invitations = invitationList;
       } else {
         event = this.createErrorEvent_(
             CloudPrintInterface.EventType.INVITES_FAILED, request);
       }
       event.user = activeUser;
       this.dispatchEvent(event);
     },
 
     /**
      * Called when invitation processing request completes.
      * @param {!print_preview.Invitation} invitation Processed invitation.
      * @param {boolean} accept Whether this invitation was accepted or rejected.
      * @param {!CloudPrintRequest} request Request that has been completed.
      * @private
      */
     onProcessInviteDone_: function(invitation, accept, request) {
       var event = null;
-      var activeUser =
-          (request.result &&
-           request.result['request'] &&
-           request.result['request']['user']) || '';
+      var activeUser = (request.result && request.result['request'] &&
+                        request.result['request']['user']) ||
+          '';
       if (request.xhr.status == 200 && request.result['success']) {
         event = new Event(CloudPrintInterface.EventType.PROCESS_INVITE_DONE);
         if (accept) {
           try {
             event.printer = cloudprint.CloudDestinationParser.parse(
                 request.result['printer'], request.origin, activeUser);
           } catch (e) {
             console.error('Failed to parse cloud print destination: ' + e);
           }
         }
       } else {
         event = this.createErrorEvent_(
             CloudPrintInterface.EventType.PROCESS_INVITE_FAILED, request);
       }
       event.invitation = invitation;
       event.accept = accept;
       event.user = activeUser;
       this.dispatchEvent(event);
     },
 
     /**
      * Called when the submit request completes.
      * @param {!CloudPrintRequest} request Request that has been completed.
      * @private
      */
     onSubmitDone_: function(request) {
       if (request.xhr.status == 200 && request.result['success']) {
-        var submitDoneEvent = new Event(
-            CloudPrintInterface.EventType.SUBMIT_DONE);
+        var submitDoneEvent =
+            new Event(CloudPrintInterface.EventType.SUBMIT_DONE);
         submitDoneEvent.jobId = request.result['job']['id'];
         this.dispatchEvent(submitDoneEvent);
       } else {
         var errorEvent = this.createErrorEvent_(
             CloudPrintInterface.EventType.SUBMIT_FAILED, request);
         this.dispatchEvent(errorEvent);
       }
     },
 
     /**
      * Called when the printer request completes.
      * @param {string} destinationId ID of the destination that was looked up.
      * @param {!CloudPrintRequest} request Request that has been completed.
      * @private
      */
     onPrinterDone_: function(destinationId, request) {
       // Special handling of the first printer request. It does not matter at
       // this point, whether printer was found or not.
       if (request.origin == print_preview.Destination.Origin.COOKIES &&
-          request.result &&
-          request.account &&
+          request.result && request.account &&
           request.result['request']['user'] &&
           request.result['request']['users'] &&
           request.account != request.result['request']['user']) {
         this.setUsers_(request);
         // In case the user account is known, but not the primary one,
         // activate it.
         if (this.userSessionIndex_[request.account] > 0) {
           this.userInfo_.activeUser = request.account;
           // Repeat the request for the newly activated account.
           this.printer(
-              request.result['request']['params']['printerid'],
-              request.origin,
+              request.result['request']['params']['printerid'], request.origin,
               request.account);
           // Stop processing this request, wait for the new response.
           return;
         }
       }
       // Process response.
       if (request.xhr.status == 200 && request.result['success']) {
         var activeUser = '';
         if (request.origin == print_preview.Destination.Origin.COOKIES) {
           activeUser = request.result['request']['user'];
         }
         var printerJson = request.result['printers'][0];
         var printer;
         try {
           printer = cloudprint.CloudDestinationParser.parse(
               printerJson, request.origin, activeUser);
         } catch (err) {
-          console.error('Failed to parse cloud print destination: ' +
+          console.error(
+              'Failed to parse cloud print destination: ' +
               JSON.stringify(printerJson));
           return;
         }
         var printerDoneEvent =
             new Event(CloudPrintInterface.EventType.PRINTER_DONE);
         printerDoneEvent.printer = printer;
         this.dispatchEvent(printerDoneEvent);
       } else {
         var errorEvent = this.createErrorEvent_(
             CloudPrintInterface.EventType.PRINTER_FAILED, request);
@@ skipping 83 matching lines @@
     this.name = name;
 
     /**
      * Name of the value.
      * @type {string}
      */
     this.value = value;
   };
 
   // Export
-  return {
-    CloudPrintInterface: CloudPrintInterface
-  };
+  return {CloudPrintInterface: CloudPrintInterface};
 });