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

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.exportPath('cloudprint');
 
 /**
  * Event types dispatched by the cloudprint interface.
  * @enum {string}
  */
 cloudprint.CloudPrintInterfaceEventType = {
   INVITES_DONE: 'cloudprint.CloudPrintInterface.INVITES_DONE',
   INVITES_FAILED: 'cloudprint.CloudPrintInterface.INVITES_FAILED',
   PRINTER_DONE: 'cloudprint.CloudPrintInterface.PRINTER_DONE',
   PRINTER_FAILED: 'cloudprint.CloudPrintInterface.PRINTER_FAILED',
   PROCESS_INVITE_DONE: 'cloudprint.CloudPrintInterface.PROCESS_INVITE_DONE',
-  PROCESS_INVITE_FAILED:
-      'cloudprint.CloudPrintInterface.PROCESS_INVITE_FAILED',
+  PROCESS_INVITE_FAILED: 'cloudprint.CloudPrintInterface.PROCESS_INVITE_FAILED',
   SEARCH_DONE: 'cloudprint.CloudPrintInterface.SEARCH_DONE',
   SEARCH_FAILED: 'cloudprint.CloudPrintInterface.SEARCH_FAILED',
   SUBMIT_DONE: 'cloudprint.CloudPrintInterface.SUBMIT_DONE',
   SUBMIT_FAILED: 'cloudprint.CloudPrintInterface.SUBMIT_FAILED',
 };
 
 cr.define('cloudprint', function() {
   'use strict';
 
   var CloudPrintInterfaceEventType = cloudprint.CloudPrintInterfaceEventType;
@@ skipping 117 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.DestinationOrigin>}
    * @const
    * @private
    */
   CloudPrintInterface.CLOUD_ORIGINS_ = [
-      print_preview.DestinationOrigin.COOKIES,
-      print_preview.DestinationOrigin.DEVICE
-      // TODO(vitalybuka): Enable when implemented.
-      // ready print_preview.DestinationOrigin.PROFILE
+    print_preview.DestinationOrigin.COOKIES,
+    print_preview.DestinationOrigin.DEVICE
+    // TODO(vitalybuka): Enable when implemented.
+    // ready print_preview.DestinationOrigin.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.DestinationOrigin>} 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.DestinationOrigin.COOKIES,
-          account,
-          this.onInvitesDone_.bind(this)));
+          'GET', 'invites', params, print_preview.DestinationOrigin.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 ? 'true' : 'false'),
         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.DestinationOrigin} 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)));
     },
 
     /**
      * Adds event listeners to relevant events.
      * @private
      */
     addEventListeners_: function() {
       this.tracker_.add(
           this.nativeLayer_.getEventTarget(),
@@ skipping 52 matching lines @@
       var headers = {};
       headers['X-CloudPrint-Proxy'] = 'ChromePrintPreview';
       if (method == 'GET') {
         headers['Content-Type'] = CloudPrintInterface.URL_ENCODED_CONTENT_TYPE_;
       } else if (method == 'POST') {
         headers['Content-Type'] = CloudPrintInterface.MULTIPART_CONTENT_TYPE_;
       }
 
       var xhr = new XMLHttpRequest();
       xhr.open(method, url, true);
-      xhr.withCredentials =
-          (origin == print_preview.DestinationOrigin.COOKIES);
+      xhr.withCredentials = (origin == print_preview.DestinationOrigin.COOKIES);
       for (var header in headers) {
         xhr.setRequestHeader(header, headers[header]);
       }
 
-      return new cloudprint.CloudPrintRequest(xhr, body, origin, account,
-                                              callback);
+      return new cloudprint.CloudPrintRequest(
+          xhr, body, origin, account, callback);
     },
 
     /**
      * Sends a request to the Google Cloud Print API or queues if it needs to
      *     wait OAuth2 access token.
      * @param {!cloudprint.CloudPrintRequest} request Request to send or queue.
      * @private
      */
     sendOrQueueRequest_: function(request) {
       if (request.origin == print_preview.DestinationOrigin.COOKIES) {
@@ skipping 79 matching lines @@
      */
     onAccessTokenReady_: function(event) {
       // TODO(vitalybuka): remove when other Origins implemented.
       assert(event.authType == print_preview.DestinationOrigin.DEVICE);
       this.requestQueue_ = this.requestQueue_.filter(function(request) {
         assert(request.origin == print_preview.DestinationOrigin.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);
     },
 
     /**
      * Called when the ready-state of a XML http request changes.
      * Calls the successCallback with the result or dispatches an ERROR event.
      * @param {!cloudprint.CloudPrintRequest} request Request that was changed.
      * @private
      */
     onReadyStateChange_: function(request) {
       if (request.xhr.readyState == 4) {
         if (request.xhr.status == 200) {
-          request.result = /** @type {Object} */ (
-              JSON.parse(request.xhr.responseText));
+          request.result =
+              /** @type {Object} */ (JSON.parse(request.xhr.responseText));
           if (request.origin == print_preview.DestinationOrigin.COOKIES &&
               request.result['success']) {
             this.xsrfTokens_[request.result['request']['user']] =
                 request.result['xsrf_token'];
           }
         }
         request.status = request.xhr.status;
         request.callback(request);
       }
     },
@@ skipping 10 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.DestinationOrigin.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(CloudPrintInterfaceEventType.SEARCH_DONE);
         event.origin = request.origin;
         event.printers = printerList;
         event.isRecent = isRecent;
       } else {
         event = this.createErrorEvent_(
-            CloudPrintInterfaceEventType.SEARCH_FAILED,
-            request);
+            CloudPrintInterfaceEventType.SEARCH_FAILED, request);
       }
       event.user = activeUser;
       event.searchDone = lastRequestForThisOrigin;
       this.dispatchEvent(event);
     },
 
     /**
      * Called when invitations search request completes.
      * @param {!cloudprint.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(CloudPrintInterfaceEventType.INVITES_DONE);
         event.invitations = invitationList;
       } else {
         event = this.createErrorEvent_(
             CloudPrintInterfaceEventType.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 {!cloudprint.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(CloudPrintInterfaceEventType.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_(
             CloudPrintInterfaceEventType.PROCESS_INVITE_FAILED, request);
       }
       event.invitation = invitation;
       event.accept = accept;
       event.user = activeUser;
       this.dispatchEvent(event);
     },
 
     /**
      * Called when the submit request completes.
      * @param {!cloudprint.CloudPrintRequest} request Request that has been
      *     completed.
      * @private
      */
     onSubmitDone_: function(request) {
       if (request.xhr.status == 200 && request.result['success']) {
-        var submitDoneEvent = new Event(
-            CloudPrintInterfaceEventType.SUBMIT_DONE);
+        var submitDoneEvent =
+            new Event(CloudPrintInterfaceEventType.SUBMIT_DONE);
         submitDoneEvent.jobId = request.result['job']['id'];
         this.dispatchEvent(submitDoneEvent);
       } else {
         var errorEvent = this.createErrorEvent_(
             CloudPrintInterfaceEventType.SUBMIT_FAILED, request);
         this.dispatchEvent(errorEvent);
       }
     },
 
     /**
      * Called when the printer request completes.
      * @param {string} destinationId ID of the destination that was looked up.
      * @param {!cloudprint.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.DestinationOrigin.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.DestinationOrigin.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(CloudPrintInterfaceEventType.PRINTER_DONE);
         printerDoneEvent.printer = printer;
         this.dispatchEvent(printerDoneEvent);
       } else {
         var errorEvent = this.createErrorEvent_(
             CloudPrintInterfaceEventType.PRINTER_FAILED, request);
@@ skipping 73 matching lines @@
      */
     this.value = value;
   }
 
   // Export
   return {
     CloudPrintInterface: CloudPrintInterface,
     CloudPrintRequest: CloudPrintRequest
   };
 });