Print Preview: Fix data/ 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.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 137 matching lines @@
    * Enumeration of JSON response fields from Google Cloud Print API.
    * @enum {string}
    * @private
    */
   CloudPrintInterface.JsonFields_ = {
     PRINTER: 'printer'
   };
 
   /**
    * Could Print origins used to search printers.
-   * @type {!Array<!print_preview.Destination.Origin>}
+   * @type {!Array<!print_preview.DestinationOrigin>}
    * @const
    * @private
    */
   CloudPrintInterface.CLOUD_ORIGINS_ = [
-      print_preview.Destination.Origin.COOKIES,
-      print_preview.Destination.Origin.DEVICE
+      print_preview.DestinationOrigin.COOKIES,
+      print_preview.DestinationOrigin.DEVICE
       // TODO(vitalybuka): Enable when implemented.
-      // ready print_preview.Destination.Origin.PROFILE
+      // 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_;
     },
 
     /**
      * @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 {print_preview.Destination.Origin=} opt_origin When specified,
+     * @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) {
-          return origin != print_preview.Destination.Origin.COOKIES;
+          return origin != print_preview.DestinationOrigin.COOKIES;
         });
       }
       this.abortSearchRequests_(origins);
       this.search_(true, account, origins);
       this.search_(false, account, origins);
     },
 
     /**
      * Sends Google Cloud Print search API requests.
      * @param {boolean} isRecent Whether to search for only recently used
      *     printers.
      * @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
+     * @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')
       ];
       if (isRecent) {
@@ skipping 17 matching lines @@
      * @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,
+          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) {
@@ skipping 45 matching lines @@
           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 {!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'),
@@ skipping 18 matching lines @@
           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.Destination.Origin} origin Origin for destination.
+     * @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.Destination.Origin)}
+     * @param {function(number, Object, !print_preview.DestinationOrigin)}
      *     callback Callback to invoke when request completes.
      * @return {!CloudPrintRequest} Partially prepared request.
      * @private
      */
     buildRequest_: function(method, action, params, origin, account, callback) {
       var url = this.baseUrl_ + '/' + action + '?xsrf=';
-      if (origin == print_preview.Destination.Origin.COOKIES) {
+      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 {
           url = url + xsrfToken;
         }
         if (account) {
           var index = this.userSessionIndex_[account] || 0;
           if (index > 0) {
@@ skipping 21 matching lines @@
       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.Destination.Origin.COOKIES);
+          (origin == print_preview.DestinationOrigin.COOKIES);
       for (var header in headers) {
         xhr.setRequestHeader(header, headers[header]);
       }
 
       return new 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.
      * @private
      */
     sendOrQueueRequest_: function(request) {
-      if (request.origin == print_preview.Destination.Origin.COOKIES) {
+      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.
@@ skipping 25 matching lines @@
       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.
      * @private
      */
     setUsers_: function(request) {
-      if (request.origin == print_preview.Destination.Origin.COOKIES) {
+      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);
       }
     },
 
     /**
      * Terminates search requests for requested {@code origins}.
-     * @param {!Array<print_preview.Destination.Origin>} origins Origins
+     * @param {!Array<print_preview.DestinationOrigin>} origins Origins
      *     to terminate search requests for.
      * @private
      */
     abortSearchRequests_: function(origins) {
       this.outstandingCloudSearchRequests_ =
           this.outstandingCloudSearchRequests_.filter(function(request) {
             if (origins.indexOf(request.origin) >= 0) {
               request.xhr.abort();
               return false;
             }
             return true;
           });
     },
 
     /**
      * Called when a native layer receives access token.
      * @param {Event} event Contains the authentication type and access token.
      * @private
      */
     onAccessTokenReady_: function(event) {
       // TODO(vitalybuka): remove when other Origins implemented.
-      assert(event.authType == print_preview.Destination.Origin.DEVICE);
+      assert(event.authType == print_preview.DestinationOrigin.DEVICE);
       this.requestQueue_ = this.requestQueue_.filter(function(request) {
-        assert(request.origin == print_preview.Destination.Origin.DEVICE);
+        assert(request.origin == print_preview.DestinationOrigin.DEVICE);
         if (request.origin != event.authType) {
           return true;
         }
         if (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 {!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);
-          if (request.origin == print_preview.Destination.Origin.COOKIES &&
+          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.
      * @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;
           });
       var activeUser = '';
-      if (request.origin == print_preview.Destination.Origin.COOKIES) {
+      if (request.origin == print_preview.DestinationOrigin.COOKIES) {
         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 = [];
@@ skipping 109 matching lines @@
 
     /**
      * 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 &&
+      if (request.origin == print_preview.DestinationOrigin.COOKIES &&
           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.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) {
+        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: ' +
               JSON.stringify(printerJson));
@@ skipping 10 matching lines @@
         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.Destination.Origin} origin Origin for destination.
+   * @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.
    * @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.Destination.Origin}
+     * @type {!print_preview.DestinationOrigin}
      */
     this.origin = origin;
 
     /**
      * User account this request is expected to be executed for.
      * @type {?string}
      */
     this.account = account;
 
     /**
@@ skipping 27 matching lines @@
      * @type {string}
      */
     this.value = value;
   };
 
   // Export
   return {
     CloudPrintInterface: CloudPrintInterface
   };
 });