Remember and restore the account last used destination is registered for.

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 51 matching lines @@
     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;
-
-    /**
-     * Initial origin used to auto-select destination.
-     * @type {print_preview.Destination.Origin}
-     * @private
-     */
-    this.initialDestinationOrigin_ = print_preview.Destination.Origin.LOCAL;
-
-    /**
      * Whether the destination store will auto select the destination that
-     * matches the initial destination.
+     * matches the last used destination stored in appState_.
      * @type {boolean}
      * @private
      */
     this.isInAutoSelectMode_ = false;
 
     /**
      * Event tracker used to track event listeners of the destination store.
      * @type {!EventTracker}
      * @private
      */
     this.tracker_ = new EventTracker();
 
     /**
      * Used to fetch cloud-based print destinations.
      * @type {print_preview.CloudPrintInterface}
      * @private
      */
     this.cloudPrintInterface_ = null;
 
     /**
-     * Whether the destination store has already loaded or is loading all cloud
-     * destinations.
-     * @type {boolean}
+     * Maps user account to the list of origins for which destinations are
+     * already loaded.
+     * @type {!Object.<string, Array.<print_preview.Destination.Origin>>}
      * @private
      */
-    this.hasLoadedAllCloudDestinations_ = false;
+    this.loadedCloudOrigins_ = {};
 
     /**
      * ID of a timeout after the initial destination ID is set. If no inserted
      * destination matches the initial destination ID after the specified
      * timeout, the first destination in the store will be automatically
      * selected.
      * @type {?number}
      * @private
      */
     this.autoSelectTimeout_ = null;
