1. Fix JSDocs in directory_model.js.

chrome/browser/resources/file_manager/js/file_manager.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.
 
 /**
  * FileManager constructor.
  *
  * FileManager objects encapsulate the functionality of the file selector
  * dialogs, as well as the full screen file manager application (though the
  * latter is not yet implemented).
@@ skipping 488 matching lines @@
       this.setupCurrentDirectory_(
           invokeHandler, true /* blankWhileOpeningAFile */);
     }
 
     this.summarizeSelection_();
 
     var sortField =
         window.localStorage['sort-field-' + this.dialogType_] || 'cachedMtime_';
     var sortDirection =
         window.localStorage['sort-direction-' + this.dialogType_] || 'desc';
-    this.directoryModel_.fileList.sort(sortField, sortDirection);
+    this.directoryModel_.sortFileList(sortField, sortDirection);
 
     this.refocus();
 
     this.metadataProvider_ =
         new MetadataProvider(this.filesystem_.root.toURL());
 
     // PyAuto tests monitor this state by polling this variable
     this.__defineGetter__('workerInitialized_', function() {
        return self.getMetadataProvider().isInitialized();
     });
 
-    this.directoryModel_.offline = this.isOffline();
+    this.directoryModel_.setOffline(this.isOffline());
 
     if (this.dialogType_ == FileManager.DialogType.FULL_PAGE)
       this.initDataTransferOperations_();
 
     this.table_.endBatchUpdates();
     this.grid_.endBatchUpdates();
 
     metrics.recordInterval('Load.DOM');
     metrics.recordInterval('Load.Total');
   };
 
   FileManager.prototype.initDataTransferOperations_ = function() {
     this.copyManager_ = new FileCopyManager(this.filesystem_.root);
     this.copyManager_.addEventListener('copy-progress',
                                        this.onCopyProgress_.bind(this));
     this.copyManager_.addEventListener('copy-operation-complete',
         this.onCopyManagerOperationComplete_.bind(this));
 
     var controller = this.fileTransferController_ = new FileTransferController(
-        this.directoryModel_.fileList,
-        this.directoryModel_.fileListSelection,
+        this.directoryModel_.getFileList(),
+        this.directoryModel_.getFileListSelection(),
         GridItem.bind(null, this),
         this.copyManager_,
         this.directoryModel_);
     controller.attachDragSource(this.table_.list);
     controller.attachDropTarget(this.table_.list);
     controller.attachDragSource(this.grid_);
     controller.attachDropTarget(this.grid_);
     controller.attachCopyPasteHandlers(this.document_);
     controller.addEventListener('selection-copied',
         this.blinkSelection.bind(this));
@@ skipping 160 matching lines @@
         this.dialogType_ == FileManager.DialogType.SELECT_OPEN_FILE ||
         this.dialogType_ == FileManager.DialogType.SELECT_FOLDER ||
         this.dialogType_ == FileManager.DialogType.SELECT_SAVEAS_FILE;
 
     this.directoryModel_ = new DirectoryModel(
         this.filesystem_.root,
         sigleSelection,
         str('ENABLE_GDATA') == '1',
         this.metadataCache_);
 
-    var dataModel = this.directoryModel_.fileList;
+    var dataModel = this.directoryModel_.getFileList();
     var collator = this.collator_;
     // TODO(dgozman): refactor comparison functions together with
     // render/update/display.
     dataModel.setCompareFunction('name', function(a, b) {
       return collator.compare(a.name, b.name);
     });
     dataModel.setCompareFunction('modificationTime',
                                  this.compareMtime_.bind(this));
     dataModel.setCompareFunction('size',
                                  this.compareSize_.bind(this));
     dataModel.setCompareFunction('type',
                                  this.compareType_.bind(this));
 
     dataModel.addEventListener('splice',
                                this.onDataModelSplice_.bind(this));
     dataModel.addEventListener('permuted',
                                this.onDataModelPermuted_.bind(this));
 
-    this.directoryModel_.fileListSelection.addEventListener(
+    this.directoryModel_.getFileListSelection().addEventListener(
         'change', this.onSelectionChanged_.bind(this));
 
-    this.directoryModel_.autoSelectIndex =
-        this.dialogType_ == FileManager.DialogType.SELECT_SAVEAS_FILE ? -1 : 0;
+    this.directoryModel_.setAutoSelectIndex(
+        this.dialogType_ == FileManager.DialogType.SELECT_SAVEAS_FILE ? -1 : 0);
 
     this.initTable_();
     this.initGrid_();
     this.initRootsList_();
 
     var listType = FileManager.ListType.DETAIL;
     if (FileManager.DialogType.isModal(this.dialogType_))
       listType = window.localStorage['listType-' + this.dialogType_] ||
           FileManager.ListType.DETAIL;
     this.setListType(listType);
@@ skipping 120 matching lines @@
     learnMore.appendChild(learnMoreLink);
   };
 
   FileManager.prototype.onDataModelSplice_ = function(event) {
     var checkbox = this.document_.querySelector('#select-all-checkbox');
     if (checkbox)
       this.updateSelectAllCheckboxState_(checkbox);
   };
 
   FileManager.prototype.onDataModelPermuted_ = function(event) {
-    var sortStatus = this.directoryModel_.fileList.sortStatus;
+    var sortStatus = this.directoryModel_.getFileList().sortStatus;
     window.localStorage['sort-field-' + this.dialogType_] = sortStatus.field;
     window.localStorage['sort-direction-' + this.dialogType_] =
         sortStatus.direction;
   };
 
   /**
    * Compare by mtime first, then by name.
    */
   FileManager.prototype.compareMtime_ = function(a, b) {
     var aTime = this.metadataCache_.getCached(a, 'filesystem').modificationTime;
@@ skipping 251 matching lines @@
       window.localStorage['listType-' + this.dialogType_] = type;
 
     this.table_.list.startBatchUpdates();
     this.grid_.startBatchUpdates();
 
     // TODO(dzvorygin): style.display and dataModel setting order shouldn't
     // cause any UI bugs. Currently, the only right way is first to set display
     // style and only then set dataModel.
 
     if (type == FileManager.ListType.DETAIL) {
-      this.table_.dataModel = this.directoryModel_.fileList;
-      this.table_.selectionModel = this.directoryModel_.fileListSelection;
+      this.table_.dataModel = this.directoryModel_.getFileList();
+      this.table_.selectionModel = this.directoryModel_.getFileListSelection();
       this.table_.style.display = '';
       this.grid_.style.display = 'none';
       this.grid_.selectionModel = this.emptySelectionModel_;
       this.grid_.dataModel = this.emptyDataModel_;
       this.table_.style.display = '';
       /** @type {cr.ui.List} */
       this.currentList_ = this.table_.list;
       this.dialogDom_.querySelector('div.detail-view')
           .setAttribute('disabled', 'disabled');
       this.dialogDom_.querySelector('div.thumbnail-view')
           .removeAttribute('disabled');
     } else if (type == FileManager.ListType.THUMBNAIL) {
-      this.grid_.dataModel = this.directoryModel_.fileList;
-      this.grid_.selectionModel = this.directoryModel_.fileListSelection;
+      this.grid_.dataModel = this.directoryModel_.getFileList();
+      this.grid_.selectionModel = this.directoryModel_.getFileListSelection();
       this.grid_.style.display = '';
       this.table_.style.display = 'none';
       this.table_.selectionModel = this.emptySelectionModel_;
       this.table_.dataModel = this.emptyDataModel_;
       this.grid_.style.display = '';
       /** @type {cr.ui.List} */
       this.currentList_ = this.grid_;
       this.dialogDom_.querySelector('div.thumbnail-view')
           .setAttribute('disabled', 'disabled');
       this.dialogDom_.querySelector('div.detail-view')
@@ skipping 162 matching lines @@
       }
     }
   };
 
   /**
    * Handler of file manager operations. Update directory model
    * to reflect operation result iimediatelly (not waiting directory
    * update event).
    */
   FileManager.prototype.onCopyManagerOperationComplete_ = function(event) {
-    var currentPath = this.directoryModel_.currentEntry.fullPath;
+    var currentPath = this.directoryModel_.getCurrentDirEntry().fullPath;
     function inCurrentDirectory(entry) {
       var fullPath = entry.fullPath;
       var dirPath = fullPath.substr(0, fullPath.length -
                                        entry.name.length - 1);
       return dirPath == currentPath;
     }
     for (var i = 0; i < event.affectedEntries.length; i++) {
       entry = event.affectedEntries[i];
       if (inCurrentDirectory(entry))
         this.directoryModel_.onEntryChanged(entry.name);
@@ skipping 53 matching lines @@
   };
 
   /**
    * Respond to the back and forward buttons.
    */
   FileManager.prototype.onPopState_ = function(event) {
     this.closeFilePopup_();
     // Nothing left to do if the current directory is not changing. This happens
     // if we are exiting the Gallery.
     if (this.getPathFromUrlOrParams_() ==
-        this.directoryModel_.currentEntry.fullPath)
+        this.directoryModel_.getCurrentDirEntry().fullPath)
       return;
     this.setupCurrentDirectory_(true /* invokeHandler */);
   };
 
   FileManager.prototype.requestResize_ = function(timeout) {
     setTimeout(this.onResize_.bind(this), timeout || 0);
   };
 
   /**
    * Resize details and thumb views to fit the new window size.
@@ skipping 229 matching lines @@
     var fragment = this.document_.createDocumentFragment();
     fragment.appendChild(input);
     fragment.appendChild(this.document_.createTextNode(name));
     return fragment;
   };
 
   /**
    * Update check and disable states of the 'Select all' checkbox.
    */
   FileManager.prototype.updateSelectAllCheckboxState_ = function(checkbox) {
-    var dm = this.directoryModel_.fileList;
+    var dm = this.directoryModel_.getFileList();
     checkbox.checked = this.selection && dm.length > 0 &&
                        dm.length == this.selection.totalCount;
     checkbox.disabled = dm.length == 0;
   };
 
   /**
    * Update the thumbnail image to fit/fill the square container.
    *
    * Using webkit center packing does not align the image properly, so we need
    * to wait until the image loads and its proportions are known, then manually
@@ skipping 246 matching lines @@
    * Render filename label for grid and list view.
    * @param {Entry} entry The Entry object to render.
    * @return {HTMLDivElement} The label.
    */
   FileManager.prototype.renderFileNameLabel_ = function(entry) {
     // Filename need to be in a '.filename-label' container for correct
     // work of inplace renaming.
     var fileName = this.document_.createElement('div');
     fileName.className = 'filename-label';
 
-    fileName.textContent = this.directoryModel_.currentEntry.name == '' ?
-        this.getRootLabel_(entry.name) : entry.name;
+    fileName.textContent =
+        this.directoryModel_.getCurrentDirEntry().name == '' ?
+            this.getRootLabel_(entry.name) : entry.name;
     return fileName;
   };
 
   /**
    * Render the Size column of the detail table.
    *
    * @param {Entry} entry The Entry object to render.
    * @param {string} columnId The id of the column to be rendered.
    * @param {cr.ui.Table} table The table doing the rendering.
    */
