[Cleanup] Files.app: Misc style fixes in Javascript code.

chrome/browser/resources/file_manager/js/directory_model.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.
 
 // If directory files changes too often, don't rescan directory more than once
 // per specified interval
 var SIMULTANEOUS_RESCAN_INTERVAL = 1000;
 // Used for operations that require almost instant rescan.
 var SHORT_RESCAN_INTERVAL = 100;
 
 /**
  * Data model of the file manager.
  *
- * @constructor
  * @param {DirectoryEntry} root File system root.
  * @param {boolean} singleSelection True if only one file could be selected
  *                                  at the time.
  * @param {MetadataCache} metadataCache The metadata cache service.
  * @param {VolumeManager} volumeManager The volume manager.
  * @param {boolean} isDriveEnabled True if DRIVE enabled (initial value).
+ * @constructor
  */
 function DirectoryModel(root, singleSelection,
                         metadataCache, volumeManager, isDriveEnabled) {
   this.root_ = root;
   var fileList = new cr.ui.ArrayDataModel([]);
   this.fileListSelection_ = singleSelection ?
       new cr.ui.ListSingleSelectionModel() : new cr.ui.ListSelectionModel();
 
   this.runningScan_ = null;
   this.pendingScan_ = null;
   this.rescanTime_ = null;
   this.scanFailures_ = 0;
   this.driveEnabled_ = isDriveEnabled;
 
   this.currentFileListContext_ = new FileListContext(
       metadataCache, fileList, false);
   this.currentDirContents_ = new DirectoryContentsBasic(
       this.currentFileListContext_, root);
 
   this.rootsList_ = new cr.ui.ArrayDataModel([]);
   this.rootsListSelection_ = new cr.ui.ListSingleSelectionModel();
   this.rootsListSelection_.addEventListener(
       'change', this.onRootChange_.bind(this));
 
   this.rootsListSelection_.addEventListener(
       'beforeChange', this.onBeforeRootChange_.bind(this));
 
   /**
    * A map root.fullPath -> currentDirectory.fullPath.
+   * @type {Object.<string, string>}
    * @private
-   * @type {Object.<string, string>}
    */
   this.currentDirByRoot_ = {};
 
   this.volumeManager_ = volumeManager;
 }
 
 /**
  * Fake entry to be used in currentDirEntry_ when current directory is
  * unmounted DRIVE.
  * @private
@@ skipping 171 matching lines @@
 };
 
 /**
  * @return {string} Path for the current directory.
  */
 DirectoryModel.prototype.getCurrentDirPath = function() {
   return this.currentDirContents_.getPath();
 };
 
 /**
+ * @return {Array.<string>} File paths of selected files.
  * @private
- * @return {Array.<string>} File paths of selected files.
  */
 DirectoryModel.prototype.getSelectedPaths_ = function() {
   var indexes = this.fileListSelection_.selectedIndexes;
   var fileList = this.getFileList();
   if (fileList) {
     return indexes.map(function(i) {
       return fileList.item(i).fullPath;
     });
   }
   return [];
 };
 
 /**
+ * @param {Array.<string>} value List of file paths of selected files.
  * @private
- * @param {Array.<string>} value List of file paths of selected files.
  */
 DirectoryModel.prototype.setSelectedPaths_ = function(value) {
   var indexes = [];
   var fileList = this.getFileList();
 
   var safeKey = function(key) {
     // The transformation must:
     // 1. Never generate a reserved name ('__proto__')
     // 2. Keep different keys different.
     return '#' + key;
   };
 
   var hash = {};
 
   for (var i = 0; i < value.length; i++)
     hash[safeKey(value[i])] = 1;
 
   for (var i = 0; i < fileList.length; i++) {
     if (hash.hasOwnProperty(safeKey(fileList.item(i).fullPath)))
       indexes.push(i);
   }
   this.fileListSelection_.selectedIndexes = indexes;
 };
 
 /**
+ * @return {string} Lead item file path.
  * @private
- * @return {string} Lead item file path.
  */
 DirectoryModel.prototype.getLeadPath_ = function() {
   var index = this.fileListSelection_.leadIndex;
   return index >= 0 && this.getFileList().item(index).fullPath;
 };
 
 /**
+ * @param {string} value The name of new lead index.
  * @private
- * @param {string} value The name of new lead index.
  */
 DirectoryModel.prototype.setLeadPath_ = function(value) {
   var fileList = this.getFileList();
   for (var i = 0; i < fileList.length; i++) {
     if (fileList.item(i).fullPath === value) {
       this.fileListSelection_.leadIndex = i;
       return;
     }
   }
 };
