Print Preview: Fix top level directory compile errors

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',
+  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;
+
   /**
    * API to the Google Cloud Print service.
    * @param {string} baseUrl Base part of the Google Cloud Print service URL
    *     with no trailing slash. For example,
    *     'https://www.google.com/cloudprint'.
    * @param {!print_preview.NativeLayer} nativeLayer Native layer used to get
    *     Auth2 tokens.
    * @param {!print_preview.UserInfo} userInfo User information repository.
    * @param {boolean} isInAppKioskMode Whether the print preview is in App
    *     Kiosk mode.
@@ skipping 42 matching lines @@
     /**
      * Stores last received XSRF tokens for each user account. Sent as
      * a parameter with every request.
      * @type {!Object<string>}
      * @private
      */
     this.xsrfTokens_ = {};
 
     /**
      * Pending requests delayed until we get access token.
-     * @type {!Array<!CloudPrintRequest>}
+     * @type {!Array<!cloudprint.CloudPrintRequest>}
      * @private
      */
     this.requestQueue_ = [];
 
     /**
      * Outstanding cloud destination search requests.
-     * @type {!Array<!CloudPrintRequest>}
+     * @type {!Array<!cloudprint.CloudPrintRequest>}
      * @private
      */
     this.outstandingCloudSearchRequests_ = [];
 
     /**
      * Event tracker used to keep track of native layer events.
      * @type {!EventTracker}
      * @private
      */
     this.tracker_ = new EventTracker();
 
     this.addEventListeners_();
-  };
-
-  /**
-   * Event types dispatched by the interface.
-   * @enum {string}
-   */
-  CloudPrintInterface.EventType = {
-    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',
-    SEARCH_DONE: 'cloudprint.CloudPrintInterface.SEARCH_DONE',
-    SEARCH_FAILED: 'cloudprint.CloudPrintInterface.SEARCH_FAILED',
-    SUBMIT_DONE: 'cloudprint.CloudPrintInterface.SUBMIT_DONE',
-    SUBMIT_FAILED: 'cloudprint.CloudPrintInterface.SUBMIT_FAILED',
-  };
+  }
 
   /**
    * Content type header value for a URL encoded HTTP request.
    * @type {string}
    * @const
    * @private
    */
   CloudPrintInterface.URL_ENCODED_CONTENT_TYPE_ =
       'application/x-www-form-urlencoded';
 
