Eliminate last vestigages of the command system design.

ui/file_manager/file_manager/foreground/js/import_controller.js

 // Copyright 2014 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.
 
 // Namespace
 var importer = importer || {};
 
 /** @enum {string} */
 importer.ResponseId = {
   HIDDEN: 'hidden',
@@ skipping 18 matching lines @@
  * behalf of Cloud Import.
  *
  * @constructor
  * @struct
  *
  * @param {!importer.ControllerEnvironment} environment The class providing
  *     access to runtime environmental information, like the current directory,
  *     volume lookup and so-on.
  * @param {!importer.MediaScanner} scanner
  * @param {!importer.ImportRunner} importRunner
- * @param {function()} commandUpdateHandler
+ * @param {!importer.CommandWidget} commandWidget
  */
 importer.ImportController =
-    function(environment, scanner, importRunner, commandUpdateHandler) {
+    function(environment, scanner, importRunner, commandWidget) {
 
   /** @private {!importer.ControllerEnvironment} */
   this.environment_ = environment;
 
   /** @private {!importer.ImportRunner} */
   this.importRunner_ = importRunner;
 
   /** @private {!importer.MediaScanner} */
   this.scanner_ = scanner;
 
-  /** @private {function()} */
-  this.updateCommands_ = commandUpdateHandler;
+  /** @private {!importer.CommandWidget} */
+  this.commandWidget_ = commandWidget;
 
   /**
    * A cache of scans by volumeId, directory URL.
    * Currently only scans of directories are cached.
    * @private {!Object.<string, !Object.<string, !importer.ScanResult>>}
    */
   this.cachedScans_ = {};
 
   var listener = this.onScanEvent_.bind(this);
   this.scanner_.addObserver(listener);
   // Remove the observer when the foreground window is closed.
-  window.addEventListener('pagehide', function() {
-    this.scanner_.removeObserver(listener);
-  }.bind(this));
+  window.addEventListener(
+      'pagehide',
+      function() {
+        this.scanner_.removeObserver(listener);
+      }.bind(this));
+
   this.environment_.addVolumeUnmountListener(
       this.onVolumeUnmounted_.bind(this));
+
   this.environment_.addDirectoryChangedListener(
       this.onDirectoryChanged_.bind(this));
+
+  this.commandWidget_.addExecuteListener(
+      this.execute.bind(this));
 };
 
 /**
  * @param {!importer.ScanEvent} event Command event.
  * @param {importer.ScanResult} result
  *
  * @private
  */
 importer.ImportController.prototype.onScanEvent_ = function(event, result) {
   if (event === importer.ScanEvent.INVALIDATED) {
     for (var key in this.cachedScans_) {
       for (var url in this.cachedScans_[key]) {
         if (this.cachedScans_[key][url].isInvalidated()) {
           delete this.cachedScans_[key][url];
         }
       }
     }
   }
   if (event === importer.ScanEvent.FINALIZED ||
       event === importer.ScanEvent.INVALIDATED) {
-    this.updateCommands_();
+    this.pushUpdate_();
   }
 };
 
 /**
  * Executes import against the current directory. Should only
  * be called when the current directory has been validated
  * by calling "update" on this class.
  */
 importer.ImportController.prototype.execute = function() {
   metrics.recordEnum('CloudImport.UserAction', 'IMPORT_INITIATED');
   var result = this.getScanForImport_();
   var importTask = this.importRunner_.importFromScanResult(result);
 };
 
 /**
- * Called by the 'cloud-import' command when it wants an update
- * on the command state.
+ * Push an update to the command widget.
+ * @private
+ */
+importer.ImportController.prototype.pushUpdate_ = function() {
+  this.commandWidget_.update(this.getCommandUpdate());
+};
+
+/**
+ * Returns an update describing the state of the CommandWidget.
  *
  * @return {!importer.CommandUpdate} response
  */
 importer.ImportController.prototype.getCommandUpdate = function() {
   // If there is no Google Drive mount, Drive may be disabled
   // or the machine may be running in guest mode.
   if (this.environment_.isGoogleDriveMounted()) {
     var entries = this.environment_.getSelection();
 
     // Enabled if user has a selection and it consists entirely of files
@@ skipping 136 matching lines @@
 
 /**
  * @param {string} volumeId
  * @private
  */
 importer.ImportController.prototype.onVolumeUnmounted_ = function(volumeId) {
   // Forget all scans related to the unmounted volume volume.
   if (this.cachedScans_.hasOwnProperty(volumeId)) {
     delete this.cachedScans_[volumeId];
   }
+  this.pushUpdate_();
+};
+
+/** @private */
+importer.ImportController.prototype.onDirectoryChanged_ = function() {
+  this.pushUpdate_();
 };
 
 /**
- * @param {string} volumeId
- * @private
- */
-importer.ImportController.prototype.onDirectoryChanged_ = function() {
-  this.updateCommands_();
-};
-
-/**
  * Interface abstracting away the concrete file manager available
  * to commands. By hiding file manager we make it easy to test
  * ImportController.
  *
  * @interface
  * @extends {VolumeManagerCommon.VolumeInfoProvider}
  */
 importer.ControllerEnvironment = function() {};
 
 /**
@@ skipping 103 matching lines @@
   // TODO(smckay): remove listeners when the page is torn down.
   this.fileManager_.directoryModel.addEventListener(
       'directory-changed',
       listener);
 };
 
 /**
  * Class that adapts from the new non-command button to the old
  * command style interface.
  *
- * <p>NOTE: This adapter is a stop gap bridge between the old-style
- * Command button and our new do-it-yourself toolbar button. We used
- * an adapter to minimize changes to RuntimeImportController while other
- * people are working on that file. Once the dust settles we can make
- * more transformative changes.
+ * @interface
+ */
+importer.CommandWidget = function() {};
+
+/**
+ * Install a listener that get's called when the user wants to initiate
+ * import.
+ *
+ * @param {function()} listener
+ */
+importer.CommandWidget.prototype.addExecuteListener;
+
+/**
+ * @param {!importer.CommandUpdate} update
+ */
+importer.CommandWidget.prototype.update;
+
+/**
+ * Runtime implementation of CommandWidget.
  *
  * @constructor
+ * @implements {importer.CommandWidget}
  * @struct
- *
- * @param {!FileManager} fileManager
  */
-importer.ButtonCommandAdapter = function(fileManager) {
-
-  /** @param {!FileManager} */
-  this.fileManager_ = fileManager;
-
-  /** @param {Element} */
+importer.RuntimeCommandWidget = function() {
+  /** @private {Element} */
   this.buttonElement_ = document.querySelector('#cloud-import-button');
 
-  this.buttonElement_.onclick = this.execute_.bind(this);
+  this.buttonElement_.onclick = this.notifyExecuteListener_.bind(this);
 
-  /** @param {Element} */
+  /** @private {Element} */
   this.iconElement_ = document.querySelector('#cloud-import-button core-icon');
+
+  /** @private {function()} */
+  this.listener_;
+};
+
+/** @override */
+importer.RuntimeCommandWidget.prototype.addExecuteListener =
+    function(listener) {
+  console.assert(!this.listener_);
+  this.listener_ = listener;
 };
 
 /** @private */
-importer.ButtonCommandAdapter.prototype.execute_ = function() {
-  this.fileManager_.importController.execute();
+importer.RuntimeCommandWidget.prototype.notifyExecuteListener_ = function() {
+  console.assert(!!this.listener_);
+  this.listener_();
 };
 
-/**
- * @param {!Event} event Command event.
- * @param {!FileManager} fileManager
- */
-importer.ButtonCommandAdapter.prototype.update = function() {
-  if (this.fileManager_.importController) {
-    var update = fileManager.importController.getCommandUpdate();
+/** @override */
+importer.RuntimeCommandWidget.prototype.update = function(update) {
     this.buttonElement_.setAttribute('title', update.label);
     this.buttonElement_.disabled = !update.executable;
     this.buttonElement_.style.display  = update.visible ? 'block' : 'none';
     this.iconElement_.setAttribute('icon', update.coreIcon);
-  } else {
-    this.buttonElement_.setAttribute('display', 'none');
-    this.iconElement_.setAttribute('icon', 'cloud-off');
-  }
 };
+

[mtomasz, 2015/01/28 22:54:03]

nit: remove \n