1. Fix JSDocs in directory_model.js.

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;
 
@@ skipping 33 matching lines @@
 
   /**
    * A map root.fullPath -> currentDirectory.fullPath.
    * @private
    * @type {Object.<string, string>}
    */
   this.currentDirByRoot_ = {};
 
   // The map 'name' -> callback. Callbacks are function(entry) -> boolean.
   this.filters_ = {};
-  this.filterHidden = true;
+  this.setFilterHidden(true);
 
   // Readonly status.
   this.readonly_ = false;
   this.currentVolumeMetadata_ = {rootPath: '/'};
   this.offline_ = false;
 }
 
 /**
  * The name of the directory containing externally
  * mounted removable storage volumes.
@@ skipping 20 matching lines @@
 /**
 * The name of the downloads directory.
 */
 DirectoryModel.DOWNLOADS_DIRECTORY = 'Downloads';
 
 /**
 * The name of the gdata provider directory.
 */
 DirectoryModel.GDATA_DIRECTORY = 'gdata';
 
-DirectoryModel.prototype = {
-  __proto__: cr.EventTarget.prototype,
+/**
+ * DirectoryModel extends cr.EventTarget.
+ */
+DirectoryModel.prototype.__proto__ = cr.EventTarget.prototype;
 
-  /**
-   * Files in the current directory.
-   * @type {cr.ui.ArrayDataModel}
-   */
-  get fileList() {
-    return this.fileList_;
-  },
+/**
+ * @return {cr.ui.ArrayDataModel} Files in the current directory.
+ */
+DirectoryModel.prototype.getFileList = function() {
+  return this.fileList_;
+};
 
-  /**
-   * Selection in the fileList.
-   * @type {cr.ui.ListSelectionModel|cr.ui.ListSingleSelectionModel}
-   */
-  get fileListSelection() {
-    return this.fileListSelection_;
-  },
+/**
+ * Sort the file list.
+ * @param {string} sortField Sort field.
+ * @param {string} sortDirection "asc" or "desc".
+ */
+DirectoryModel.prototype.sortFileList = function(sortField, sortDirection) {
+  this.fileList_.sort(sortField, sortDirection);
+};
 
-  get rootType() {
-    return DirectoryModel.getRootType(this.currentEntry.fullPath);
-  },
+/**
+ * @return {cr.ui.ListSelectionModel|cr.ui.ListSingleSelectionModel} Selection
+ * in the fileList.
+ */
+DirectoryModel.prototype.getFileListSelection = function() {
+  return this.fileListSelection_;
+};
 
-  get rootName() {
-    return DirectoryModel.getRootName(this.currentEntry.fullPath);
-  },
+/**
+ * @return {DirectoryModel.RootType} Root type of current root.
+ */
+DirectoryModel.prototype.getRootType = function() {
+  return DirectoryModel.getRootType(this.currentDirEntry_.fullPath);
+};
 
-  /**
-   * True if current directory is read only.
-   * @type {boolean}
-   */
-  get readonly() {
-    return this.readonly_;
-  },
+/**
+ * @return {string} Root name.
+ */
+DirectoryModel.prototype.getRootName = function() {
+  return DirectoryModel.getRootName(this.currentDirEntry_.fullPath);
+};
 
-  get offline() {
-    return this.offline_;
-  },
-  set offline(value) {
-    if (this.offline_ != value) {
-      this.offline_ = !!value;
-      this.updateReadonlyStatus_();
-    }
-  },
+/**
+ * @return {boolean} True if current directory is read only.
+ */
+DirectoryModel.prototype.isReadOnly = function() {
+  return this.readonly_;
+};
 
-  get isSystemDirectoy() {
-    var path = this.currentEntry.fullPath;
-    return path == '/' ||
-           path == '/' + DirectoryModel.REMOVABLE_DIRECTORY ||
-           path == '/' + DirectoryModel.ARCHIVE_DIRECTORY;
-  },
+/**
+ * @return {boolean} If offline.
+ */
+DirectoryModel.prototype.isOffline = function() {
+  return this.offline_;
+};
 
-  get filterHidden() {
-    return !!this.filters_['hidden'];
-  },
+/**
+ * @param {boolean} value New online status.
+ */
+DirectoryModel.prototype.setOffline = function(value) {
+  if (this.offline_ != value) {
+    this.offline_ = !!value;
+    this.updateReadonlyStatus_();
+  }
+};
 
-  set filterHidden(value) {
-    if (value) {
-      this.addFilter('hidden',
-                     function(e) {return e.name.substr(0, 1) != '.';});
-    } else {
-      this.removeFilter('hidden');
-    }
-  },
+/**
+ * @return {boolean} If current directory is system.
+ */
+DirectoryModel.prototype.isSystemDirectory = function() {
+  var path = this.currentDirEntry_.fullPath;
+  return path == '/' ||
+         path == '/' + DirectoryModel.REMOVABLE_DIRECTORY ||
+         path == '/' + DirectoryModel.ARCHIVE_DIRECTORY;
+};
 
-  /**
-   * Current directory.
-   * @type {DirectoryEntry}
-   */
-  get currentEntry() {
-    return this.currentDirEntry_;
-  },
+/**
+ * @return {boolean} If the files with names starting with "." are not shown.
+ */
+DirectoryModel.prototype.isFilterHiddenOn = function() {
+  return !!this.filters_['hidden'];
+};
 
-  set autoSelectIndex(value) {
-    this.autoSelectIndex_ = value;
-  },
+/**
+ * @param {boolean} value Whether files with leading "." are hidden.
+ */
+DirectoryModel.prototype.setFilterHidden = function(value) {
+  if (value) {
+    this.addFilter('hidden',
+                   function(e) {return e.name.substr(0, 1) != '.';});
+  } else {
+    this.removeFilter('hidden');
+  }
+};
 
-  /**
-   * Names of selected files.
-   * @type {Array.<string>}
-   */
-  get selectedNames() {
-    var indexes = this.fileListSelection_.selectedIndexes;
-    var dataModel = this.fileList_;
-    if (dataModel) {
-      return indexes.map(function(i) {
-        return dataModel.item(i).name;
-      });
-    }
-    return [];
-  },
+/**
+ * @return {DirectoryEntry} Current directory.
+ */
+DirectoryModel.prototype.getCurrentDirEntry = function() {
+  return this.currentDirEntry_;
+};
 
-  set selectedNames(value) {
-    var indexes = [];
-    var dataModel = this.fileList_;
+/**
+ * @param {number} value New auto select index.
+ */
+DirectoryModel.prototype.setAutoSelectIndex = function(value) {
+  this.autoSelectIndex_ = value;
+};
 
-    function safeKey(key) {
-      // The transformation must:
-      // 1. Never generate a reserved name ('__proto__')
-      // 2. Keep different keys different.
-      return '#' + key;
-    }
+/**
+ * @private
+ * @return {Array.<string>} Names of selected files.
+ */
+DirectoryModel.prototype.getSelectedNames_ = function() {
+  var indexes = this.fileListSelection_.selectedIndexes;
+  var dataModel = this.fileList_;
+  if (dataModel) {
+    return indexes.map(function(i) {
+      return dataModel.item(i).name;
+    });
+  }
+  return [];
+};
 
-    var hash = {};
+/**
+ * @private
+ * @param {Array.<string>} value List of names of selected files.
+ */
+DirectoryModel.prototype.setSelectedNames_ = function(value) {
+  var indexes = [];
+  var dataModel = this.fileList_;
 
-    for (var i = 0; i < value.length; i++)
-      hash[safeKey(value[i])] = 1;
+  function safeKey(key) {
+    // The transformation must:
+    // 1. Never generate a reserved name ('__proto__')
+    // 2. Keep different keys different.
+    return '#' + key;
+  }
 
-    for (var i = 0; i < dataModel.length; i++) {
-      if (hash.hasOwnProperty(safeKey(dataModel.item(i).name)))
-        indexes.push(i);
-    }
-    this.fileListSelection_.selectedIndexes = indexes;
-  },
+  var hash = {};
 
-  /**
-   * Lead item file name.
-   * @type {string?}
-   */
-  get leadName() {
-    var index = this.fileListSelection_.leadIndex;
-    return index >= 0 && this.fileList_.item(index).name;
-  },
+  for (var i = 0; i < value.length; i++)
+    hash[safeKey(value[i])] = 1;
 
-  set leadName(value) {
-    for (var i = 0; i < this.fileList_.length; i++) {
-      if (this.fileList_.item(i).name == value) {
-        this.fileListSelection_.leadIndex = i;
-        return;
-      }
+  for (var i = 0; i < dataModel.length; i++) {
+    if (hash.hasOwnProperty(safeKey(dataModel.item(i).name)))
+      indexes.push(i);
+  }
+  this.fileListSelection_.selectedIndexes = indexes;
+};
+
+/**
+ * @private
+ * @return {string} Lead item file name.
+ */
+DirectoryModel.prototype.getLeadName_ = function() {
+  var index = this.fileListSelection_.leadIndex;
+  return index >= 0 && this.fileList_.item(index).name;
+};
+
+/**
+ * @private
+ * @param {string} value The name of new lead index.
+ */
+DirectoryModel.prototype.setLeadName_ = function(value) {
+  for (var i = 0; i < this.fileList_.length; i++) {
+    if (this.fileList_.item(i).name == value) {
+      this.fileListSelection_.leadIndex = i;
+      return;
     }
   }
 };
 
 /**
  * @return {cr.ui.ArrayDataModel} The list of roots.
  */
 DirectoryModel.prototype.getRootsList = function() {
   return this.rootsList_;
 };
@@ skipping 93 matching lines @@
       this.pendingScan_ = this.createScanner_(fileList, successCallback);
     return;
   }
 
   this.runningScan_ = this.createScanner_(fileList, successCallback);
   this.runningScan_.run();
 };
 
 /**
  * @private
- * @param {Array.<Entry>|cr.ui.ArrayDataModel} list
+ * @param {Array.<Entry>|cr.ui.ArrayDataModel} list File list.
  * @param {function} successCallback Callback on success.
  * @return {DirectoryModel.Scanner} New Scanner instance.
  */
 DirectoryModel.prototype.createScanner_ = function(list, successCallback) {
   var self = this;
   function onSuccess() {
     self.scanFailures_ = 0;
     successCallback();
     if (self.pendingScan_) {
       self.runningScan_ = self.pendingScan_;
@@ skipping 14 matching lines @@
       this.currentDirEntry_,
       list,
       onSuccess,
       onFailure,
       this.prefetchCacheForSorting_.bind(this),
       this.filters_);
 };
 
 /**
  * @private
- * @param {Array.<Entry>} entries
+ * @param {Array.<Entry>} entries List of files.
  */
 DirectoryModel.prototype.replaceFileList_ = function(entries) {
   cr.dispatchSimpleEvent(this, 'begin-update-files');
   this.fileListSelection_.beginChange();
 
-  var selectedNames = this.selectedNames;
+  var selectedNames = this.getSelectedNames_();
   // Restore leadIndex in case leadName no longer exists.
   var leadIndex = this.fileListSelection_.leadIndex;
-  var leadName = this.leadName;
+  var leadName = this.getLeadName_();
 
   var spliceArgs = [].slice.call(entries);
   spliceArgs.unshift(0, this.fileList_.length);
   this.fileList_.splice.apply(this.fileList_, spliceArgs);
 
-  this.selectedNames = selectedNames;
+  this.setSelectedNames_(selectedNames);
   this.fileListSelection_.leadIndex = leadIndex;
-  this.leadName = leadName;
+  this.setLeadName_(leadName);
   this.fileListSelection_.endChange();
   cr.dispatchSimpleEvent(this, 'end-update-files');
 };
 
 /**
  * Cancels waiting and scheduled rescans and starts new scan.
  *
  * If the scan completes successfully on the first attempt, the callback will
  * be invoked and a 'scan-completed' event will be dispatched.  If the scan
  * fails for any reason, we'll periodically retry until it succeeds (and then
@@ skipping 26 matching lines @@
   if (this.currentDirEntry_ == this.unmountedGDataEntry_) {
     onDone();
     return;
   }
   this.runningScan_ = this.createScanner_(this.fileList_, onDone);
   this.runningScan_.run();
 };
 
 /**
  * @private
- * @param {Array.<Entry>} entries
- * @param {function} callback
+ * @param {Array.<Entry>} entries Files.
+ * @param {function} callback Callback on done.
  */
 DirectoryModel.prototype.prefetchCacheForSorting_ = function(entries,
                                                              callback) {
   var field = this.fileList_.sortStatus.field;
   if (field) {
     this.prepareSortEntries_(entries, field, callback);
   } else {
     callback();
   }
 };
@@ skipping 25 matching lines @@
 
     util.removeFileOrDirectory(
         entry,
         onSuccess,
         util.flog('Error deleting ' + entry.fullPath, onComplete));
   }
   onComplete();
 };
 
 /**
- * @param {string} name
+ * @param {string} name Filename.
  */
 DirectoryModel.prototype.onEntryChanged = function(name) {
-  var currentEntry = this.currentEntry;
+  var currentEntry = this.currentDirEntry_;
   var dm = this.fileList_;
   var self = this;
 
   function onEntryFound(entry) {
     self.prefetchCacheForSorting_([entry], function() {
       // Do nothing if current directory changed during async operations.
-      if (self.currentEntry != currentEntry)
+      if (self.currentDirEntry_ != currentEntry)
         return;
 
       var index = self.findIndexByName_(name);
       if (index >= 0)
         dm.splice(index, 1, entry);
       else
         dm.splice(dm.length, 0, entry);
     });
   };
 
   function onError(err) {
     // Do nothing if current directory changed during async operations.
-    if (self.currentEntry != currentEntry)
+    if (self.currentDirEntry_ != currentEntry)
       return;
     if (err.code != FileError.NOT_FOUND_ERR) {
       self.rescanLater();
       return;
     }
 
     var index = self.findIndexByName_(name);
     if (index >= 0)
       dm.splice(index, 1);
   };
 
-  util.resolvePath(currentEntry, name, onEntryFound, onError);
+  util.resolvePath(this.currentDirEntry_, name, onEntryFound, onError);
 };
 
 /**
  * @private
- * @param {string} name
+ * @param {string} name Filename.
  * @return {number} The index in the fileList.
  */
 DirectoryModel.prototype.findIndexByName_ = function(name) {
   var dm = this.fileList_;
   for (var i = 0; i < dm.length; i++)
     if (dm.item(i).name == name)
       return i;
   return -1;
 };
 
 /**
  * Rename the entry in the filesystem and update the file list.
  * @param {Entry} entry Entry to rename.
- * @param {string} newName
+ * @param {string} newName New name.
  * @param {function} errorCallback Called on error.
  * @param {function} opt_successCallback Called on success.
  */
 DirectoryModel.prototype.renameEntry = function(entry, newName, errorCallback,
                                                 opt_successCallback) {
   var self = this;
   function onSuccess(newEntry) {
     self.prefetchCacheForSorting_([newEntry], function() {
       var fileList = self.fileList_;
       var index = fileList.indexOf(entry);
       if (index >= 0)
         fileList.splice(index, 1, newEntry);
       self.selectEntry(newName);
       // If the entry doesn't exist in the list it mean that it updated from
       // outside (probably by directory rescan).
       if (opt_successCallback)
         opt_successCallback();
     });
   }
-  entry.moveTo(this.currentEntry, newName,
-               onSuccess, errorCallback);
+  entry.moveTo(this.currentDirEntry_, newName, onSuccess, errorCallback);
 };
 
 /**
  * Checks if current directory contains a file or directory with this name.
  * @param {string} newName Name to check.
  * @param {function(boolean, boolean?)} callback Called when the result's
  *     available. First parameter is true if the entry exists and second
  *     is true if it's a file.
  */
 DirectoryModel.prototype.doesExist = function(newName, callback) {
-  util.resolvePath(this.currentEntry, newName,
+  util.resolvePath(this.currentDirEntry_, newName,
       function(entry) {
         callback(true, entry.isFile);
       },
       callback.bind(window, false));
 };
 
 /**
  * Creates directory and updates the file list.
  *
- * @param {string} name
- * @param {function} successCallback
- * @param {function} errorCallback
+ * @param {string} name Directory name.
+ * @param {function} successCallback Callback on success.
+ * @param {function} errorCallback Callback on failure.
  */
 DirectoryModel.prototype.createDirectory = function(name, successCallback,
                                                     errorCallback) {
   var self = this;
   function onSuccess(newEntry) {
     self.prefetchCacheForSorting_([newEntry], function() {
       var fileList = self.fileList_;
       var existing = fileList.slice().filter(
           function(e) { return e.name == name; });
 
       if (existing.length) {
         self.selectEntry(name);
         successCallback(existing[0]);
       } else {
-        self.fileListSelection.beginChange();
+        self.fileListSelection_.beginChange();
         fileList.splice(0, 0, newEntry);
         self.selectEntry(name);
-        self.fileListSelection.endChange();
+        self.fileListSelection_.endChange();
         successCallback(newEntry);
       }
     });
   }
 
-  this.currentEntry.getDirectory(name, {create: true, exclusive: true},
-                                 onSuccess, errorCallback);
+  this.currentDirEntry_.getDirectory(name, {create: true, exclusive: true},
+                                     onSuccess, errorCallback);
 };
 
 /**
  * Changes directory. Causes 'directory-change' event.
  *
  * @param {string} path New current directory path.
  * @param {function} opt_OnError Called if failed.
  */
 DirectoryModel.prototype.changeDirectory = function(path, opt_OnError) {
   var onDirectoryResolved = function(dirEntry) {
@@ skipping 36 matching lines @@
  * @private
  * @param {DirectoryEntry} dirEntry The absolute path to the new directory.
  * @param {function} action Action executed if the directory loads
  *    successfully.  By default selects the first item (unless it's a save
  *    dialog).
  * @param {boolean} initial True if it comes from setupPath and
  *                          false if caused by an user action.
  */
 DirectoryModel.prototype.changeDirectoryEntry_ = function(dirEntry, action,
                                                           initial) {
-  var previous = this.currentEntry;
+  var previous = this.currentDirEntry_;
   this.currentDirEntry_ = dirEntry;
   function onRescanComplete() {
     action();
     // For tests that open the dialog to empty directories, everything
     // is loaded at this point.
     chrome.test.sendMessage('directory-change-complete');
   }
   this.updateReadonlyStatus_();
   this.updateVolumeMetadata_();
   this.updateRootsListSelection_();
@@ skipping 124 matching lines @@
   } else {
     this.getDefaultDirectory_(function(defaultDir) {
       baseName = defaultDir;
       root.getDirectory(
           baseName, {create: false}, onBaseFound, onBaseError);
     });
   }
 };
 
 /**
- * @param {function} opt_callback
+ * @param {function} opt_callback Callback on done.
  */
 DirectoryModel.prototype.setupDefaultPath = function(opt_callback) {
   var overridden = false;
-  function onExternalDirChange() { overridden = true }
+  function onExternalDirChange() {
+    overridden = true;
+  }
   this.addEventListener('directory-changed', onExternalDirChange);
 
   this.getDefaultDirectory_(function(path) {
     this.removeEventListener('directory-changed', onExternalDirChange);
     if (!overridden)
       this.setupPath(path, opt_callback);
   }.bind(this));
 };
 
 /**
  * @private
- * @param {function} callback
+ * @param {function(string)} callback Called with the path to directory.
  */
 DirectoryModel.prototype.getDefaultDirectory_ = function(callback) {
   function onGetDirectoryComplete(entries, error) {
     if (entries.length > 0)
       callback(entries[0].fullPath);
     else
       callback('/' + DirectoryModel.DOWNLOADS_DIRECTORY);
   }
 
   // No preset given, find a good place to start.
   // Check for removable devices, if there are none, go to Downloads.
   util.readDirectory(this.root_, DirectoryModel.REMOVABLE_DIRECTORY,
                      onGetDirectoryComplete);
 };
 
 /**
- * @param {string} name
+ * @param {string} name Filename.
  */
 DirectoryModel.prototype.selectEntry = function(name) {
   var dm = this.fileList_;
   for (var i = 0; i < dm.length; i++) {
     if (dm.item(i).name == name) {
       this.selectIndex(i);
       return;
     }
   }
 };
 
 /**
- * @param {number} index
+ * @param {number} index Index of file.
  */
 DirectoryModel.prototype.selectIndex = function(index) {
   // this.focusCurrentList_();
   if (index >= this.fileList_.length)
     return;
 
   // If a list bound with the model it will do scrollIndexIntoView(index).
   this.fileListSelection_.selectedIndex = index;
 };
 
 /**
  * Cache necessary data before a sort happens.
  *
  * This is called by the table code before a sort happens, so that we can
  * go fetch data for the sort field that we may not have yet.
  * @private
- * @param {string} field
- * @param {function} callback
+ * @param {string} field Sort field.
+ * @param {function} callback Called when done.
  */
 DirectoryModel.prototype.prepareSort_ = function(field, callback) {
   this.prepareSortEntries_(this.fileList_.slice(), field, callback);
 };
 
 /**
  * @private
- * @param {Array.<Entry>} entries
- * @param {string} field
- * @param {function} callback
+ * @param {Array.<Entry>} entries Files.
+ * @param {string} field Sort field.
+ * @param {function} callback Called when done.
  */
 DirectoryModel.prototype.prepareSortEntries_ = function(entries, field,
                                                         callback) {
   this.metadataCache_.get(entries, 'filesystem', function(properties) {
     callback();
   });
 };
 
 /**
  * Get root entries asynchronously.
@@ skipping 133 matching lines @@
  */
 DirectoryModel.prototype.updateRootsListSelection_ = function() {
   this.rootsListSelection_.selectedIndex =
       this.findRootsListItem_(this.rootPath);
 };
 
 /**
  * @private
  */
 DirectoryModel.prototype.updateReadonlyStatus_ = function() {
-  switch (this.rootType) {
+  switch (this.getRootType()) {
     case DirectoryModel.RootType.REMOVABLE:
       this.readonly_ = !!this.currentVolumeMetadata_.isReadOnly;
       break;
     case DirectoryModel.RootType.ARCHIVE:
       this.readonly_ = true;
       break;
     case DirectoryModel.RootType.DOWNLOADS:
       this.readonly_ = false;
       break;
     case DirectoryModel.RootType.GDATA:
-      this.readonly_ = this.offline;
+      this.readonly_ = this.offline_;
       break;
     default:
       this.readonly_ = true;
       break;
   }
 };
 
 /**
  * @private
  */
@@ skipping 13 matching lines @@
           }
         });
       });
     }
   }
 };
 
 /**
  * Prepare the root for the unmount.
  *
- * @param {string} rootPath
+ * @param {string} rootPath The path to the root.
  */
 DirectoryModel.prototype.prepareUnmount = function(rootPath) {
   var index = this.findRootsListItem_(rootPath);
   if (index == -1) {
     console.error('Unknown root entry', rootPath);
     return;
   }
   var entry = this.rootsList_.item(index);
 
   // We never need to remove this attribute because even if the unmount fails
   // the onMountCompleted handler calls updateRoots which creates a new entry
   // object for this volume.
   entry.unmounting = true;
 
   // Re-place the entry into the roots data model to force re-rendering.
   this.rootsList_.splice(index, 1, entry);
 
   if (rootPath == this.rootPath) {
     // TODO(kaznacheev): Consider changing to the most recently used root.
     this.changeDirectory('/' + DirectoryModel.DOWNLOADS_DIRECTORY);
   }
 };
 
 /**
- * @param {string} path
+ * @param {string} path Any path.
  * @return {string} The root path.
  */
 DirectoryModel.getRootPath = function(path) {
   var type = DirectoryModel.getRootType(path);
 
   if (type == DirectoryModel.RootType.DOWNLOADS)
     return '/' + DirectoryModel.DOWNLOADS_DIRECTORY;
   if (type == DirectoryModel.RootType.GDATA)
     return '/' + DirectoryModel.GDATA_DIRECTORY;
 
   function subdir(dir) {
     var end = path.indexOf('/', dir.length + 2);
     return end == -1 ? path : path.substr(0, end);
   }
 
   if (type == DirectoryModel.RootType.ARCHIVE)
     return subdir(DirectoryModel.ARCHIVE_DIRECTORY);
   if (type == DirectoryModel.REMOVABLE_DIRECTORY)
     return subdir(DirectoryModel.REMOVABLE_DIRECTORY);
   return '/';
 };
 
 /**
- * @param {string} path
- * @return {string}
+ * @param {string} path Any path.
+ * @return {string} The name of the root.
  */
 DirectoryModel.getRootName = function(path) {
   var root = DirectoryModel.getRootPath(path);
   var index = root.lastIndexOf('/');
   return index == -1 ? root : root.substring(index + 1);
 };
 
 /**
  * @param {string} path Path.

[dgozman, 2012/04/24 10:58:14]

'Any path' for consistency? :)

[Oleg Eterevsky, 2012/04/24 11:03:33]

Changed to "A path".

  * @return {string} A root type.
  */
 DirectoryModel.getRootType = function(path) {
   function isTop(dir) {
     return path.substr(1, dir.length) == dir;
   }
 
   if (isTop(DirectoryModel.DOWNLOADS_DIRECTORY))
     return DirectoryModel.RootType.DOWNLOADS;
   if (isTop(DirectoryModel.GDATA_DIRECTORY))
     return DirectoryModel.RootType.GDATA;
   if (isTop(DirectoryModel.ARCHIVE_DIRECTORY))
     return DirectoryModel.RootType.ARCHIVE;
   if (isTop(DirectoryModel.REMOVABLE_DIRECTORY))
     return DirectoryModel.RootType.REMOVABLE;
   return '';
 };
 
 /**
- * @param {string} path
- * @return {boolean}
+ * @param {string} path A path.
+ * @return {boolean} True if it is a path to the root.
  */
 DirectoryModel.isRootPath = function(path) {
   if (path[path.length - 1] == '/')
     path = path.substring(0, path.length - 1);
   return DirectoryModel.getRootPath(path) == path;
 };
 
 /**
  * @constructor
  * @extends cr.EventTarget
@@ skipping 44 matching lines @@
 /**
  * @private
  */
 DirectoryModel.Scanner.prototype.readNextChunk_ = function() {
   this.reader_.readEntries(this.onChunkComplete_.bind(this),
                            this.errorCallback_);
 };
 
 /**
  * @private
- * @param {Array.<Entry>} entries
+ * @param {Array.<Entry>} entries File list.
  */
 DirectoryModel.Scanner.prototype.onChunkComplete_ = function(entries) {
   if (this.cancelled_)
     return;
 
   if (entries.length == 0) {
     this.successCallback_();
     this.recordMetrics_();
     return;
   }
@@ skipping 19 matching lines @@
 /**
  * @private
  */
 DirectoryModel.Scanner.prototype.recordMetrics_ = function() {
   metrics.recordInterval('DirectoryScan');
   if (this.dir_.fullPath ==
       '/' + DirectoryModel.DOWNLOADS_DIRECTORY) {
     metrics.recordMediumCount('DownloadsCount', this.list_.length);
   }
 };