@@ skipping 109 matching lines @@
         color: { option: [{type: 'STANDARD_COLOR', is_default: true}] }
       }
     };
     return dest;
   };
 
   DestinationStore.prototype = {
     __proto__: cr.EventTarget.prototype,
 
     /**
-     * @return {!Array.<!print_preview.Destination>} List of destinations in
-     *     the store.
+     * @param {string=} opt_account Account to filter destinations by. When
+     *     omitted, all destinations are returned.
+     * @return {!Array.<!print_preview.Destination>} List of destinations
+     *     accessible by the {@code account}.
      */
-    get destinations() {
-      return this.destinations_.slice(0);
+    destinations: function(opt_account) {
+      if (opt_account) {
+        return this.destinations_.filter(function(destination) {
+          return !destination.account || destination.account == opt_account;
+        });
+      } else {
+        return this.destinations_.slice(0);
+      }
     },
 
     /**
      * @return {print_preview.Destination} The currently selected destination or
      *     {@code null} if none is selected.
      */
     get selectedDestination() {
       return this.selectedDestination_;
     },
 
@@ skipping 11 matching lines @@
     get isCloudDestinationSearchInProgress() {
       return this.cloudPrintInterface_ &&
              this.cloudPrintInterface_.isCloudDestinationSearchInProgress;
     },
 
     /**
      * 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 &&
-          this.appState_.selectedDestinationOrigin) {
-        this.initialDestinationId_ = this.appState_.selectedDestinationId;
-        this.initialDestinationOrigin_ =
-            this.appState_.selectedDestinationOrigin;
-      } else if (systemDefaultDestinationId) {

[Vitaly Buka (NO REVIEWS), 2014/04/11 02:32:57]

separate change?

[Aleksey Shlyapnikov, 2014/04/11 19:09:29]

Done.

-        this.initialDestinationId_ = systemDefaultDestinationId;
-        this.initialDestinationOrigin_ = print_preview.Destination.Origin.LOCAL;
-      }
+    init: function() {
       this.isInAutoSelectMode_ = true;
-      if (!this.initialDestinationId_ || !this.initialDestinationOrigin_) {
+      if (!this.appState_.selectedDestinationId ||
+          !this.appState_.selectedDestinationOrigin) {
         this.onAutoSelectFailed_();
       } else {
-        var key = this.getDestinationKey_(this.initialDestinationOrigin_,
-                                          this.initialDestinationId_);
+        var key = this.getDestinationKey_(
+            this.appState_.selectedDestinationOrigin,
+            this.appState_.selectedDestinationId,
+            this.appState_.selectedDestinationAccount);
         var candidate = this.destinationMap_[key];
         if (candidate != null) {
           this.selectDestination(candidate);
-        } else if (this.initialDestinationOrigin_ ==
+        } else if (this.appState_.selectedDestinationOrigin ==
                    print_preview.Destination.Origin.LOCAL) {
           this.nativeLayer_.startGetLocalDestinationCapabilities(
-              this.initialDestinationId_);
+              this.appState_.selectedDestinationId);
         } else if (this.cloudPrintInterface_ &&
-                   (this.initialDestinationOrigin_ ==
-                    print_preview.Destination.Origin.COOKIES ||
-                    this.initialDestinationOrigin_ ==
-                    print_preview.Destination.Origin.DEVICE)) {
-          this.cloudPrintInterface_.printer(this.initialDestinationId_,
-                                            this.initialDestinationOrigin_);
-        } else if (this.initialDestinationOrigin_ ==
+                   (this.appState_.selectedDestinationOrigin ==
+                        print_preview.Destination.Origin.COOKIES ||
+                    this.appState_.selectedDestinationOrigin ==
+                        print_preview.Destination.Origin.DEVICE)) {
+          this.cloudPrintInterface_.printer(
+              this.appState_.selectedDestinationId,
+              this.appState_.selectedDestinationOrigin,
+              this.appState_.selectedDestinationAccount);
+        } else if (this.appState_.selectedDestinationOrigin ==
                    print_preview.Destination.Origin.PRIVET) {
           // TODO(noamsml): Resolve a specific printer instead of listing all
           // privet printers in this case.
           this.nativeLayer_.startGetPrivetDestinations();
 
           var destinationName = this.appState_.selectedDestinationName || '';
 
           // Create a fake selectedDestination_ that is not actually in the
           // destination store. When the real destination is created, this
           // destination will be overwritten.
           this.selectedDestination_ = new print_preview.Destination(
-              this.initialDestinationId_,
+              this.appState_.selectedDestinationId,
               print_preview.Destination.Type.LOCAL,
               print_preview.Destination.Origin.PRIVET,
               destinationName,
               false /*isRecent*/,
               print_preview.Destination.ConnectionStatus.ONLINE);
           this.selectedDestination_.capabilities =
               this.appState_.selectedDestinationCapabilities;
 
           cr.dispatchSimpleEvent(
             this,
@@ skipping 12 matching lines @@
      */
     setCloudPrintInterface: function(cloudPrintInterface) {
       this.cloudPrintInterface_ = cloudPrintInterface;
       this.tracker_.add(
           this.cloudPrintInterface_,
           cloudprint.CloudPrintInterface.EventType.SEARCH_DONE,
           this.onCloudPrintSearchDone_.bind(this));
       this.tracker_.add(
           this.cloudPrintInterface_,
           cloudprint.CloudPrintInterface.EventType.SEARCH_FAILED,
-          this.onCloudPrintSearchFailed_.bind(this));
+          this.onCloudPrintSearchDone_.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));
     },
 
     /**
      * @return {boolean} Whether only default cloud destinations have been
      *     loaded.
      */
     hasOnlyDefaultCloudDestinations: function() {
+      // TODO: Move the logic to print_preview.
       return this.destinations_.every(function(dest) {
         return dest.isLocal ||
             dest.id == print_preview.Destination.GooglePromotedId.DOCS ||
             dest.id == print_preview.Destination.GooglePromotedId.FEDEX;
       });
     },
 
     /** @param {!print_preview.Destination} Destination to select. */
     selectDestination: function(destination) {
+      this.isInAutoSelectMode_ = false;
+      this.cancelAutoSelectTimeout_();
+      if (destination == this.selectedDestination_) {
+        return;
+      }
+      if (destination == null) {
+        this.selectedDestination_ = null;
+        cr.dispatchSimpleEvent(
+            this, DestinationStore.EventType.DESTINATION_SELECT);
+        return;
+      }
+      // Update and persist selected destination.
       this.selectedDestination_ = destination;
       this.selectedDestination_.isRecent = true;
-      this.isInAutoSelectMode_ = false;
-      if (this.autoSelectTimeout_ != null) {
-        clearTimeout(this.autoSelectTimeout_);
-        this.autoSelectTimeout_ = null;
-      }
       if (destination.id == print_preview.Destination.GooglePromotedId.FEDEX &&
           !destination.isTosAccepted) {
         assert(this.cloudPrintInterface_ != null,
-               'Selected FedEx Office destination, but Google Cloud Print is ' +
-               'not enabled');
+               'Selected FedEx destination, but GCP API is not available');
         destination.isTosAccepted = true;
-        this.cloudPrintInterface_.updatePrinterTosAcceptance(destination.id,
-                                                             destination.origin,
-                                                             true);
+        this.cloudPrintInterface_.updatePrinterTosAcceptance(destination, true);
       }
       this.appState_.persistSelectedDestination(this.selectedDestination_);