@@ skipping 57 matching lines @@
 
     /**
      * @return {boolean} Whether a search for cloud destinations is in progress.
      */
     get isCloudDestinationSearchInProgress() {
       return this.outstandingCloudSearchRequests_.length > 0;
     },
 
     /**
      * Sends Google Cloud Print search API request.
-     * @param {string=} opt_account Account the search is sent for. When
-     *      omitted, the search is done on behalf of the primary user.
+     * @param {?string=} opt_account Account the search is sent for. When
+     *      null or omitted, the search is done on behalf of the primary user.
      * @param {print_preview.DestinationOrigin=} opt_origin When specified,
      *     searches destinations for {@code opt_origin} only, otherwise starts
      *     searches for all origins.
      */
     search: function(opt_account, opt_origin) {
       var account = opt_account || '';
       var origins =
           opt_origin && [opt_origin] || CloudPrintInterface.CLOUD_ORIGINS_;
       if (this.isInAppKioskMode_) {
         origins = origins.filter(function(origin) {
@@ skipping 57 matching lines @@
 
     /**
      * 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),
+        accept ? new HttpParam('accept', 'true') :

[dpapad, 2017/05/05 23:30:29]

You can compact (and satisfy the compiler) as follows,

new HttpParam('accept', accept ? 'true' : false)
or
new HttpParam('accept', accept.toString());

[rbpotter, 2017/05/06 00:02:19]

Done.

+                 new HttpParam('accept', 'false'),
+        new HttpParam('use_cdd', 'true'),
       ];
       this.sendOrQueueRequest_(this.buildRequest_(
           'POST',
           'processinvite',
           params,
           invitation.destination.origin,
           invitation.destination.account,
           this.onProcessInviteDone_.bind(this, invitation, accept)));
     },
 
@@ skipping 48 matching lines @@
       var params = [
         new HttpParam('printerid', printerId),
         new HttpParam('use_cdd', 'true'),
         new HttpParam('printer_connection_status', 'true')
       ];
       this.sendOrQueueRequest_(this.buildRequest_(
           'GET',
           'printer',
           params,
           origin,
-          account,
+          account || '',
           this.onPrinterDone_.bind(this, printerId)));
     },
 
     /**
      * Adds event listeners to relevant events.
      * @private
      */
     addEventListeners_: function() {
       this.tracker_.add(
           this.nativeLayer_,
           print_preview.NativeLayer.EventType.ACCESS_TOKEN_READY,
           this.onAccessTokenReady_.bind(this));
     },
 
     /**
      * Builds request to the Google Cloud Print API.
      * @param {string} method HTTP method of the request.
      * @param {string} action Google Cloud Print action to perform.
      * @param {Array<!HttpParam>} params HTTP parameters to include in the
      *     request.
      * @param {!print_preview.DestinationOrigin} origin Origin for destination.
      * @param {?string} account Account the request is sent for. Can be
      *     {@code null} or empty string if the request is not cookie bound or
      *     is sent on behalf of the primary user.
-     * @param {function(number, Object, !print_preview.DestinationOrigin)}
-     *     callback Callback to invoke when request completes.
-     * @return {!CloudPrintRequest} Partially prepared request.
+     * @param {function(!cloudprint.CloudPrintRequest)} callback Callback to
+     *     invoke when request completes.
+     * @return {!cloudprint.CloudPrintRequest} Partially prepared request.
      * @private
      */
     buildRequest_: function(method, action, params, origin, account, callback) {
       var url = this.baseUrl_ + '/' + action + '?xsrf=';
       if (origin == print_preview.DestinationOrigin.COOKIES) {
         var xsrfToken = this.xsrfTokens_[account];
         if (!xsrfToken) {
           // TODO(rltoscano): Should throw an error if not a read-only action or
           // issue an xsrf token request.
         } else {
@@ skipping 31 matching lines @@
       }
 
       var xhr = new XMLHttpRequest();
       xhr.open(method, url, true);
       xhr.withCredentials =
           (origin == print_preview.DestinationOrigin.COOKIES);
       for (var header in headers) {
         xhr.setRequestHeader(header, headers[header]);
       }
 
-      return new 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 {!CloudPrintRequest} request Request to send or queue.
+     * @param {!cloudprint.CloudPrintRequest} request Request to send or queue.
      * @private
      */
     sendOrQueueRequest_: function(request) {
       if (request.origin == print_preview.DestinationOrigin.COOKIES) {
         return this.sendRequest_(request);
       } else {
         this.requestQueue_.push(request);
         this.nativeLayer_.startGetAccessToken(request.origin);
       }
     },
 
     /**
      * Sends a request to the Google Cloud Print API.
-     * @param {!CloudPrintRequest} request Request to send.
+     * @param {!cloudprint.CloudPrintRequest} request Request to send.
      * @private
      */
     sendRequest_: function(request) {
       request.xhr.onreadystatechange =
           this.onReadyStateChange_.bind(this, request);
       request.xhr.send(request.body);
     },
 
     /**
      * Creates a Google Cloud Print interface error that is ready to dispatch.
-     * @param {!CloudPrintInterface.EventType} type Type of the error.
-     * @param {!CloudPrintRequest} request Request that has been completed.
+     * @param {!cloudprint.CloudPrintInterfaceEventType} type Type of the
+     *     error.
+     * @param {!cloudprint.CloudPrintRequest} request Request that has been
+     *     completed.
      * @return {!Event} Google Cloud Print interface error event.
      * @private
      */
     createErrorEvent_: function(type, request) {
       var errorEvent = new Event(type);
       errorEvent.status = request.xhr.status;
       if (request.xhr.status == 200) {
         errorEvent.errorCode = request.result['errorCode'];
         errorEvent.message = request.result['message'];
       } else {
         errorEvent.errorCode = 0;
         errorEvent.message = '';
       }
       errorEvent.origin = request.origin;
       return errorEvent;
     },
 
     /**
      * Updates user info and session index from the {@code request} response.
-     * @param {!CloudPrintRequest} request Request to extract user info from.
+     * @param {!cloudprint.CloudPrintRequest} request Request to extract user
+     *     info from.
      * @private
      */
     setUsers_: function(request) {
       if (request.origin == print_preview.DestinationOrigin.COOKIES) {
         var users = request.result['request']['users'] || [];
         this.userSessionIndex_ = {};
         for (var i = 0; i < users.length; i++) {
           this.userSessionIndex_[users[i]] = i;
         }
         this.userInfo_.setUsers(request.result['request']['user'], users);
@@ skipping 39 matching lines @@
           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 {!CloudPrintRequest} request Request that was changed.
+     * @param {!cloudprint.CloudPrintRequest} request Request that was changed.
      * @private
      */
     onReadyStateChange_: function(request) {
       if (request.xhr.readyState == 4) {
         if (request.xhr.status == 200) {
-          request.result = 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);
       }
     },
 
     /**
      * Called when the search request completes.
      * @param {boolean} isRecent Whether the search request was for recent
      *     destinations.
-     * @param {!CloudPrintRequest} request Request that has been completed.
+     * @param {!cloudprint.CloudPrintRequest} request Request that has been
+     *     completed.
      * @private
      */
     onSearchDone_: function(isRecent, request) {
       var lastRequestForThisOrigin = true;
       this.outstandingCloudSearchRequests_ =
           this.outstandingCloudSearchRequests_.filter(function(item) {
             if (item != request && item.origin == request.origin) {
               lastRequestForThisOrigin = false;
             }
             return item != request;
@@ skipping 14 matching lines @@
           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 = new Event(CloudPrintInterfaceEventType.SEARCH_DONE);
         event.origin = request.origin;
         event.printers = printerList;
         event.isRecent = isRecent;
       } else {
         event = this.createErrorEvent_(
-            CloudPrintInterface.EventType.SEARCH_FAILED,
+            CloudPrintInterfaceEventType.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.
+     * @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']) || '';
       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));
           } catch (e) {
             console.error('Unable to parse invitation: ' + e);
           }
         });
         // Dispatch INVITES_DONE event.
-        event = new Event(CloudPrintInterface.EventType.INVITES_DONE);
+        event = new Event(CloudPrintInterfaceEventType.INVITES_DONE);
         event.invitations = invitationList;
       } else {
         event = this.createErrorEvent_(
-            CloudPrintInterface.EventType.INVITES_FAILED, request);
+            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 {!CloudPrintRequest} request Request that has been completed.
+     * @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']) || '';
       if (request.xhr.status == 200 && request.result['success']) {
-        event = new Event(CloudPrintInterface.EventType.PROCESS_INVITE_DONE);
+        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_(
-            CloudPrintInterface.EventType.PROCESS_INVITE_FAILED, request);
+            CloudPrintInterfaceEventType.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.
+     * @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(
-            CloudPrintInterface.EventType.SUBMIT_DONE);
+            CloudPrintInterfaceEventType.SUBMIT_DONE);
         submitDoneEvent.jobId = request.result['job']['id'];
         this.dispatchEvent(submitDoneEvent);
       } else {
         var errorEvent = this.createErrorEvent_(
-            CloudPrintInterface.EventType.SUBMIT_FAILED, request);
+            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 {!CloudPrintRequest} request Request that has been completed.
+     * @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']['user'] &&
           request.result['request']['users'] &&
@@ skipping 22 matching lines @@
         var printer;
         try {
           printer = cloudprint.CloudDestinationParser.parse(
               printerJson, request.origin, activeUser);
         } catch (err) {
           console.error('Failed to parse cloud print destination: ' +
               JSON.stringify(printerJson));
           return;
         }
         var printerDoneEvent =
-            new Event(CloudPrintInterface.EventType.PRINTER_DONE);
+            new Event(CloudPrintInterfaceEventType.PRINTER_DONE);
         printerDoneEvent.printer = printer;
         this.dispatchEvent(printerDoneEvent);
       } else {
         var errorEvent = this.createErrorEvent_(
-            CloudPrintInterface.EventType.PRINTER_FAILED, request);
+            CloudPrintInterfaceEventType.PRINTER_FAILED, request);
         errorEvent.destinationId = destinationId;
         errorEvent.destinationOrigin = request.origin;
         this.dispatchEvent(errorEvent);
       }
     },
   };
 
   /**
    * Data structure that holds data for Cloud Print requests.
    * @param {!XMLHttpRequest} xhr Partially prepared http request.
    * @param {string} body Data to send with POST requests.
    * @param {!print_preview.DestinationOrigin} origin Origin for destination.
    * @param {?string} account Account the request is sent for. Can be
    *     {@code null} or empty string if the request is not cookie bound or
    *     is sent on behalf of the primary user.
-   * @param {function(!CloudPrintRequest)} callback Callback to invoke when
-   *     request completes.
+   * @param {function(!cloudprint.CloudPrintRequest)} callback Callback to
+   *     invoke when request completes.
    * @constructor
    */
   function CloudPrintRequest(xhr, body, origin, account, callback) {
     /**
      * Partially prepared http request.
      * @type {!XMLHttpRequest}
      */
     this.xhr = xhr;
 
     /**
      * Data to send with POST requests.
      * @type {string}
      */
     this.body = body;
 
     /**
      * Origin for destination.
      * @type {!print_preview.DestinationOrigin}
      */
     this.origin = origin;
 
     /**
      * User account this request is expected to be executed for.
      * @type {?string}
      */
     this.account = account;
 
     /**
      * Callback to invoke when request completes.
-     * @type {function(!CloudPrintRequest)}
+     * @type {function(!cloudprint.CloudPrintRequest)}
      */
     this.callback = callback;
 
     /**
      * Result for requests.
      * @type {Object} JSON response.
      */
     this.result = null;
-  };
+  }
 
   /**
    * Data structure that represents an HTTP parameter.
    * @param {string} name Name of the parameter.
    * @param {string} value Value of the parameter.
    * @constructor
    */
   function HttpParam(name, value) {
     /**
      * Name of the parameter.
      * @type {string}
      */
     this.name = name;
 
     /**
      * Name of the value.
      * @type {string}
      */
     this.value = value;
-  };
+  }
 
   // Export
   return {
-    CloudPrintInterface: CloudPrintInterface
+    CloudPrintInterface: CloudPrintInterface,
+    CloudPrintRequest: CloudPrintRequest
   };
 });