@@ skipping 81 matching lines @@
 
   this.scan_(dirContents, successCallback);
 };
 
 /**
  * Run scan on the current DirectoryContents. The active fileList is cleared and
  * the entries are added directly.
  *
  * This should be used when changing directory or initiating a new search.
  *
- * @private
  * @param {DirectoryContentes} newDirContents New DirectoryContents instance to
  *     replace currentDirContents_.
  * @param {Function} opt_callback Called on success.
+ * @private
  */
 DirectoryModel.prototype.clearAndScan_ = function(newDirContents,
                                                   opt_callback) {
   if (this.currentDirContents_.isScanning())
     this.currentDirContents_.cancelScan();
   this.currentDirContents_ = newDirContents;
   this.clearRescanTimeout_();
 
   if (this.pendingScan_)
     this.pendingScan_ = false;
@@ skipping 13 matching lines @@
   var fileList = this.getFileList();
   fileList.splice(0, fileList.length);
   cr.dispatchSimpleEvent(this, 'scan-started');
   this.scan_(this.currentDirContents_, onDone);
 };
 
 /**
  * Perform a directory contents scan. Should be called only from rescan() and
  * clearAndScan_().
  *
- * @private
  * @param {DirectoryContents} dirContents DirectoryContents instance on which
  *     the scan will be run.
  * @param {function} successCallback Callback on success.
+ * @private
  */
 DirectoryModel.prototype.scan_ = function(dirContents, successCallback) {
   var self = this;
 
   /**
    * Runs pending scan if there is one.
    *
    * @return {boolean} Did pending scan exist.
    */
   var maybeRunPendingRescan = function() {
@@ skipping 25 matching lines @@
 
   this.runningScan_ = dirContents;
 
   dirContents.addEventListener('scan-completed', onSuccess);
   dirContents.addEventListener('scan-failed', onFailure);
   dirContents.addEventListener('scan-cancelled', this.dispatchEvent.bind(this));
   dirContents.scan();
 };
 
 /**
+ * @param {DirectoryContents} dirContents DirectoryContents instance.
  * @private
- * @param {DirectoryContents} dirContents DirectoryContents instance.
  */
 DirectoryModel.prototype.replaceDirectoryContents_ = function(dirContents) {
   cr.dispatchSimpleEvent(this, 'begin-update-files');
   this.fileListSelection_.beginChange();
 
   var selectedPaths = this.getSelectedPaths_();
   var selectedIndices = this.fileListSelection_.selectedIndexes;
 
   // Restore leadIndex in case leadName no longer exists.
   var leadIndex = this.fileListSelection_.leadIndex;
@@ skipping 52 matching lines @@
 
     var index = self.findIndexByName_(name);
     if (index >= 0)
       fileList.splice(index, 1);
   };
 
   util.resolvePath(currentEntry, name, onEntryFound, onError);
 };
 
 /**
- * @private
  * @param {string} name Filename.
  * @return {number} The index in the fileList.
+ * @private
  */
 DirectoryModel.prototype.findIndexByName_ = function(name) {
   var fileList = this.getFileList();
   for (var i = 0; i < fileList.length; i++)
     if (fileList.item(i).name == name)
       return i;
   return -1;
 };
 
 /**
@@ skipping 130 matching lines @@
   if (path == '/') {
     successCallback(this.root_);
     return;
   }
 
   this.root_.getDirectory(path, {create: false},
                           successCallback, errorCallback);
 };
 
 /**
+ * @return {Entry} Directory entry of the root selected in rootsList.
  * @private
- * @return {Entry} Directory entry of the root selected in rootsList.
  */
 DirectoryModel.prototype.getSelectedRootDirEntry_ = function() {
   return this.rootsList_.item(this.rootsListSelection_.selectedIndex);
 };
 
 /**
  * Handler before root item change.
  * @param {Event} event The event.
  * @private
  */
 DirectoryModel.prototype.onBeforeRootChange_ = function(event) {
   if (event.changes.length == 1 && !event.changes[0].selected)
     event.preventDefault();
 };
 
 /**
  * Handler for root item being clicked.
+ * @param {Event} event The event.
  * @private
- * @param {Event} event The event.
  */
 DirectoryModel.prototype.onRootChange_ = function(event) {
   var newRootDir = this.getSelectedRootDirEntry_();
   if (newRootDir)
     this.changeRoot(newRootDir.fullPath);
 };
 
 /**
  * Changes directory. If path points to a root (except current one)
  * then directory changed to the last used one for the root.
  *
  * @param {string} path New current directory path or new root.
  */
 DirectoryModel.prototype.changeRoot = function(path) {
   var currentDir = this.currentDirByRoot_[path] || path;
   if (currentDir == this.getCurrentDirPath())
     return;
   var onError = path != currentDir && path != this.getCurrentDirPath() ?
       this.changeDirectory.bind(this, path) : null;
   this.resolveDirectory(
       currentDir,
       this.changeDirectoryEntry_.bind(this, false),
       onError);
 };
 
 /**
- * @private
  * @param {DirectoryEntry} dirEntry The absolute path to the new directory.
  * @param {function} opt_callback Executed if the directory loads successfully.
+ * @private
  */
 DirectoryModel.prototype.changeDirectoryEntrySilent_ = function(dirEntry,
                                                                 opt_callback) {
   var onScanComplete = function() {
     if (opt_callback)
       opt_callback();
     // For tests that open the dialog to empty directories, everything
     // is loaded at this point.
     chrome.test.sendMessage('directory-change-complete');
   };
   this.clearAndScan_(new DirectoryContentsBasic(this.currentFileListContext_,
                                                 dirEntry),
                      onScanComplete.bind(this));
   this.currentDirByRoot_[this.getCurrentRootPath()] = dirEntry.fullPath;
   this.updateRootsListSelection_();
 };
 
 /**
  * Change the current directory to the directory represented by a
  * DirectoryEntry.
  *
  * Dispatches the 'directory-changed' event when the directory is successfully
  * changed.
  *
- * @private
  * @param {boolean} initial True if it comes from setupPath and
  *                          false if caused by an user action.
  * @param {DirectoryEntry} dirEntry The absolute path to the new directory.
  * @param {function} opt_callback Executed if the directory loads successfully.
+ * @private
  */
 DirectoryModel.prototype.changeDirectoryEntry_ = function(initial, dirEntry,
                                                           opt_callback) {
   if (dirEntry == DirectoryModel.fakeDriveEntry_ &&
       this.volumeManager_.getDriveStatus() ==
           VolumeManager.DriveStatus.UNMOUNTED) {
     this.volumeManager_.mountDrive(function() {}, function() {});
   }
 
   this.clearSearch_();
@@ skipping 185 matching lines @@
   // this.focusCurrentList_();
   if (index >= this.getFileList().length)
     return;
 
   // If a list bound with the model it will do scrollIndexIntoView(index).
   this.fileListSelection_.selectedIndex = index;
 };
 
 /**
  * Get root entries asynchronously.
+ * @param {function(Array.<Entry>)} callback Called when roots are resolved.
  * @private
- * @param {function(Array.<Entry>)} callback Called when roots are resolved.
  */
 DirectoryModel.prototype.resolveRoots_ = function(callback) {
   var groups = {
     downloads: null,
     archives: null,
     removables: null,
     drive: null
   };
   var self = this;
 
@@ skipping 275 matching lines @@
 
 /**
  * @param {string} name Filter identifier.
  */
 DirectoryModel.prototype.removeFilter = function(name) {
   this.currentFileListContext_.removeFilter(name);
 };
 
 
 /**
- * @constructor
  * @param {DirectoryEntry} root Root entry.
  * @param {DirectoryModel} directoryModel Model to watch.
  * @param {VolumeManager} volumeManager Manager to watch.
+ * @constructor
  */
 function FileWatcher(root, directoryModel, volumeManager) {
   this.root_ = root;
   this.dm_ = directoryModel;
   this.vm_ = volumeManager;
   this.watchedDirectoryEntry_ = null;
   this.updateWatchedDirectoryBound_ =
       this.updateWatchedDirectory_.bind(this);
   this.onDirectoryChangedBound_ =
       this.onDirectoryChanged_.bind(this);
@@ skipping 99 matching lines @@
         }.bind(this));
   }
 };
 
 /**
  * @return {DirectoryEntry} Current watched directory entry.
  */
 FileWatcher.prototype.getWatchedDirectoryEntry = function() {
   return this.watchedDirectoryEntry_;
 };