@@ skipping 73 matching lines @@
   };
 
   FileManager.prototype.updateDate_ = function(div, entry) {
     div.textContent = '...';
     this.displayDateInDiv_(
         div, this.metadataCache_.getCached(entry, 'filesystem'));
   };
 
   FileManager.prototype.displayDateInDiv_ = function(div, filesystemProps) {
     if (!filesystemProps) return;
-    if (this.directoryModel_.isSystemDirectoy &&
+    if (this.directoryModel_.isSystemDirectory() &&
         filesystemProps.modificationTime.getTime() == 0) {
       // Mount points for FAT volumes have this time associated with them.
       // We'd rather display nothing than this bogus date.
       div.textContent = '';
     } else {
       div.textContent =
           this.shortDateFormatter_.format(filesystemProps.modificationTime);
     }
   };
 
@@ skipping 15 matching lines @@
         if (entry.gdata_.isHosted)
           return;
         checkbox.checked = entry.gdata_.isPinned;
         div.appendChild(checkbox);
       });
     }
     return div;
   };
 
   FileManager.prototype.refreshCurrentDirectoryMetadata_ = function() {
-    var entries = this.directoryModel_.fileList.slice();
+    var entries = this.directoryModel_.getFileList().slice();
     this.metadataCache_.clear(entries, 'filesystem');
     // We don't pass callback here. When new metadata arrives, we have an
     // observer registered to update the UI.
     this.metadataCache_.get(entries, 'filesystem', null);
   };
 
   FileManager.prototype.updateFilesystemPropertiesInUI_ = function(
       urls, properties) {
     if (this.listType_ != FileManager.ListType.DETAIL) return;
 
     var items = {};
-    var dm = this.directoryModel_.fileList;
+    var dm = this.directoryModel_.getFileList();
     for (var index = 0; index < dm.length; index++) {
       var listItem = this.currentList_.getListItemByIndex(index);
       if (!listItem) continue;
       var entry = dm.item(index);
       items[entry.toURL()] = listItem;
     }
 
     for (var index = 0; index < urls.length; index++) {
       var url = urls[index];
       if (!(url in items)) continue;
@@ skipping 11 matching lines @@
    *
    * While refreshing file list it gets repopulated with new file entries.
    * There is not a big difference wether DOM items stay the same or not.
    * Except for the item that the user is renaming.
    */
   FileManager.prototype.restoreItemBeingRenamed_ = function() {
     if (!this.isRenamingInProgress())
       return;
 
     var dm = this.directoryModel_;
-    var leadIndex = dm.fileListSelection.leadIndex;
+    var leadIndex = dm.getFileListSelection().leadIndex;
     if (leadIndex < 0)
       return;
 
-    var leadEntry = dm.fileList.item(leadIndex);
+    var leadEntry = dm.getFileList().item(leadIndex);
     if (this.renameInput_.currentEntry.fullPath != leadEntry.fullPath)
       return;
 
     var leadListItem = this.findListItemForNode_(this.renameInput_);
     if (this.currentList_ == this.table_.list) {
       this.updateType_(leadListItem.querySelector('.type'), leadEntry);
       this.updateDate_(leadListItem.querySelector('.date'), leadEntry);
       this.updateSize_(leadListItem.querySelector('.size'), leadEntry);
     }
     this.currentList_.restoreLeadItem(leadListItem);
@@ skipping 48 matching lines @@
       }
     }
 
     function onThumbnailLoaded() {
       thumbnailLoaded++;
       if (thumbnailLoaded == thumbnailCount)
         showThumbnails();
     }
 
     for (var i = 0; i < selection.indexes.length; i++) {
-      var entry = this.directoryModel_.fileList.item(selection.indexes[i]);
+      var entry = this.directoryModel_.getFileList().item(selection.indexes[i]);
       if (!entry)
         continue;
 
       selection.entries.push(entry);
       selection.urls.push(entry.toURL());
 
       if (thumbnailCount < MAX_PREVIEW_THUMBAIL_COUNT) {
         var box = this.document_.createElement('div');
         function imageLoadCalback(index, box, img, transform) {
           if (index == 0)
@@ skipping 399 matching lines @@
   };
 
   FileManager.prototype.onOnlineOffline_ = function() {
     if (this.isOffline()) {
       console.log('OFFLINE');
       this.dialogContainer_.setAttribute('offline', true);
     } else {
       console.log('ONLINE');
       this.dialogContainer_.removeAttribute('offline');
     }
-    this.directoryModel_.offline = this.isOffline();
+    this.directoryModel_.setOffline(this.isOffline());
   };
 
   FileManager.prototype.isOnGDataOffline = function() {
     return this.isOnGData() && this.isOffline();
   };
 
   FileManager.prototype.isOnReadonlyDirectory = function() {
-    return this.directoryModel_.readonly;
+    return this.directoryModel_.isReadOnly();
   };
 
   /**
    * Event handler called when some volume was mounted or unmouted.
    */
   FileManager.prototype.onMountCompleted_ = function(event) {
     var self = this;
 
     var changeDirectoryTo = null;
 
     if (event && event.mountType == 'gdata') {
       metrics.recordInterval('Load.GData');
       console.log('GData mounted');
       if (event.status == 'success') {
         this.gdataMounted_ = true;
         this.gdataMountInfo_ = {
           'mountPath': event.mountPath,
           'sourceUrl': event.sourceUrl,
           'mountType': event.mountType,
           'mountCondition': event.status
         };
         // Not calling clearGDataLoadingTimer_ here because we want to keep
         // "Loading Google Docs" message until the directory loads. It is OK if
         // the timer fires after the mount because onDirectoryChanged_ will hide
         // the unmounted panel.
         if (this.setupCurrentDirectoryPostponed_) {
           this.setupCurrentDirectoryPostponed_(false /* execute */);
         } else if (this.isOnGData() &&
-                   this.directoryModel_.currentEntry.unmounted) {
+                   this.directoryModel_.getCurrentDirEntry().unmounted) {
           // We are currently on an unmounted GData directory, force a rescan.
           changeDirectoryTo = this.directoryModel_.getCurrentRootPath();
         }
       } else {
         this.gdataMounted_ = false;
         this.gdataMountInfo_ = null;
         this.clearGDataLoadingTimer_();
         this.onGDataUnreachable_('GData mount failed: ' + event.status);
         if (this.setupCurrentDirectoryPostponed_) {
           this.setupCurrentDirectoryPostponed_(true /* cancel */);
@@ skipping 119 matching lines @@
   FileManager.prototype.closeFilePopup_ = function() {
     if (this.filePopup_) {
       this.dialogDom_.removeChild(this.filePopup_);
       this.filePopup_ = null;
       this.refocus();
     }
   };
 
   FileManager.prototype.getAllUrlsInCurrentDirectory_ = function() {
     var urls = [];
-    var dm = this.directoryModel_.fileList;
-    for (var i = 0; i != dm.length; i++) {
-      urls.push(dm.item(i).toURL());
+    var fileList = this.directoryModel_.getFileList();
+    for (var i = 0; i != fileList.length; i++) {
+      urls.push(fileList.item(i).toURL());
     }
     return urls;
   };
 
   FileManager.prototype.getShareActions_ = function(urls, callback) {
     chrome.fileBrowserPrivate.getFileTasks(urls, function(tasks) {
       var shareActions = [];
       for (var index = 0; index < tasks.length; index++) {
         var task = tasks[index];
         if (task.taskId != this.getExtensionId_() + '|gallery') {
@@ skipping 23 matching lines @@
       // in the ribbon.
       // We do not do that if a single video is selected because the UI is
       // cleaner without the ribbon.
       urls = this.getAllUrlsInCurrentDirectory_().filter(
           FileType.isImageOrVideo);
     } else {
       // Pass just the selected items, select the first entry.
       selectedUrl = urls[0];
     }
 
-    var dirPath = this.directoryModel_.currentEntry.fullPath;
+    var dirPath = this.directoryModel_.getCurrentDirEntry().fullPath;
 
     // Push a temporary state which will be replaced every time an individual
     // item is selected in the Gallery.
     this.updateLocation_(false /*push*/, dirPath);
 
     galleryFrame.onload = function() {
       galleryFrame.contentWindow.ImageUtil.metrics = metrics;
       galleryFrame.contentWindow.FileType = FileType;
       galleryFrame.contentWindow.util = util;
 
       // Gallery shoud treat GData folder as readonly even when online
       // until we learn to save files directly to GData.
       var readonly = self.isOnReadonlyDirectory() || self.isOnGData();
-      var currentDir = self.directoryModel_.currentEntry;
+      var currentDir = self.directoryModel_.getCurrentDirEntry();
       var downloadsDir = self.directoryModel_.getRootsList().item(0);
 
       var gallerySelection;
       var context = {
         // We show the root label in readonly warning (e.g. archive name).
         readonlyDirName:
             readonly ?
                 (self.isOnGData() ?
                     self.getRootLabel_(currentDir.fullPath) :
-                    self.directoryModel_.rootName) :
+                    self.directoryModel_.getRootName()) :
                 null,
         saveDirEntry: readonly ? downloadsDir : currentDir,
         metadataProvider: self.getMetadataProvider(),
         getShareActions: self.getShareActions_.bind(self),
         onNameChange: function(name) {
           self.document_.title = gallerySelection = name;
           self.updateLocation_(true /*replace*/, dirPath + '/' + name);
         },
         onClose: function() {
           if (singleSelection)
@@ skipping 10 matching lines @@
   };
 
   /**
    * Update the breadcrumb display to reflect the current directory.
    */
   FileManager.prototype.updateBreadcrumbs_ = function() {
     var bc = this.dialogDom_.querySelector('.breadcrumbs');
     removeChildren(bc);
 
     var rootPath = this.directoryModel_.getCurrentRootPath();
-    var relativePath = this.directoryModel_.currentEntry.fullPath.
+    var relativePath = this.directoryModel_.getCurrentDirEntry().fullPath.
                        substring(rootPath.length).replace(/\/$/, '');
 
     var pathNames = relativePath.replace(/\/$/, '').split('/');
     if (pathNames[0] == '')
       pathNames.splice(0, 1);
 
     // We need a first breadcrumb for root, so placing last name from
     // rootPath as first name of relativePath.
     var rootPathNames = rootPath.replace(/\/$/, '').split('/');
     pathNames.splice(0, 0, rootPathNames[rootPathNames.length - 1]);
@@ skipping 153 matching lines @@
       this.table_.focus();
     else  // this.listType_ == FileManager.ListType.THUMBNAIL)
       this.grid_.focus();
   };
 
   /**
    * Return full path of the current directory or null.
    */
   FileManager.prototype.getCurrentDirectory = function() {
     return this.directoryModel_ &&
-        this.directoryModel_.currentEntry.fullPath;
+        this.directoryModel_.getCurrentDirEntry().fullPath;
   };
 
   /**
    * Return URL of the current directory or null.
    */
   FileManager.prototype.getCurrentDirectoryURL = function() {
     return this.directoryModel_ &&
-        this.directoryModel_.currentEntry.toURL();
+        this.directoryModel_.getCurrentDirEntry().toURL();
   };
 
   FileManager.prototype.deleteEntries = function(entries, force, opt_callback) {
     if (!force) {
       var self = this;
       var msg;
       if (entries.length == 1) {
         msg = strf('CONFIRM_DELETE_ONE', entries[0].name);
       } else {
         msg = strf('CONFIRM_DELETE_SOME', entries.length);
@@ skipping 75 matching lines @@
   /**
    * Handle a click event on a breadcrumb element.
    *
    * @param {Event} event The click event.
    */
   FileManager.prototype.onBreadcrumbClick_ = function(event) {
     this.directoryModel_.changeDirectory(event.srcElement.path);
   };
 
   FileManager.prototype.onCheckboxClick_ = function(event) {
-    var sm = this.directoryModel_.fileListSelection;
+    var sm = this.directoryModel_.getFileListSelection();
     var listItem = this.findListItemForEvent_(event);
     sm.setIndexSelected(listItem.listIndex, event.target.checked);
   };
 
   FileManager.prototype.onPinClick_ = function(checkbox, entry, event) {
     var self = this;
     function callback(props) {
       if (props.errorCode) {
         // TODO(serya): Do not show the message if unpin failed.
         self.metadataCache_.get(entry, 'filesystem', function(filesystem) {
@@ skipping 249 matching lines @@
 
     this.checkFreeSpace_(this.getCurrentDirectory());
 
     // TODO(dgozman): title may be better than this.
     this.document_.title = this.getCurrentDirectory().substr(1);
 
     if (this.metadataObserverId_)
       this.metadataCache_.removeObserver(this.metadataObserverId_);
 
     this.metadataObserverId_ = this.metadataCache_.addObserver(
-        this.directoryModel_.currentEntry,
+        this.directoryModel_.getCurrentDirEntry(),
         MetadataCache.CHILDREN,
         'filesystem',
         this.updateFilesystemPropertiesInUI_.bind(this));
 
     var self = this;
 
     if (this.watchedDirectoryUrl_) {
       if (this.watchedDirectoryUrl_ != event.previousDirEntry.toURL()) {
         console.warn('event.previousDirEntry does not match File Manager state',
             event, this.watchedDirectoryUrl_);
@@ skipping 215 matching lines @@
 
   FileManager.prototype.showSpinner_ = function(on) {
     this.cancelSpinnerTimeout_();
     this.spinner_.style.display = on ? '' : 'none';
   };
 
   FileManager.prototype.onNewFolderCommand_ = function(event) {
     var defaultName = str('DEFAULT_NEW_FOLDER_NAME');
 
     // Find a name that doesn't exist in the data model.
-    var files = this.directoryModel_.fileList;
+    var files = this.directoryModel_.getFileList();
     var hash = {};
     for (var i = 0; i < files.length; i++) {
       var name = files.item(i).name;
       // Filtering names prevents from conflicts with prototype's names
       // and '__proto__'.
       if (name.substring(0, defaultName.length) == defaultName)
         hash[name] = 1;
     }
 
     var baseName = defaultName;
@@ skipping 52 matching lines @@
    */
   FileManager.prototype.onKeyDown_ = function(event) {
     if (event.srcElement === this.renameInput_) {
       // Ignore keydown handler in the rename input box.
       return;
     }
 
     switch (util.getKeyModifiers(event) + event.keyCode) {
       case 'Ctrl-190':  // Ctrl-. => Toggle filter files.
         var dm = this.directoryModel_;
-        dm.filterHidden = !dm.filterHidden;
+        dm.setFilterHidden(!dm.getFilterHidden());
         event.preventDefault();
         return;
 
       case '27':  // Escape => Cancel dialog.
         if (this.copyManager_ &&
             this.copyManager_.getStatus().totalFiles != 0) {
           // If there is a copy in progress, ESC will cancel it.
           event.preventDefault();
           this.copyManager_.requestCancel();
           return;
@@ skipping 133 matching lines @@
 
   /**
    * Performs a 'text search' - selects a first list entry with name
    * starting with entered text (case-insensitive).
    */
   FileManager.prototype.doTextSearch_ = function() {
     var text = this.textSearchState_.text;
     if (!text)
       return;
 
-    var dm = this.directoryModel_.fileList;
+    var dm = this.directoryModel_.getFileList();
     for (var index = 0; index < dm.length; ++index) {
       var name = dm.item(index).name;
       if (name.substring(0, text.length).toLowerCase() == text) {
         this.currentList_.selectionModel.selectedIndexes = [index];
         return;
       }
     }
 
     this.textSearchState_.text = '';
   };
@@ skipping 220 matching lines @@
 
     var files = [];
     var selectedIndexes = this.currentList_.selectionModel.selectedIndexes;
 
     // All other dialog types require at least one selected list item.
     // The logic to control whether or not the ok button is enabled should
     // prevent us from ever getting here, but we sanity check to be sure.
     if (!selectedIndexes.length)
       throw new Error('Nothing selected!');
 
-    var dm = this.directoryModel_.fileList;
+    var dm = this.directoryModel_.getFileList();
     for (var i = 0; i < selectedIndexes.length; i++) {
       var entry = dm.item(selectedIndexes[i]);
       if (!entry) {
         console.log('Error locating selected file at index: ' + i);
         continue;
       }
 
       files.push(currentDirUrl + encodeURIComponent(entry.name));
     }
 
@@ skipping 45 matching lines @@
   FileManager.prototype.validateFileName_ = function(name, opt_onDone) {
     var onDone = opt_onDone || function() {};
     var msg;
     var testResult = /[\/\\\<\>\:\?\*\"\|]/.exec(name);
     if (testResult) {
       msg = strf('ERROR_INVALID_CHARACTER', testResult[0]);
     } else if (/^\s*$/i.test(name)) {
       msg = str('ERROR_WHITESPACE_NAME');
     } else if (/^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$/i.test(name)) {
       msg = str('ERROR_RESERVED_NAME');
-    } else if (this.directoryModel_.filterHidden && name[0] == '.') {
+    } else if (this.directoryModel_.getFilterHidden() && name[0] == '.') {
       msg = str('ERROR_HIDDEN_NAME');
     }
 
     if (msg) {
       this.alert.show(msg, onDone);
       return false;
     }
 
     onDone();
     return true;
@@ skipping 107 matching lines @@
 
       handleSplitterDragEnd: function(e) {
         Splitter.prototype.handleSplitterDragEnd.apply(this, arguments);
         this.ownerDocument.documentElement.classList.remove('col-resize');
       }
     };
 
     customSplitter.decorate(splitterElement);
   };
 })();