Rename DriveProvider to ExternalProvider.

ui/file_manager/gallery/js/gallery_item.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.
 
 'use strict';
 
 /**
  * Object representing an image item (a photo).
  *
  * @param {FileEntry} entry Image entry.
- * @param {function():Promise} fethcedMediaProvider Function to provide the
- *     fetchedMedia metadata.
+ * @param {EntryLocation} locationInfo Entry location information.
+ * @param {Object} metadata Metadata for the entry.
+ * @param {MetadataCache} metadataCache Metadata cache instance.
  * @param {boolean} original Whether the entry is original or edited.
- * @param {boolean} readonly Whether the entry is located at readonly directory
- *     or not.
  * @constructor
  */
-Gallery.Item = function(entry, metadata, metadataCache, original, readonly) {
+Gallery.Item = function(
+    entry, locationInfo, metadata, metadataCache, original) {
   /**
    * @type {FileEntry}
    * @private
    */
   this.entry_ = entry;
 
   /**
+   * @type {EntryLocation}
+   * @private
+   */
+  this.locationInfo_ = locationInfo;
+
+  /**
    * @type {Object}
    * @private
    */
   this.metadata_ = Object.freeze(metadata);
 
   /**
    * @type {MetadataCache}
    * @private
    */
   this.metadataCache_ = metadataCache;
@@ skipping 18 matching lines @@
   /**
    * Last accessed date to be used for selecting items whose cache are evicted.
    * @type {number}
    */
   this.lastAccessed_ = Date.now();
 
   /**
    * @type {boolean}
    * @private
    */
-  this.isReadOnly_ = readonly;
-
-  /**
-   * @type {boolean}
-   * @private
-   */
   this.original_ = original;
 
   Object.seal(this);
 };
 
 /**
  * @return {FileEntry} Image entry.
  */
 Gallery.Item.prototype.getEntry = function() { return this.entry_; };
 
 /**
+ * @return {EntryLocation} Entry location information.
+ */
+Gallery.Item.prototype.getLocationInfo = function() {
+  return this.locationInfo_;
+};
+
+/**
  * @return {Object} Metadata.
  */
 Gallery.Item.prototype.getMetadata = function() { return this.metadata_; };
 
 /**
  * Obtains the latest media metadata.
  *
  * This is a heavy operation since it forces to load the image data to obtain
  * the metadata.
  * @return {Promise} Promise to be fulfilled with fetched metadata.
@@ skipping 26 matching lines @@
 Gallery.Item.prototype.getFileName = function() {
   return this.entry_.name;
 };
 
 /**
  * @return {boolean} True if this image has not been created in this session.
  */
 Gallery.Item.prototype.isOriginal = function() { return this.original_; };
 
 /**
- * @return {boolean} Whther the item is located at a readonly directory.
- */
-Gallery.Item.prototype.isReadOnly = function() {
-   return this.isReadOnly_;
-};
-
-/**
- * Obtains the item is on the drive volume or not.
- * @return {boolean} True if the item is on the drive volume.
- */
-Gallery.Item.prototype.isOnDrive = function() {
-  return !!this.metadata_.drive;
-};
-
-/**
  * Obtains the last accessed date.
  * @return {number} Last accessed date.
  */
 Gallery.Item.prototype.getLastAccessedDate = function() {
   return this.lastAccessed_;
 };
 
 /**
  * Updates the last accessed date.
  */
 Gallery.Item.prototype.touch = function() {
   this.lastAccessed_ = Date.now();
 };
 
-
 // TODO: Localize?
 /**
  * @type {string} Suffix for a edited copy file name.
  */
 Gallery.Item.COPY_SIGNATURE = ' - Edited';
 
 /**
  * Regular expression to match '... - Edited'.
  * @type {RegExp}
  */
@@ skipping 59 matching lines @@
 
     dirEntry.getFile(name + ext, {create: false, exclusive: false},
         tryNext.bind(null, tries - 1),
         callback.bind(null, name + ext));
   }
 
   tryNext(10);
 };
 
 /**
- * Writes the new item content to the file.
+ * Writes the new item content to either the existing or a new file.
  *
- * @param {DirectoryEntry} fallbackDir If the entry is readonly, the edited
- *     image is saved to the directory.
- * @param {boolean} overwrite True if overwrite, false if copy.
+ * @param {VolumeManager} volumeManager Volume manager instance.
+ * @param {string} fallbackDir Fallback directory in case the current directory
+ *     is read only.
  * @param {HTMLCanvasElement} canvas Source canvas.
  * @param {ImageEncoder.MetadataEncoder} metadataEncoder MetadataEncoder.
  * @param {function(boolean)=} opt_callback Callback accepting true for success.
  */
 Gallery.Item.prototype.saveToFile = function(
-    fallbackDir, overwrite, canvas, metadataEncoder, opt_callback) {
+    volumeManager, fallbackDir, overwrite, canvas, metadataEncoder,
+    opt_callback) {
   ImageUtil.metrics.startInterval(ImageUtil.getMetricName('SaveTime'));
 
   var name = this.getFileName();
 
-  var onSuccess = function(entry) {
+  var onSuccess = function(entry, locationInfo) {
     ImageUtil.metrics.recordEnum(ImageUtil.getMetricName('SaveResult'), 1, 2);
     ImageUtil.metrics.recordInterval(ImageUtil.getMetricName('SaveTime'));
+
     this.entry_ = entry;
-    this.isReadOnly_ = false;
+    this.locationInfo_ = locationInfo;
+
     this.metadataCache_.clear([this.entry_], 'fetchedMedia');
     if (opt_callback)
       opt_callback(true);
   }.bind(this);
 
-  function onError(error) {
+  var onError = function(error) {
     console.error('Error saving from gallery', name, error);
     ImageUtil.metrics.recordEnum(ImageUtil.getMetricName('SaveResult'), 0, 2);
     if (opt_callback)
       opt_callback(false);
   }
 
-  function doSave(newFile, fileEntry) {
+  var doSave = function(newFile, fileEntry) {
     fileEntry.createWriter(function(fileWriter) {
       function writeContent() {
         fileWriter.onwriteend = onSuccess.bind(null, fileEntry);
         fileWriter.write(ImageEncoder.getBlob(canvas, metadataEncoder));
       }
       fileWriter.onerror = function(error) {
         onError(error);
         // Disable all callbacks on the first error.
         fileWriter.onerror = null;
         fileWriter.onwriteend = null;
       };
       if (newFile) {
         writeContent();
       } else {
         fileWriter.onwriteend = writeContent;
         fileWriter.truncate(0);
       }
     }, onError);
   }
 
-  function getFile(dir, newFile) {
+  var getFile = function(dir, newFile) {
     dir.getFile(name, {create: newFile, exclusive: newFile},
-        doSave.bind(null, newFile), onError);
-  }
+        function(fileEntry) {
+          var locationInfo = volumeManager.getLocationInfo(fileEntry);
+          // If the volume is gone, then abort the saving operation.
+          if (!locationInfo) {
+            onError('NotFound');
+            return;
+          }
+          doSave(newFile, fileEntry, locationInfo);
+        }.bind(this), onError);
+  }.bind(this);
 
-  function checkExistence(dir) {
+  var checkExistence = function(dir) {
     dir.getFile(name, {create: false, exclusive: false},
         getFile.bind(null, dir, false /* existing file */),
         getFile.bind(null, dir, true /* create new file */));
   }
 
   var saveToDir = function(dir) {
-    if (overwrite && !this.isReadOnly_) {
+    if (overwrite && !this.locationInfo_.isReadOnly) {
       checkExistence(dir);
     } else {
       this.createCopyName_(dir, function(copyName) {
         this.original_ = false;
         name = copyName;
         checkExistence(dir);
       }.bind(this));
     }
   }.bind(this);
 
-  if (this.isReadOnly_) {
+  if (this.locationInfo_.isReadOnly) {
     saveToDir(fallbackDir);
   } else {
     this.entry_.getParent(saveToDir, onError);
   }
 };
 
 /**
  * Renames the item.
  *
  * @param {string} displayName New display name (without the extension).
@@ skipping 22 matching lines @@
         return Promise.reject(str('GALLERY_FILE_EXISTS'));
       }, function() {
         return new Promise(
             this.entry_.moveTo.bind(this.entry_, parentDirectory, newFileName));
       }.bind(this));
     }.bind(this));
   }.bind(this)).then(function(entry) {
     this.entry_ = entry;
   }.bind(this));
 };