Rename AuthType to Origin of destination.

chrome/browser/resources/print_preview/data/destination_store.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('print_preview', function() {
   'use strict';
 
   /**
    * A data store that stores destinations and dispatches events when the data
    * store changes.
@@ skipping 21 matching lines @@
     this.appState_ = appState;
 
     /**
      * Internal backing store for the data store.
      * @type {!Array.<!print_preview.Destination>}
      * @private
      */
     this.destinations_ = [];
 
     /**
-     * Cache used for constant lookup of destinations by ID.
+     * Cache used for constant lookup of destinations by origin and id.
      * @type {object.<string, !print_preview.Destination>}
      * @private
      */
     this.destinationMap_ = {};
 
     /**
      * Currently selected destination.
      * @type {print_preview.Destination}
      * @private
      */
     this.selectedDestination_ = null;
 
     /**
      * Initial destination ID used to auto-select the first inserted destination
      * that matches. If {@code null}, the first destination inserted into the
      * store will be selected.
      * @type {?string}
      * @private
      */
     this.initialDestinationId_ = null;
 
     /**
-     * Whether the initial destination is a local one or not.
-     * @type {boolean}
+     * Initial origin used to auto-select destination.
+     * @type {print_preview.Destination.Origin}
      * @private
      */
-    this.isInitialDestinationLocal_ = true;
+    this.initialDestinationOrigin_ = print_preview.Destination.Origin.LOCAL;
 
     /**
      * Whether the destination store will auto select the destination that
      * matches the initial destination.
      * @type {boolean}
      * @private
      */
     this.isInAutoSelectMode_ = false;
 
     /**
@@ skipping 67 matching lines @@
 
   /**
    * Creates a local PDF print destination.
    * @return {!print_preview.Destination} Created print destination.
    * @private
    */
   DestinationStore.createLocalPdfPrintDestination_ = function() {
     var dest = new print_preview.Destination(
         print_preview.Destination.GooglePromotedId.SAVE_AS_PDF,
         print_preview.Destination.Type.LOCAL,
-        print_preview.Destination.AuthType.LOCAL,
+        print_preview.Destination.Origin.LOCAL,
         localStrings.getString('printToPDF'),
         false /*isRecent*/,
         print_preview.Destination.ConnectionStatus.ONLINE);
     dest.capabilities = {
       version: '1.0',
       printer: {
         page_orientation: {
           option: [
             {type: 'AUTO', is_default: true},
             {type: 'PORTRAIT'},
@@ skipping 43 matching lines @@
     /**
      * Initializes the destination store. Sets the initially selected
      * destination. If any inserted destinations match this ID, that destination
      * will be automatically selected. This method must be called after the
      * print_preview.AppState has been initialized.
      * @param {?string} systemDefaultDestinationId ID of the system default
      *     destination.
      * @private
      */
     init: function(systemDefaultDestinationId) {
-      if (this.appState_.selectedDestinationId) {
+      if (this.appState_.selectedDestinationId &&
+          this.appState_.selectedDestinationOrigin) {
         this.initialDestinationId_ = this.appState_.selectedDestinationId;
-        this.isInitialDestinationLocal_ =
-            this.appState_.isSelectedDestinationLocal;
+        this.initialDestinationOrigin_ =
+            this.appState_.selectedDestinationOrigin_;
       } else {
         this.initialDestinationId_ = systemDefaultDestinationId;
-        this.isInitialDestinationLocal_ = true;
+        this.initialDestinationOrigin_ =
+            print_preview.Destination.Origin.LOCAL;
       }
-
       this.isInAutoSelectMode_ = true;
-      if (this.initialDestinationId_ == null) {
+      if (this.initialDestinationId_ == null ||
+          this.initialDestinationOrigin_ == null) {
         assert(this.destinations_.length > 0,
                'No destinations available to select');
         this.selectDestination(this.destinations_[0]);
       } else {
-        var candidate = this.destinationMap_[this.initialDestinationId_];
+        var key = this.getDestinationKey_(this.initialDestinationOrigin_,
+                                          this.initialDestinationId_);
+        var candidate = this.destinationMap_[key];
         if (candidate != null) {
           this.selectDestination(candidate);
-        } else if (!cr.isChromeOS && this.isInitialDestinationLocal_) {
+        } else if (!cr.isChromeOS &&
+                   this.initialDestinationOrigin_ ==
+                   print_preview.Destination.Origin.LOCAL) {
           this.nativeLayer_.startGetLocalDestinationCapabilities(
               this.initialDestinationId_);
         }
       }
     },
 
     /**
      * Sets the destination store's Google Cloud Print interface.
      * @param {!print_preview.CloudPrintInterface} cloudPrintInterface Interface
      *     to set.
@@ skipping 10 matching lines @@
           this.onCloudPrintSearchFailed_.bind(this));
       this.tracker_.add(
           this.cloudPrintInterface_,
           cloudprint.CloudPrintInterface.EventType.PRINTER_DONE,
           this.onCloudPrintPrinterDone_.bind(this));
       this.tracker_.add(
           this.cloudPrintInterface_,
           cloudprint.CloudPrintInterface.EventType.PRINTER_FAILED,
           this.onCloudPrintPrinterFailed_.bind(this));
       // Fetch initial destination if its a cloud destination.
-      if (this.isInAutoSelectMode_ && !this.isInitialDestinationLocal_) {
-        this.cloudPrintInterface_.printer(this.initialDestinationId_);
+      var origin = this.initialDestinationOrigin_;
+      if (this.isInAutoSelectMode_ &&
+          origin != print_preview.Destination.Origin.LOCAL) {
+        this.cloudPrintInterface_.printer(this.initialDestinationId_, origin);
       }
     },
 
     /**
      * @return {boolean} Whether only default cloud destinations have been
      *     loaded.
      */
     hasOnlyDefaultCloudDestinations: function() {
       return this.destinations_.every(function(dest) {
         return dest.isLocal ||
@@ skipping 24 matching lines @@
       cr.dispatchSimpleEvent(
           this, DestinationStore.EventType.DESTINATION_SELECT);
       if (destination.capabilities == null) {
          if (destination.isLocal) {
           this.nativeLayer_.startGetLocalDestinationCapabilities(
               destination.id);
         } else {
           assert(this.cloudPrintInterface_ != null,
                  'Selected destination is a cloud destination, but Google ' +
                  'Cloud Print is not enabled');
-          this.cloudPrintInterface_.printer(destination.id);
+          this.cloudPrintInterface_.printer(destination.id,
+                                            destination.origin);
         }
       } else {
         cr.dispatchSimpleEvent(
             this,
             DestinationStore.EventType.SELECTED_DESTINATION_CAPABILITIES_READY);
       }
     },
 
     /**
      * Inserts a print destination to the data store and dispatches a
      * DESTINATIONS_INSERTED event. If the destination matches the initial
      * destination ID, then the destination will be automatically selected.
      * @param {!print_preview.Destination} destination Print destination to
      *     insert.
      */
     insertDestination: function(destination) {
       if (this.insertDestination_(destination)) {
         cr.dispatchSimpleEvent(
             this, DestinationStore.EventType.DESTINATIONS_INSERTED);
         if (this.isInAutoSelectMode_ &&
-            (this.initialDestinationId_ == null ||
-                destination.id == this.initialDestinationId_)) {
+            this.matchInitialDestination_(destination.id, destination.origin)) {
           this.selectDestination(destination);
         }
       }
     },
 
     /**
      * Inserts multiple print destinations to the data store and dispatches one
      * DESTINATIONS_INSERTED event. If any of the destinations match the initial
      * destination ID, then that destination will be automatically selected.
      * @param {!Array.<print_preview.Destination>} destinations Print
      *     destinations to insert.
      */
     insertDestinations: function(destinations) {
       var insertedDestination = false;
       var destinationToAutoSelect = null;
       destinations.forEach(function(dest) {
         if (this.insertDestination_(dest)) {
           insertedDestination = true;
           if (this.isInAutoSelectMode_ &&
               destinationToAutoSelect == null &&
-              (this.initialDestinationId_ == null ||
-                  dest.id == this.initialDestinationId_)) {
+              this.matchInitialDestination_(dest.id, dest.origin)) {
             destinationToAutoSelect = dest;
           }
         }
       }, this);
       if (insertedDestination) {
         cr.dispatchSimpleEvent(
             this, DestinationStore.EventType.DESTINATIONS_INSERTED);
       }
       if (destinationToAutoSelect != null) {
         this.selectDestination(destinationToAutoSelect);
       }
     },
 
     /**
      * Updates an existing print destination with capabilities information. If
      * the destination doesn't already exist, it will be added.
      * @param {!print_preview.Destination} destination Destination to update.
      * @return {!print_preview.Destination} The existing destination that was
-     *     updated.
+     *     updated or {@code null} if it was the new destination.
      */
     updateDestination: function(destination) {
-      var existingDestination = this.destinationMap_[destination.id];
+      var key = this.getDestinationKey_(destination.origin, destination.id);
+      var existingDestination = this.destinationMap_[key];
       if (existingDestination != null) {
         existingDestination.capabilities = destination.capabilities;
         return existingDestination;
       } else {
         this.insertDestination(destination);
+        return null;
       }
     },
 
     /** Initiates loading of local print destinations. */
     startLoadLocalDestinations: function() {
       this.nativeLayer_.startGetLocalDestinations();
       this.isLocalDestinationSearchInProgress_ = true;
       cr.dispatchSimpleEvent(
           this, DestinationStore.EventType.DESTINATION_SEARCH_STARTED);
     },
@@ skipping 13 matching lines @@
       }
     },
 
     /**
      * Inserts a destination into the store without dispatching any events.
      * @return {boolean} Whether the inserted destination was not already in the
      *     store.
      * @private
      */
     insertDestination_: function(destination) {
-      var existingDestination = this.destinationMap_[destination.id];
+      var key = this.getDestinationKey_(destination.origin, destination.id);
+      var existingDestination = this.destinationMap_[key];
       if (existingDestination == null) {
         this.destinations_.push(destination);
-        this.destinationMap_[destination.id] = destination;
+        this.destinationMap_[key] = destination;
         return true;
       } else if (existingDestination.connectionStatus ==
                      print_preview.Destination.ConnectionStatus.UNKNOWN &&
                  destination.connectionStatus !=
                      print_preview.Destination.ConnectionStatus.UNKNOWN) {
         existingDestination.connectionStatus = destination.connectionStatus;
         return true;
       } else {
         return false;
       }
@@ skipping 57 matching lines @@
      * Called when the native layer retrieves the capabilities for the selected
      * local destination. Updates the destination with new capabilities if the
      * destination already exists, otherwise it creates a new destination and
      * then updates its capabilities.
      * @param {cr.Event} event Contains the capabilities of the local print
      *     destination.
      * @private
      */
     onLocalDestinationCapabilitiesSet_: function(event) {
       var destinationId = event.settingsInfo['printerId'];
-      var destination = this.destinationMap_[destinationId];
+      var key =
+          this.getDestinationKey_(print_preview.Destination.Origin.LOCAL,
+                                  destinationId);
+      var destination = this.destinationMap_[key];
       var capabilities = print_preview.LocalCapabilitiesParser.parse(
             event.settingsInfo);
       if (destination) {
         // In case there were multiple capabilities request for this local
         // destination, just ignore the later ones.
         if (destination.capabilities != null) {
           return;
         }
         destination.capabilities = capabilities;
       } else {
@@ skipping 17 matching lines @@
      * Called when a request to get a local destination's print capabilities
      * fails. If the destination is the initial destination, auto-select another
      * destination instead.
      * @param {cr.Event} event Contains the destination ID that failed.
      * @private
      */
     onGetCapabilitiesFail_: function(event) {
       console.error('Failed to get print capabilities for printer ' +
                     event.destinationId);
       if (this.isInAutoSelectMode_ &&
-          this.initialDestinationId_ == event.destinationId) {
+          this.matchInitialDestinationStrict_(event.destinationId,
+                                              event.destinationOrigin)) {
         assert(this.destinations_.length > 0,
                'No destinations were loaded when failed to get initial ' +
                'destination');
         this.selectDestination(this.destinations_[0]);
       }
     },
 
     /**
      * Called when the /search call completes. Adds the fetched destinations to
      * the destination store.
@@ skipping 35 matching lines @@
     /**
      * Called when the Google Cloud Print interface fails to lookup a
      * destination. Selects another destination if the failed destination was
      * the initial destination.
      * @param {object} event Contains the ID of the destination that was failed
      *     to be looked up.
      * @private
      */
     onCloudPrintPrinterFailed_: function(event) {
       if (this.isInAutoSelectMode_ &&
-          this.initialDestinationId_ == event.destinationId) {
+          this.matchInitialDestinationStrict_(event.destinationId,
+                                              event.destinationOrigin)) {
         console.error('Could not find initial printer: ' + event.destinationId);
         assert(this.destinations_.length > 0,
                'No destinations were loaded when failed to get initial ' +
                'destination');
         this.selectDestination(this.destinations_[0]);
       }
     },
 
     /**
      * Called from native layer after the user was requested to sign in, and did
@@ skipping 11 matching lines @@
     /**
      * Called when no destination was auto-selected after some timeout. Selects
      * the first destination in store.
      * @private
      */
     onAutoSelectTimeoutExpired_: function() {
       this.autoSelectTimeout_ = null;
       assert(this.destinations_.length > 0,
              'No destinations were loaded before auto-select timeout expired');
       this.selectDestination(this.destinations_[0]);
+    },
+
+    // TODO(vitalybuka): Remove three next functions replacing Destination.id
+    //    and Destination.origin by complex ID.
+    /**
+     * Returns key to be used with {@code destinationMap_}.
+     * @param {!print_preview.Destination.Origin} origin Destination origin.
+     * @return {!string} id Destination id.
+     * @private
+     */
+    getDestinationKey_: function(origin, id) {
+      return origin + '/' + id;
+    },
+
+    /**
+     * @param {?string} id Id of the destination.
+     * @param {?string} origin Oring of the destination.
+     * @return {boolean} Whether a initial destination matches provided.
+     * @private
+     */
+    matchInitialDestination_: function(id, origin) {
+      return this.initialDestinationId_ == null ||
+             this.initialDestinationOrigin_ == null ||
+             this.matchInitialDestinationStrict_(id, origin);
+    },
+
+    /**
+     * @param {?string} id Id of the destination.
+     * @param {?string} origin Oring of the destination.
+     * @return {boolean} Whether destination is the same as initial.
+     * @private
+     */
+    matchInitialDestinationStrict_: function(id, origin) {
+      return id == this.initialDestinationId_ &&
+             origin == this.initialDestinationOrigin_;
     }
   };
 
   // Export
   return {
     DestinationStore: DestinationStore
   };
 });