Change getAccessToken and getExtensionPrinterAccess to sendWithPromise

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 995 matching lines @@
     /**
      * Attempts to resolve a provisional destination.
      * @param {!print_preview.Destination} destination Provisional destination
      *     that should be resolved.
      */
     resolveProvisionalDestination: function(destination) {
       assert(
           destination.provisionalType ==
               print_preview.DestinationProvisionalType.NEEDS_USB_PERMISSION,
           'Provisional type cannot be resolved.');
-      this.nativeLayer_.grantExtensionPrinterAccess(destination.id);
+      var id = destination.id;
+      this.nativeLayer_.grantExtensionPrinterAccess(id).then(
+          this.handleProvisionalDestinationResolved_.bind(this, id),

[dpapad, 2017/06/15 22:20:13]

handleProvisionalDestinationResolved_and handleProvisionalDestinationRejected_
are only used here. Can we inline them here instead?

[rbpotter, 2017/06/16 02:19:36]

Done.

+          this.handleProvisionalDestinationRejected_.bind(this, id));
     },
 
     /**
      * Selects 'Save to PDF' destination (since it always exists).
      * @private
      */
     selectPdfDestination_: function() {
       var saveToPdfKey = this.getDestinationKey_(
           print_preview.DestinationOrigin.LOCAL,
           print_preview.Destination.GooglePromotedId.SAVE_AS_PDF,
@@ skipping 109 matching lines @@
       this.startLoadCloudDestinations();
       this.startLoadLocalDestinations();
       this.startLoadPrivetDestinations();
       this.startLoadExtensionDestinations();
     },
 
     /**
      * Wait for a privet device to be registered.
      */
     waitForRegister: function(id) {
       this.nativeLayer_.getPrivetPrinters().then(

[dpapad, 2017/06/15 22:20:13]

Unrelated to this CL, but related to previous. Is |waitForRegisterDestination_|
and |waitForRegister| still relevant? We already have a Promise for it. Could it
be something like 

waitForRegister: function(id) {
  return this.nativeLayer_.getPrivetPrinters().then(
      this.endPrivetPrinterSearch_.bind(this));
}

And whoever calls this, uses the returned Promise?

[rbpotter, 2017/06/16 02:19:36]

I think the issue is that the promise returned by getPrivetPrinters()
is not resolved until privet search times out, i.e. "all" privet
destinations have been retrieved. waitForRegisterDestination_ is used
so that the desired destination that is being registered can be
selected as soon as it arrives, see onPrivetPrinterAdded_ here:
(https://cs.chromium.org/chromium/src/chrome/browser/resources/print_preview/d...).

I think to eliminate these variables we would need to create a new
native layer function, like getPrivetPrinter(), that would send the
specific destination ID to C++ so that the promise could be resolved
when that destination was returned, and would be resolved with the
appropriate structure (instead of just base::Value()). Then we would
have:
nativeLayer_.getPrivetPrinter(id).then(
this.onPrivetPrinterAdded_().bind(this));

Do you think this is worth doing (maybe in a follow-up CL)?

           this.endPrivetPrinterSearch_.bind(this));
       this.waitForRegisterDestination_ = id;
     },
 
     /**
-     * Event handler for {@code
-     * print_preview.NativeLayer.EventType.PROVISIONAL_DESTINATION_RESOLVED}.
-     * Currently assumes the provisional destination is an extension
-     * destination.
-     * Called when a provisional destination resolvement attempt finishes.
-     * The provisional destination is removed from the store and replaced with
-     * a destination created from the resolved destination properties, if any
-     * are reported.
-     * Emits {@code DestinationStore.EventType.PROVISIONAL_DESTINATION_RESOLVED}
-     * event.
-     * @param {!Event} evt The event containing the provisional destination ID
-     *     and resolved destination description. If the destination was not
-     *     successfully resolved, the description will not be set.
+     * Removes the provisional destination with ID |provisionalId| from
+     * |destinationMap_| and |destinations_|.
+     * @param{string} provisionalId The provisional destination ID.
      * @private
      */
-    handleProvisionalDestinationResolved_: 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;
-        }
-      }
+    removeProvisionalDestination_: function(provisionalId) {
+      this.destinations_ = this.destinations_.filter(
+          function(el, i, destinations) {
+            if (el.id == provisionalId) {
+              delete this.destinationMap_[this.getKey_(el)];
+              return false;
+            }
+            return true;
+          }, this);
+    },
 