-
+      // Adjust metrics.
       if (destination.cloudID &&
-          this.destinations.some(function(otherDestination) {
+          this.destinations_.some(function(otherDestination) {
             return otherDestination.cloudID == destination.cloudID &&
                 otherDestination != destination;
-            })) {
+          })) {
         if (destination.isPrivet) {
           this.metrics_.incrementDestinationSearchBucket(
               print_preview.Metrics.DestinationSearchBucket.
                   PRIVET_DUPLICATE_SELECTED);
         } else {
           this.metrics_.incrementDestinationSearchBucket(
               print_preview.Metrics.DestinationSearchBucket.
                   CLOUD_DUPLICATE_SELECTED);
         }
       }
-
+      // Notify about selected destination change.
       cr.dispatchSimpleEvent(
           this, DestinationStore.EventType.DESTINATION_SELECT);
+      // Request destination capabilities, of not known yet.
       if (destination.capabilities == null) {
         if (destination.isPrivet) {
           this.nativeLayer_.startGetPrivetDestinationCapabilities(
               destination.id);
         }
         else 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,
-                                            destination.origin);
+                 'Cloud destination selected, but GCP is not enabled');
+          this.cloudPrintInterface_.printer(
+              destination.id, destination.origin, destination.account);
         }
       } 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.
+     * Selects 'Save to PDF' destination (since it always exists).
+     * @private
      */
