Introduce concept of provisional destinations to print preview

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 181 matching lines @@
    * @enum {string}
    */
   DestinationStore.EventType = {
     DESTINATION_SEARCH_DONE:
         'print_preview.DestinationStore.DESTINATION_SEARCH_DONE',
     DESTINATION_SEARCH_STARTED:
         'print_preview.DestinationStore.DESTINATION_SEARCH_STARTED',
     DESTINATION_SELECT: 'print_preview.DestinationStore.DESTINATION_SELECT',
     DESTINATIONS_INSERTED:
         'print_preview.DestinationStore.DESTINATIONS_INSERTED',
+    PROVISIONAL_DESTINATION_RESOLVED:
+        'print_preview.DestinationStore.PROVISIONAL_DESTINATION_RESOLVED',
     CACHED_SELECTED_DESTINATION_INFO_READY:
         'print_preview.DestinationStore.CACHED_SELECTED_DESTINATION_INFO_READY',
     SELECTED_DESTINATION_CAPABILITIES_READY:
         'print_preview.DestinationStore.SELECTED_DESTINATION_CAPABILITIES_READY'
   };
 
   /**
    * Delay in milliseconds before the destination store ignores the initial
    * destination ID and just selects any printer (since the initial destination
    * was not found).
@@ skipping 242 matching lines @@
         this.autoSelectTimeout_ = null;
       } else if (destination == this.selectedDestination_) {
         return;
       }
       if (destination == null) {
         this.selectedDestination_ = null;
         cr.dispatchSimpleEvent(
             this, DestinationStore.EventType.DESTINATION_SELECT);
         return;
       }
+
+      assert(!destination.isProvisional, 'Selecting provisonal destination');
+
       // Update and persist selected destination.
       this.selectedDestination_ = destination;
       this.selectedDestination_.isRecent = true;
       if (destination.id == print_preview.Destination.GooglePromotedId.FEDEX &&
           !destination.isTosAccepted) {
         assert(this.cloudPrintInterface_ != null,
                'Selected FedEx destination, but GCP API is not available');
         destination.isTosAccepted = true;
         this.cloudPrintInterface_.updatePrinterTosAcceptance(destination, true);
       }
@@ skipping 30 matching lines @@
           this.cloudPrintInterface_.printer(
               destination.id, destination.origin, destination.account);
         }
       } else {
         cr.dispatchSimpleEvent(
             this,
             DestinationStore.EventType.SELECTED_DESTINATION_CAPABILITIES_READY);
       }
     },
 
+    resolveProvisionalDestination: function(destination) {
+      assert(
+          destination.provisionalType ==
+              print_preview.Destination.ProvisionalType.NEEDS_USB_PERMISSION,
+          'Provisional type cannot be resolved.');
+      assert(destination.usbId != null,
+             'Resolving provisional destination without USB ID.');
+      this.nativeLayer_.grantUsbExtensionPermission(
+          destination.id, destination.extensionId, destination.usbId);
+    },
+
     /**
      * Selects 'Save to PDF' destination (since it always exists).
      * @private
      */
     selectDefaultDestination_: function() {
       var saveToPdfKey = this.getDestinationKey_(
           print_preview.Destination.Origin.LOCAL,
           print_preview.Destination.GooglePromotedId.SAVE_AS_PDF,
           '');
       this.selectDestination(
@@ skipping 82 matching lines @@
     },
 
     /**
      * Wait for a privet device to be registered.
      */
     waitForRegister: function(id) {
       this.nativeLayer_.startGetPrivetDestinations();
       this.waitForRegisterDestination_ = id;
     },
 
+    resolveProvisionalDestination_: function(evt) {
+      var provisionalDestinationIndex = -1;
+      var provisionalDestination = null;
+      for (var i = 0; i < this.destinations_.length; ++i) {
+        if (evt.provisionalId == this.destinations_[i].id) {
+          provisionalDestinationIndex = i;
+          provisionalDestination = this.destinations_[i];
+          break;
+        }
+      }
+
+      if (!provisionalDestination)
+        return;
+
+      this.destinations_.splice(provisionalDestinationIndex, 1);
+      this.destinationMap_[this.getKey_(provisionalDestination)] = undefined;
+
+      var destination = evt.destination ?
+          print_preview.ExtensionDestinationParser.parse(evt.destination) :
+          null;
+      if (destination)
+        this.insertIntoStore_(destination);
+
+      var event = new Event(
+          DestinationStore.EventType.PROVISIONAL_DESTINATION_RESOLVED);
+      event.provisionalId = evt.provisionalId;
+      event.destination = destination;
+      this.dispatchEvent(event);
+    },
+
     /**
      * 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);
@@ skipping 149 matching lines @@
           print_preview.NativeLayer.EventType.PRIVET_CAPABILITIES_SET,
           this.onPrivetCapabilitiesSet_.bind(this));
       this.tracker_.add(
           this.nativeLayer_,
           print_preview.NativeLayer.EventType.EXTENSION_PRINTERS_ADDED,
           this.onExtensionPrintersAdded_.bind(this));
       this.tracker_.add(
           this.nativeLayer_,
           print_preview.NativeLayer.EventType.EXTENSION_CAPABILITIES_SET,
           this.onExtensionCapabilitiesSet_.bind(this));
+      this.tracker_.add(
+          this.nativeLayer_,
+          print_preview.NativeLayer.EventType.EXTENSION_USB_PRINTER_RESOLVED,
+          this.resolveProvisionalDestination_.bind(this));
     },
 
     /**
      * Creates a local PDF print destination.
      * @return {!print_preview.Destination} Created print destination.
      * @private
      */
     createLocalPdfPrintDestination_: function() {
       // TODO(alekseys): Create PDF printer in the native code and send its
       // capabilities back with other local printers.
@@ skipping 206 matching lines @@
     /**
      * Called when an extension responds to a getExtensionDestinations
      * request.
      * @param {Object} event Contains information about list of printers
      *     reported by the extension.
      *     {@code done} parameter is set iff this is the final list of printers
      *     returned as part of getExtensionDestinations request.
      * @private
      */
     onExtensionPrintersAdded_: function(event) {
-      // Filter out printers enumerated from providers' "usbPrinters" manifest
-      // key for now.
-      var filteredPrinters = event.printers.filter(function(printer) {
-        return 'extensionId' in printer;
-      });
-      this.insertDestinations_(filteredPrinters.map(function(printer) {
-        return print_preview.ExtensionDestinationParser.parse(printer);
-      }));
+      event.printers.forEach(function(printer) {
+        if (!printer.needsUsbPermission) {
+          this.insertDestinations_([
+            print_preview.ExtensionDestinationParser.parse(printer)
+          ]);
+          return;
+        }
+
+        // Add provisional extension destinations that support a USB printer.
+        printer.extensions.forEach(function(extension) {
+          var provisionalDest = print_preview.ExtensionDestinationParser.parse({
+            id: extension.printerId,
+            extensionId: extension.extensionId,
+            extensionName: extension.extensionName,
+            name: printer.name,
+            usbDevice: printer.usbDevice
+          });
+
+          provisionalDest.provisionalType =
+              print_preview.Destination.ProvisionalType.NEEDS_USB_PERMISSION;
+          this.insertDestinations_([provisionalDest]);
+        }.bind(this));
+      }.bind(this));
 
       if (event.done && this.isExtensionDestinationSearchInProgress_) {
         clearTimeout(this.extensionSearchTimeout_);
         this.endExtensionPrinterSearch_();
       }
     },
 
     /**
      * Called when capabilities for an extension managed printer are set.
      * @param {Object} event Contains the printer's capabilities and ID.
@@ skipping 69 matching lines @@
       return id == this.appState_.selectedDestinationId &&
              origin == this.appState_.selectedDestinationOrigin;
     }
   };
 
   // Export
   return {
     DestinationStore: DestinationStore
   };
 });