-      if (!provisionalDestination)
-        return;
-
-      this.destinations_.splice(provisionalDestinationIndex, 1);
-      delete this.destinationMap_[this.getKey_(provisionalDestination)];
-
-      var destination = evt.destination ?
-          print_preview.ExtensionDestinationParser.parse(evt.destination) :
-          null;
-
-      if (destination)
-        this.insertIntoStore_(destination);
-
+    /**
+     * Dispatches the PROVISIONAL_DESTINATION_RESOLVED event for id
+     * |provisionalId| and destination |destination|.
+     * @param {string} provisionalId The ID of the destination that was
+     *     resolved.
+     * @param {?print_preview.Destination} destination Information about the
+     *     destination if it was resolved successfully.
+     */
+    dispatchProvisionalDestinationResolvedEvent_: function(provisionalId,
+                                                           destination) {
       var event = new Event(
           DestinationStore.EventType.PROVISIONAL_DESTINATION_RESOLVED);
-      event.provisionalId = evt.provisionalId;
+      event.provisionalId = provisionalId;
       event.destination = destination;
       this.dispatchEvent(event);
     },
 
     /**
+     * Called when a provisional destination resolvement attempt finishes
+     * successfully. The provisional destination is removed from the store and
+     * replaced with a destination created from the resolved destination
+     * properties, if any are reported.
+     * Currently assumes the provisional destination is an extension
+     * destination.
+     * Emits {@code DestinationStore.EventType.PROVISIONAL_DESTINATION_RESOLVED}
+     * event.
+     * @param {string} provisionalId The provisional destination ID
+     * @param {!print_preview.ProvisionalDestinationInfo} destinationInfo
+     *     Information about the resolved printer.
+     * @private
+     */
+    handleProvisionalDestinationResolved_: function(provisionalId,
+                                                    destinationInfo) {
+      this.removeProvisionalDestination_(provisionalId);
+      var destination =
+          print_preview.ExtensionDestinationParser.parse(destinationInfo);
+      this.insertIntoStore_(destination);
+      this.dispatchProvisionalDestinationResolvedEvent_(provisionalId,
+                                                        destination);
+    },
+
+    /**
+     * Called when a provisional destination resolvement attempt fails.
+     * The provisional destination is removed from the store.
+     * Currently assumes the provisional destination is an extension
+     * destination.
+     * Emits {@code DestinationStore.EventType.PROVISIONAL_DESTINATION_RESOLVED}
+     * event.
+     * @param {string} provisionalId The provisional destination ID
+     * @private
+     */
+    handleProvisionalDestinationRejected_: function(provisionalId) {
+      this.removeProvisionalDestination_(provisionalId);
+      this.dispatchProvisionalDestinationResolvedEvent_(provisionalId, null);
+    },
+
+    /**
      * 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 132 matching lines @@
     /**
      * Binds handlers to events.
      * @private
      */
     addEventListeners_: function() {
       var nativeLayerEventTarget = this.nativeLayer_.getEventTarget();
       this.tracker_.add(
           nativeLayerEventTarget,
           print_preview.NativeLayer.EventType.DESTINATIONS_RELOAD,
           this.onDestinationsReload_.bind(this));
-      this.tracker_.add(
-          nativeLayerEventTarget,
-          print_preview.NativeLayer.EventType.PROVISIONAL_DESTINATION_RESOLVED,
-          this.handleProvisionalDestinationResolved_.bind(this));
     },
 
     /**
      * Creates a local PDF print destination.
      * @private
      */
     createLocalPdfPrintDestination_: function() {
       // TODO(alekseys): Create PDF printer in the native code and send its
       // capabilities back with other local printers.
       if (this.pdfPrinterEnabled_) {
@@ skipping 300 matching lines @@
       return this.getDestinationKey_(
           destination.origin, destination.id, destination.account);
     }
   };
 
   // Export
   return {
     DestinationStore: DestinationStore
   };
 });