Dropping files into the root list.

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 35 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.setFilterHidden(true);
 
-  // Readonly status.
-  this.readonly_ = false;
-  this.currentVolumeMetadata_ = {rootPath: '/'};
-  this.offline_ = false;
+  /** @type {Object.<string, boolean>} */
+  this.volumeReadOnlyStatus_ = {};

[Vladislav Kaznacheev, 2012/04/25 11:08:04]

I am concerned that the default value is "false" (not readonly) which means that
before getVolumeMetadata returns the drive is actually writable and we can try
copying something there if we are quick.

[SeRya, 2012/04/25 11:50:53]

This place is not about default values. volumeReadOnlyStatus_ is empty and
rootList_ is empty as well. They both update synchronously so they must be
always consistent.

 }
 
 /**
  * The name of the directory containing externally
  * mounted removable storage volumes.
  */
 DirectoryModel.REMOVABLE_DIRECTORY = 'removable';
 
 /**
  * The name of the directory containing externally
@@ skipping 62 matching lines @@
  * @return {string} Root name.
  */
 DirectoryModel.prototype.getRootName = function() {
   return DirectoryModel.getRootName(this.currentDirEntry_.fullPath);
 };
 
 /**
  * @return {boolean} True if current directory is read only.
  */
 DirectoryModel.prototype.isReadOnly = function() {
-  return this.readonly_;
+  return this.isPathReadOnly(this.getCurrentRootPath());
 };
 
 /**
- * @return {boolean} If offline.
+ * @param {strin} path Path to check.
+ * @return {boolean} True if the |path| is read only.
  */
-DirectoryModel.prototype.isOffline = function() {
-  return this.offline_;
-};
-
-/**
- * @param {boolean} value New online status.
- */
-DirectoryModel.prototype.setOffline = function(value) {
-  if (this.offline_ != value) {
-    this.offline_ = !!value;
-    this.updateReadonlyStatus_();
+DirectoryModel.prototype.isPathReadOnly = function(path) {
+  switch (DirectoryModel.getRootType(path)) {
+    case DirectoryModel.RootType.REMOVABLE:
+      return !!this.volumeReadOnlyStatus_[DirectoryModel.getRootPath(path)];
+    case DirectoryModel.RootType.ARCHIVE:
+      return true;
+    case DirectoryModel.RootType.DOWNLOADS:
+      return false;
+    case DirectoryModel.RootType.GDATA:
+      return !navigator.onLine;
+    default:
+      return true;
   }
 };
 
 /**
  * @return {boolean} If current directory is system.
  */
 DirectoryModel.prototype.isSystemDirectory = function() {
   var path = this.currentDirEntry_.fullPath;
   return path == '/' ||
          path == '/' + DirectoryModel.REMOVABLE_DIRECTORY ||
@@ skipping 532 matching lines @@
 DirectoryModel.prototype.changeDirectoryEntry_ = function(dirEntry, action,
                                                           initial) {
   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_();
   this.scan_(onRescanComplete);
   this.currentDirByRoot_[this.getCurrentRootPath()] = dirEntry.fullPath;
 
   var e = new cr.Event('directory-changed');
   e.previousDirEntry = previous;
   e.newDirEntry = dirEntry;
   e.initial = initial;
   this.dispatchEvent(e);
 };
@@ skipping 185 matching lines @@
  * @param {function(Array.<Entry>)} callback Called when roots are resolved.
  * @param {boolean} resolveGData See comment for updateRoots.
  */
 DirectoryModel.prototype.resolveRoots_ = function(callback, resolveGData) {
   var groups = {
     downloads: null,
     archives: null,
     removables: null,
     gdata: null
   };
+  var self = this;
 
   metrics.startInterval('Load.Roots');
   function done() {
     for (var i in groups)
       if (!groups[i])
         return;
 
+    self.updateVolumeReadOnlyStatus_(groups.removables);
     callback(groups.downloads.
              concat(groups.gdata).
              concat(groups.archives).
              concat(groups.removables));
     metrics.recordInterval('Load.Roots');
   }
 
   function append(index, values, opt_error) {
     groups[index] = values;
     done();
   }
 
   function onDownloads(entry) {
     groups.downloads = [entry];
     done();
   }
 
   function onDownloadsError(error) {
     groups.downloads = [];
     done();
   }
 
-  var self = this;
-
   function onGData(entry) {
     console.log('GData found:', entry);
     self.unmountedGDataEntry_ = null;
     groups.gdata = [entry];
     done();
   }
 
   function onGDataError(error) {
     console.log('GData error: ', error);
     self.unmountedGDataEntry_ = {
@@ skipping 78 matching lines @@
 
 /**
  * @private
  */
 DirectoryModel.prototype.updateRootsListSelection_ = function() {
   var rootPath = DirectoryModel.getRootPath(this.currentDirEntry_.fullPath);
   this.rootsListSelection_.selectedIndex = this.findRootsListItem_(rootPath);
 };
 
 /**
+ * @param {Array.<DirectoryEntry>} roots Removable volumes entries.
  * @private
  */
-DirectoryModel.prototype.updateReadonlyStatus_ = function() {
-  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_;
-      break;
-    default:
-      this.readonly_ = true;
-      break;
+DirectoryModel.prototype.updateVolumeReadOnlyStatus_ = function(roots) {
+  var status = this.volumeReadOnlyStatus_ = {};
+  for (var i = 0; i < roots.length; i++) {
+    status[roots[i].fullPath] = false;

[Vladislav Kaznacheev, 2012/04/25 11:08:04]

How about setting 'true' originally? 

[SeRya, 2012/04/25 11:50:53]

I would vote for 'false' because:
1. It better works in testing environment where getVolumeMetadata doesn't work.
2. In case something goes wrong it's better to let the user to perform
operations on an readonly volume and get an error then stop the user from
performing operations on a writable volume.

+    chrome.fileBrowserPrivate.getVolumeMetadata(roots[i].toURL(),
+        function(systemMetadata, path) {
+          status[path] = !!(systemMetadata && systemMetadata.isReadOnly);
+        }.bind(null, roots[i].fullPath));
   }
 };
 
-/**
- * @private
- */
-DirectoryModel.prototype.updateVolumeMetadata_ = function() {
-  var rootPath = this.getCurrentRootPath();
-  if (this.currentVolumeMetadata_.rootPath != rootPath) {
-    var metadata = this.currentVolumeMetadata_ = {rootPath: rootPath};
-    if (DirectoryModel.getRootType(rootPath) ==
-        DirectoryModel.RootType.REMOVABLE) {
-      var self = this;
-      this.root_.getDirectory(rootPath, {}, function(entry) {
-        chrome.fileBrowserPrivate.getVolumeMetadata(entry.toURL(),
-            function(systemMetadata) {
-          if (systemMetadata) {
-            metadata.isReadOnly = systemMetadata.isReadOnly;
-            self.updateReadonlyStatus_();
-          }
-        });
-      });
-    }
-  }
-};
-
 /**
  * Prepare the root for the unmount.
  *
  * @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;
@@ skipping 168 matching lines @@
 /**
  * @private
  */
 DirectoryModel.Scanner.prototype.recordMetrics_ = function() {
   metrics.recordInterval('DirectoryScan');
   if (this.dir_.fullPath ==
       '/' + DirectoryModel.DOWNLOADS_DIRECTORY) {
     metrics.recordMediumCount('DownloadsCount', this.list_.length);
   }
 };