-    insertDestination: function(destination) {
-      if (this.insertDestination_(destination)) {
-        cr.dispatchSimpleEvent(
-            this, DestinationStore.EventType.DESTINATIONS_INSERTED);
-        if (this.isInAutoSelectMode_ &&
-            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.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 and display name
-     * 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 or {@code null} if it was the new destination.
-     */
-    updateDestination: function(destination) {
-      assert(destination.constructor !== Array, 'Single printer expected');
-      var key = this.getDestinationKey_(destination.origin, destination.id);
-      var existingDestination = this.destinationMap_[key];
-      if (existingDestination != null) {
-        existingDestination.capabilities = destination.capabilities;
-      } else {
-        this.insertDestination(destination);
-      }
-
-      if (existingDestination == this.selectedDestination_ ||
-          destination == this.selectedDestination_) {
-        this.appState_.persistSelectedDestination(this.selectedDestination_);
-        cr.dispatchSimpleEvent(
-            this,
-            DestinationStore.EventType.SELECTED_DESTINATION_CAPABILITIES_READY);
-      }
-
-      return existingDestination;
+    selectDefaultDestination_: function() {
+      var destination = this.destinationMap_[this.getDestinationKey_(
+          print_preview.Destination.Origin.LOCAL,
+          print_preview.Destination.GooglePromotedId.SAVE_AS_PDF,
+          '')] || null;
+      assert(destination != null, 'Save to PDF printer not found');
+      this.selectDestination(destination);
     },
 
     /** Initiates loading of local print destinations. */
     startLoadLocalDestinations: function() {
       if (!this.hasLoadedAllLocalDestinations_) {
         this.hasLoadedAllLocalDestinations_ = true;
         this.nativeLayer_.startGetLocalDestinations();
         this.isLocalDestinationSearchInProgress_ = true;
         cr.dispatchSimpleEvent(
             this, DestinationStore.EventType.DESTINATION_SEARCH_STARTED);
@@ skipping 12 matching lines @@
             DestinationStore.PRIVET_SEARCH_DURATION_);
       }
     },
 
     /**
      * Initiates loading of cloud destinations.
      * @param {print_preview.Destination.Origin=} opt_origin Search destinations
      *     for the specified origin only.
      */
     startLoadCloudDestinations: function(opt_origin) {
-      if (this.cloudPrintInterface_ != null &&
-          !this.hasLoadedAllCloudDestinations_) {
-        this.hasLoadedAllCloudDestinations_ = true;
-        this.cloudPrintInterface_.search(opt_origin);
-        cr.dispatchSimpleEvent(
-            this, DestinationStore.EventType.DESTINATION_SEARCH_STARTED);
+      if (this.cloudPrintInterface_ != null) {
+        var origins = this.loadedCloudOrigins_[this.userInfo_.activeUser] || [];
+        if (origins.length == 0 ||
+            (opt_origin && origins.indexOf(opt_origin) < 0)) {
+          this.cloudPrintInterface_.search(opt_origin);
+          cr.dispatchSimpleEvent(
+              this, DestinationStore.EventType.DESTINATION_SEARCH_STARTED);
+        }
       }
     },
 
+    /** Requests load of COOKIE based cloud destinations. */
+    reloadUserCookieBasedDestinations: function() {
+      var origins = this.loadedCloudOrigins_[this.userInfo_.activeUser] || [];
+      if (origins.indexOf(print_preview.Destination.Origin.COOKIES) >= 0) {
+        cr.dispatchSimpleEvent(
+            this, DestinationStore.EventType.DESTINATION_SEARCH_DONE);
+      } else {
+        this.startLoadCloudDestinations(
+            print_preview.Destination.Origin.COOKIES);
+      }
+    },
+
     /**
      * Wait for a privet device to be registered.
      */
     waitForRegister: function(id) {
       this.nativeLayer_.startGetPrivetDestinations();
       this.waitForRegisterDestination_ = id;
     },
 
     /**
+     * Inserts {@code destination} to the data store and dispatches a
+     * DESTINATIONS_INSERTED event.
+     * @param {!print_preview.Destination} destination Print destination to
+     *     insert.
+     * @private
+     */
+    insertDestination_: function(destination) {
+      if (this.insertIntoStore_(destination)) {
+        this.destinationsInserted_(destination);
+      }
+    },
+
+    /**
+     * Inserts multiple {@code destinations} to the data store and dispatches
+     * single DESTINATIONS_INSERTED event.
+     * @param {!Array.<print_preview.Destination>} destinations Print
+     *     destinations to insert.
+     * @private
+     */
+    insertDestinations_: function(destinations) {
+      var inserted = false;
+      destinations.forEach(function(destination) {
+        inserted = this.insertIntoStore_(destination) || inserted;
+      }, this);
+      if (inserted) {
+        this.destinationsInserted_();
+      }
+    },
+
+    /**
+     * Dispatches DESTINATIONS_INSERTED event. In auto select mode, tries to
+     * update selected destination to match {@code appState_} settings.
+     * @param {print_preview.Destination=} opt_destination The only destination
+     *     that was changed or skipped if possibly more than one destination was
+     *     changed. Used as a hint to limit destination search scope in
+     *     {@code isInAutoSelectMode_).
+     */
+    destinationsInserted_: function(opt_destination) {
+      cr.dispatchSimpleEvent(
+          this, DestinationStore.EventType.DESTINATIONS_INSERTED);
+      if (this.isInAutoSelectMode_) {
+        var destinationsToSearch =
+            opt_destination && [opt_destination] || this.destinations_;
+        destinationsToSearch.some(function(destination) {
+          if (this.matchPersistedDestination_(destination)) {
+            this.selectDestination(destination);
+            return true;
+          }
+        }, this);
+      }
+    },
+
+    /**
+     * Updates an existing print destination with capabilities and display name
+     * 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 or {@code null} if it was the new destination.
+     * @private
+     */
+    updateDestination_: function(destination) {
+      assert(destination.constructor !== Array, 'Single printer expected');
+      var existingDestination = this.destinationMap_[this.getKey_(destination)];
+      if (existingDestination != null) {
+        existingDestination.capabilities = destination.capabilities;
+      } else {
+        this.insertDestination_(destination);
+      }
+
+      if (existingDestination == this.selectedDestination_ ||
+          destination == this.selectedDestination_) {
+        this.appState_.persistSelectedDestination(this.selectedDestination_);
+        cr.dispatchSimpleEvent(
+            this,
+            DestinationStore.EventType.SELECTED_DESTINATION_CAPABILITIES_READY);
+      }
+
+      return existingDestination;
+    },
+
+    /**
      * Called when the search for Privet printers is done.
      * @private
      */
     endPrivetPrinterSearch_: function() {
       this.nativeLayer_.stopGetPrivetDestinations();
       this.isPrivetDestinationSearchInProgress_ = false;
       this.hasLoadedAllPrivetDestinations_ = true;
       cr.dispatchSimpleEvent(
           this, DestinationStore.EventType.DESTINATION_SEARCH_DONE);
     },
 
     /**
      * 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 key = this.getDestinationKey_(destination.origin, destination.id);
+    insertIntoStore_: function(destination) {
+      var key = this.getKey_(destination);
       var existingDestination = this.destinationMap_[key];
       if (existingDestination == null) {
         this.destinations_.push(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;
@@ skipping 25 matching lines @@
           print_preview.NativeLayer.EventType.DESTINATIONS_RELOAD,
           this.onDestinationsReload_.bind(this));
       this.tracker_.add(
           this.nativeLayer_,
           print_preview.NativeLayer.EventType.PRIVET_PRINTER_CHANGED,
           this.onPrivetPrinterAdded_.bind(this));
       this.tracker_.add(
           this.nativeLayer_,
           print_preview.NativeLayer.EventType.PRIVET_CAPABILITIES_SET,
           this.onPrivetCapabilitiesSet_.bind(this));
-      this.tracker_.add(
-          this.userInfo_,
-          print_preview.UserInfo.EventType.ACTIVE_USER_CHANGED,
-          this.onActiveUserChanged_.bind(this));
     },
 
     /**
      * Resets the state of the destination store to its initial state.
      * @private
      */
     reset_: function() {
       this.destinations_ = [];
       this.destinationMap_ = {};
-      this.selectedDestination_ = null;
-      this.hasLoadedAllCloudDestinations_ = false;
+      this.selectDestination(null);
+      this.loadedCloudOrigins_ = {};
       this.hasLoadedAllLocalDestinations_ = false;
-      this.insertDestination(
+      this.insertDestination_(
           DestinationStore.createLocalPdfPrintDestination_());
       this.resetAutoSelectTimeout_();
     },
 
     /**
-     * Resets the state of the destination store to its initial state.
-     * @private
-     */
-    resetCookiesDestinations_: function() {
-      // Forget all cookies based destinations.
-      this.destinations_ = this.destinations_.filter(function(destination) {
-        if (destination.origin == print_preview.Destination.Origin.COOKIES) {
-          delete this.destinationMap_[
-              this.getDestinationKey_(destination.origin, destination.id)];
-          return false;
-        }
-        return true;
-      }, this);
-      // Reset selected destination, if necessary.
-      if (this.selectedDestination_ &&
-          this.selectedDestination_.origin ==
-              print_preview.Destination.Origin.COOKIES) {
-        this.selectedDestination_ = null;
-      }
-      this.hasLoadedAllCloudDestinations_ = false;
-      this.resetAutoSelectTimeout_();
-    },
-
-    /**
      * Resets destination auto selection timeout.
      * @private
      */
     resetAutoSelectTimeout_: function() {
+      this.cancelAutoSelectTimeout_();
       this.autoSelectTimeout_ =
           setTimeout(this.onAutoSelectFailed_.bind(this),
                      DestinationStore.AUTO_SELECT_TIMEOUT_);
     },
 
     /**
-     * Called when active user changes. Resets cookie based destinations
-     * and starts loading cloud destinations for the active user.
+     * Cancels destination auto selection timeout.
      * @private
      */
-    onActiveUserChanged_: function() {
-      this.resetCookiesDestinations_();
-      this.isInAutoSelectMode_ = true;
-      this.startLoadCloudDestinations(print_preview.Destination.Origin.COOKIES);
+    cancelAutoSelectTimeout_: function() {
+      if (this.autoSelectTimeout_ != null) {
+        clearTimeout(this.autoSelectTimeout_);
+        this.autoSelectTimeout_ = null;
+      }
     },
 
     /**
      * Called when the local destinations have been got from the native layer.
      * @param {Event} Contains the local destinations.
      * @private
      */
     onLocalDestinationsSet_: function(event) {
       var localDestinations = event.destinationInfos.map(function(destInfo) {
         return print_preview.LocalDestinationParser.parse(destInfo);
       });
-      this.insertDestinations(localDestinations);
+      this.insertDestinations_(localDestinations);
       this.isLocalDestinationSearchInProgress_ = false;
       cr.dispatchSimpleEvent(
           this, DestinationStore.EventType.DESTINATION_SEARCH_DONE);
     },
 
     /**
      * 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 {Event} event Contains the capabilities of the local print
      *     destination.
      * @private
      */
     onLocalDestinationCapabilitiesSet_: function(event) {
       var destinationId = event.settingsInfo['printerId'];
-      var key =
-          this.getDestinationKey_(print_preview.Destination.Origin.LOCAL,
-                                  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 {
         // TODO(rltoscano): This makes the assumption that the "deviceName" is
         // the same as "printerName". We should include the "printerName" in the
         // response. See http://crbug.com/132831.
         destination = print_preview.LocalDestinationParser.parse(
             {deviceName: destinationId, printerName: destinationId});
         destination.capabilities = capabilities;
-        this.insertDestination(destination);
+        this.insertDestination_(destination);
       }
       if (this.selectedDestination_ &&
           this.selectedDestination_.id == destinationId) {
         cr.dispatchSimpleEvent(this,
                                DestinationStore.EventType.
                                    SELECTED_DESTINATION_CAPABILITIES_READY);
       }
     },
 
     /**
      * 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 {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.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]);
+          this.sameAsPersistedDestination_(event.destinationId,
+                                           event.destinationOrigin)) {
+        this.selectDefaultDestination_();
       }
     },
 
     /**
-     * Called when the /search call completes. Adds the fetched destinations to
-     * the destination store.
-     * @param {Event} event Contains the fetched destinations.
+     * Called when the /search call completes, either successfully or not.
+     * In case of success, stores fetched destinations.
+     * @param {Event} event Contains the request result.
      * @private
      */
     onCloudPrintSearchDone_: function(event) {
-      this.insertDestinations(event.printers);
+      if (event.printers) {
+        this.insertDestinations_(event.printers);
+      }
+      if (event.searchDone) {
+        var origins = this.loadedCloudOrigins_[event.user] || [];
+        if (origins.indexOf(event.origin) < 0) {
+          this.loadedCloudOrigins_[event.user] = origins.concat([event.origin]);
+        }
+      }
       cr.dispatchSimpleEvent(
           this, DestinationStore.EventType.DESTINATION_SEARCH_DONE);
     },
-
-    /**
-     * Called when the /search call fails. Updates outstanding request count and
-     * dispatches CLOUD_DESTINATIONS_LOADED event.
-     * @private
-     */
-    onCloudPrintSearchFailed_: function() {
-      cr.dispatchSimpleEvent(
-          this, DestinationStore.EventType.DESTINATION_SEARCH_DONE);
-    },
 
     /**
      * Called when /printer call completes. Updates the specified destination's
      * print capabilities.
      * @param {Event} event Contains detailed information about the
      *     destination.
      * @private
      */
     onCloudPrintPrinterDone_: function(event) {
-      this.updateDestination(event.printer);
+      this.updateDestination_(event.printer);
     },
 
     /**
      * 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.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]);
+          this.sameAsPersistedDestination_(event.destinationId,
+                                           event.destinationOrigin)) {
+        console.error(
+            'Failed to fetch last used printer caps: ' + event.destinationId);
+        this.selectDefaultDestination_();
       }
     },
 
     /**
      * Called when a Privet printer is added to the local network.
      * @param {object} event Contains information about the added printer.
      * @private
      */
     onPrivetPrinterAdded_: function(event) {
       if (event.printer.serviceName == this.waitForRegisterDestination_ &&
           !event.printer.isUnregistered) {
         this.waitForRegisterDestination_ = null;
         this.onDestinationsReload_();
       } else {
-        this.insertDestinations(
+        this.insertDestinations_(
             print_preview.PrivetDestinationParser.parse(event.printer));
       }
     },
 
     /**
      * Called when capabilities for a privet printer are set.
      * @param {object} event Contains the capabilities and printer ID.
      * @private
      */
     onPrivetCapabilitiesSet_: function(event) {
       var destinationId = event.printerId;
       var destinations =
           print_preview.PrivetDestinationParser.parse(event.printer);
       destinations.forEach(function(dest) {
         dest.capabilities = event.capabilities;
-        this.updateDestination(dest);
+        this.updateDestination_(dest);
       }, this);
     },
 
     /**
      * Called from native layer after the user was requested to sign in, and did
      * so successfully.
      * @private
      */
     onDestinationsReload_: function() {
       this.reset_();
       this.isInAutoSelectMode_ = true;
       this.startLoadLocalDestinations();
       this.startLoadCloudDestinations();
       this.startLoadPrivetDestinations();
     },
 
     /**
      * Called when auto-selection fails. Selects the first destination in store.
      * @private
      */
     onAutoSelectFailed_: function() {
-      this.autoSelectTimeout_ = null;
-      assert(this.destinations_.length > 0,
-             'No destinations were loaded before auto-select timeout expired');
-      this.selectDestination(this.destinations_[0]);
+      this.cancelAutoSelectTimeout_();
+      this.selectDefaultDestination_();
     },
 
     // 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.
+     * @return {string} id Destination id.
+     * @return {string} account User account destination is registered for.
      * @private
      */
-    getDestinationKey_: function(origin, id) {
-      return origin + '/' + id;
+    getDestinationKey_: function(origin, id, account) {
+      return origin + '/' + id + '/' + account;
     },
 
     /**
-     * @param {?string} id Id of the destination.
-     * @param {?string} origin Oring of the destination.
-     * @return {boolean} Whether a initial destination matches provided.
+     * Returns key to be used with {@code destinationMap_}.
+     * @param {!print_preview.Destination} destination Destination.
      * @private
      */
-    matchInitialDestination_: function(id, origin) {
-      return this.initialDestinationId_ == null ||
-             this.initialDestinationOrigin_ == null ||
-             this.matchInitialDestinationStrict_(id, origin);
+    getKey_: function(destination) {
+      return this.getDestinationKey_(
+          destination.origin, destination.id, destination.account);
     },
 
     /**
+     * @param {!print_preview.Destination} destination Destination to match.
+     * @return {boolean} Whether {@code destination} matches the last user
+     *     selected one.
+     * @private
+     */
+    matchPersistedDestination_: function(destination) {
+      return !this.appState_.selectedDestinationId ||
+             !this.appState_.selectedDestinationOrigin ||
+             this.sameAsPersistedDestination_(
+                 destination.id, destination.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_;
+    sameAsPersistedDestination_: function(id, origin) {
+      return id == this.appState_.selectedDestinationId &&
+             origin == this.appState_.selectedDestinationOrigin;
     }
   };
 
   // Export
   return {
     DestinationStore: DestinationStore
   };
 });