This is UI side unreadable device support.

chrome/browser/resources/file_manager/js/file_manager.js

 // Copyright (c) 2011 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.
 
 // Setting the src of an img to an empty string can crash the browser, so we
 // use an empty 1x1 gif instead.
 const EMPTY_IMAGE_URI = 'data:image/gif;base64,'
         + 'R0lGODlhAQABAPABAP///wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw%3D%3D';
 
 var g_slideshow_data = null;
@@ skipping 188 matching lines @@
    */
   const CP_RECURSE = true;
   const CP_NO_RECURSE = false;
 
   /**
    * Translated strings.
    */
   var localStrings;
 
   /**
-   * Map of icon types to regular expressions.
+   * Map of icon types to regular expressions and functions
    *
-   * The first regexp to match the file name determines the icon type
-   * assigned to dom elements for a file.  Order of evaluation is not
+   * The first regexp/function to match the entry name determines the icon type
+   * assigned to dom elements for a file. Order of evaluation is not
    * defined, so don't depend on it.
    */
   const iconTypes = {
     'audio': /\.(flac|mp3|m4a|oga|ogg|wav)$/i,
     'html': /\.(html?)$/i,
     'image': /\.(bmp|gif|jpe?g|ico|png|webp)$/i,
     'pdf' : /\.(pdf)$/i,
     'text': /\.(pod|rst|txt|log)$/i,
-    'video': /\.(3gp|avi|mov|mp4|m4v|mpe?g4?|ogm|ogv|ogx|webm)$/i
+    'video': /\.(3gp|avi|mov|mp4|m4v|mpe?g4?|ogm|ogv|ogx|webm)$/i,
+    'device': function(self, entry) {
+      var deviceNumber = self.getDeviceNumber(entry);
+      if (deviceNumber != undefined)
+        return (self.mountPoints_[deviceNumber].specialData == '');
+      return false;
+    },
+    'unreadable': function(self, entry) {
+      var deviceNumber = self.getDeviceNumber(entry);
+      if (deviceNumber != undefined) {
+        return self.mountPoints_[deviceNumber].specialData ==
+               'unreadable_unknown_filesystem' ||
+               self.mountPoints_[deviceNumber].specialData ==
+               'unreadable_unsupported_filesystem';
+      }
+      return false;
+    }
   };
 
   const previewArt = {
     'audio': 'images/filetype_large_audio.png',
+    // TODO(sidor): Find better icon here.
+    'device': 'images/filetype_large_folder.png',
     'folder': 'images/filetype_large_folder.png',
     'unknown': 'images/filetype_large_generic.png',
+    // TODO(sidor): Find better icon here.
+    'unreadable': 'images/filetype_large_folder.png',
     'video': 'images/filetype_large_video.png'
   };
 
   /**
    * Regexp for archive files. Used to show mount-archive task.
    */
   const ARCHIVES_REGEXP = /.zip$/;
 
   /**
    * Return a translated string.
@@ skipping 47 matching lines @@
    *
    * @param {string} path The file path.
    */
   function getParentPath(path) {
     var parent = path.replace(/[\/]?[^\/]+[\/]?$/,'');
     if (parent.length == 0)
       parent = '/';
     return parent;
   }
 
-  /**
-   * Get the icon type for a given Entry.
-   *
-   * @param {Entry} entry An Entry subclass (FileEntry or DirectoryEntry).
-   * @return {string} One of the keys from FileManager.iconTypes, or
-   *     'unknown'.
-   */
-  function getIconType(entry) {
-    if (entry.cachedIconType_)
-      return entry.cachedIconType_;
+ /**
+  * Normalizes path not to start with /
+  *
+  * @param {string} path The file path.
+  */
+  function normalizeAbsolutePath(x) {
+    if (x[0] == '/')
+      return x.slice(1);
+    else
+      return x;
+  }
 
-    var rv = 'unknown';
-
-    if (entry.isDirectory) {
-      rv = 'folder';
-    } else {
-      for (var name in iconTypes) {
-        var value = iconTypes[name];
-
-        if (value instanceof RegExp) {
-          if (value.test(entry.name))  {
-            rv = name;
-            break;
-          }
-        } else if (typeof value == 'function') {
-          try {
-            if (value(entry)) {
-              rv = name;
-              break;
-            }
-          } catch (ex) {
-            console.error('Caught exception while evaluating iconType: ' +
-                          name, ex);
-          }
-        } else {
-          console.log('Unexpected value in iconTypes[' + name + ']: ' + value);
-        }
-      }
-    }
-
-    entry.cachedIconType_ = rv;
-    return rv;
-  }
 
   /**
    * Call an asynchronous method on dirEntry, batching multiple callers.
    *
    * This batches multiple callers into a single invocation, calling all
    * interested parties back when the async call completes.
    *
    * The Entry method to be invoked should take two callbacks as parameters
    * (one for success and one for failure), and it should invoke those
    * callbacks with a single parameter representing the result of the call.
@@ skipping 122 matching lines @@
       });
     } else {
       batchAsyncCall(entry, 'getMetadata', function(metadata) {
         entry.cachedMtime_ = metadata.modificationTime;
         if (successCallback)
           successCallback(entry);
       }, opt_errorCallback);
     }
   }
 
-  /**
-   * Get the icon type of a file, caching the result.
-   *
-   * When this method completes, the fileEntry object will get a
-   * 'cachedIconType_' property (if it doesn't already have one) containing the
-   * icon type of the file as a string.
-   *
-   * The successCallback is always invoked synchronously, since this does not
-   * actually require an async call.  You should not depend on this, as it may
-   * change if we were to start reading magic numbers (for example).
-   *
-   * @param {Entry} entry An HTML5 Entry object.
-   * @param {function(Entry)} successCallback The function to invoke once the
-   *     icon type is known.
-   */
-  function cacheEntryIconType(entry, successCallback) {
-    getIconType(entry);
-    if (successCallback)
-      setTimeout(function() { successCallback(entry) }, 0);
-  }
-
   function isSystemDirEntry(dirEntry) {
     return dirEntry.fullPath == '/' ||
         dirEntry.fullPath == REMOVABLE_DIRECTORY ||
         dirEntry.fullPath == ARCHIVE_DIRECTORY;
   }
 
   // Public statics.
 
   /**
    * List of dialog types.
@@ skipping 140 matching lines @@
 
     this.setListType(FileManager.ListType.DETAIL);
 
     this.onResize_();
     this.dialogDom_.style.opacity = '1';
 
     this.textSearchState_ = {text: '', date: new Date()};
   };
 
   /**
+   * Get the icon type for a given Entry.
+   *
+   * @param {Entry} entry An Entry subclass (FileEntry or DirectoryEntry).
+   * @return {string} One of the keys from FileManager.iconTypes, or
+   *     'unknown'.
+   */
+  FileManager.prototype.getIconType = function(entry) {
+    if (entry.cachedIconType_)
+      return entry.cachedIconType_;
+
+    var rv = 'unknown';
+   if (entry.isDirectory)
+      rv = 'folder';
+    for (var name in iconTypes) {
+      var value = iconTypes[name];
+
+      if (value instanceof RegExp) {
+        if (value.test(entry.name))  {
+          rv = name;
+          break;
+        }
+      } else if (typeof value == 'function') {
+        try {
+          if (value(this,entry)) {
+            rv = name;
+            break;
+          }
+        } catch (ex) {
+          console.error('Caught exception while evaluating iconType: ' +
+                        name, ex);
+        }
+      } else {
+        console.log('Unexpected value in iconTypes[' + name + ']: ' + value);
+      }
+    }
+    entry.cachedIconType_ = rv;
+    return rv;
+  };
+
+
+  /**
+   * Get the icon type of a file, caching the result.
+   *
+   * When this method completes, the fileEntry object will get a
+   * 'cachedIconType_' property (if it doesn't already have one) containing the
+   * icon type of the file as a string.
+   *
+   * The successCallback is always invoked synchronously, since this does not
+   * actually require an async call.  You should not depend on this, as it may
+   * change if we were to start reading magic numbers (for example).
+   *
+   * @param {Entry} entry An HTML5 Entry object.
+   * @param {function(Entry)} successCallback The function to invoke once the
+   *     icon type is known.
+   */
+  FileManager.prototype.cacheEntryIconType = function(entry, successCallback) {
+    this.getIconType(entry);
+    if (successCallback)
+      setTimeout(function() { successCallback(entry) }, 0);
+  }
+
+  /**
    * Compare by mtime first, then by name.
    */
   FileManager.prototype.compareMtime_ = function(a, b) {
     if (a.cachedMtime_ > b.cachedMtime)
       return 1;
 
     if (a.cachedMtime_ < b.cachedMtime)
       return -1;
 
     return this.collator_.compare(a.name, b.name);
@@ skipping 565 matching lines @@
   FileManager.prototype.prepareSort_ = function(field, callback) {
     var cacheFunction;
 
     if (field == 'name' || field == 'cachedMtime_') {
       // Mtime is the tie-breaker for a name sort, so we need to resolve
       // it for both mtime and name sorts.
       cacheFunction = cacheEntryDate;
     } else if (field == 'cachedSize_') {
       cacheFunction = cacheEntrySize;
     } else if (field == 'cachedIconType_') {
-      cacheFunction = cacheEntryIconType;
+      cacheFunction = this.cacheEntryIconType;
     } else {
       callback();
       return;
     }
 
     function checkCount() {
       if (uncachedCount == 0) {
         // Callback via a setTimeout so the sync/async semantics don't change
         // based on whether or not the value is cached.
         setTimeout(callback, 0);
@@ skipping 86 matching lines @@
    */
   FileManager.prototype.renderIconType_ = function(entry, columnId, table) {
     var div = this.document_.createElement('div');
     div.className = 'detail-icon-container';
 
     if (this.showCheckboxes_)
       div.appendChild(this.renderCheckbox_(entry));
 
     var icon = this.document_.createElement('div');
     icon.className = 'detail-icon';
-    entry.cachedIconType_ = getIconType(entry);
+    entry.cachedIconType_ = this.getIconType(entry);
     icon.setAttribute('iconType', entry.cachedIconType_);
     div.appendChild(icon);
 
     return div;
   };
 
   FileManager.prototype.getLabelForRootPath_ = function(path) {
     // This hack lets us localize the top level directories.
     if (path == 'Downloads')
       return str('DOWNLOADS_DIRECTORY_LABEL');
@@ skipping 114 matching lines @@
 
     for (var i = 0; i < selection.indexes.length; i++) {
       var entry = this.dataModel_.item(selection.indexes[i]);
       if (!entry)
         continue;
 
       selection.entries.push(entry);
       selection.urls.push(entry.toURL());
 
       if (selection.iconType == null) {
-        selection.iconType = getIconType(entry);
+        selection.iconType = this.getIconType(entry);
       } else if (selection.iconType != 'unknown') {
-        var iconType = getIconType(entry);
+        var iconType = this.getIconType(entry);
         if (selection.iconType != iconType)
           selection.iconType = 'unknown';
       }
 
       selection.totalCount++;
 
       if (entry.isFile) {
         selection.fileCount += 1;
         if (!('cachedSize_' in entry)) {
           // Any file that hasn't been rendered may be missing its cachedSize_
@@ skipping 198 matching lines @@
    * @param {Object} selection Selected files object.
    */
   FileManager.prototype.maybeRenderFormattingTask_ = function(selection) {
     // Not to make unnecessary getMountPoints() call we doublecheck if there is
     // only one selected entry.
     if (selection.entries.length != 1)
       return;
     var self = this;
     function onMountPointsFound(mountPoints) {
       self.mountPoints_ = mountPoints;
-
-      function normalize(x) {
-        if (x[0] == '/')
-          return x.slice(1);
-        else
-          return x;
-      }
-
       function onVolumeMetadataFound(volumeMetadata) {
         if (volumeMetadata.deviceType == "flash") {
-          if (selection.entries.length != 1 ||
-              normalize(selection.entries[0].fullPath) !=
-              normalize(volumeMetadata.mountPath)) {
+          if (self.selection.entries.length != 1 ||
+              normalizeAbsolutePath(self.selection.entries[0].fullPath) !=
+              normalizeAbsolutePath(volumeMetadata.mountPath)) {
             return;
           }
           var task = {
             taskId: self.getExtensionId_() + '|format-device',
             iconUrl: chrome.extension.getURL('images/filetype_generic.png'),
             title: str('FORMAT_DEVICE')
           };
           self.renderTaskButton_(task);
         }
       }
 
       if (selection.entries.length != 1)
         return;
       var selectedPath = selection.entries[0].fullPath;
       for (var i = 0; i < mountPoints.length; i++) {
         if (mountPoints[i].mountType == "device" &&
-            normalize(mountPoints[i].mountPath) == normalize(selectedPath)) {
+            normalizeAbsolutePath(mountPoints[i].mountPath) ==
+            normalizeAbsolutePath(selectedPath)) {
           chrome.fileBrowserPrivate.getVolumeMetadata(mountPoints[i].sourceUrl,
               onVolumeMetadataFound);
           return;
         }
       }
     }
 
     chrome.fileBrowserPrivate.getMountPoints(onMountPointsFound);
   };
 
@@ skipping 33 matching lines @@
         }
       }
 
       if (event.eventType == 'unmount' && event.status == 'success' &&
           self.currentDirEntry_ &&
           isParentPath(event.mountPath, self.currentDirEntry_.fullPath)) {
         self.changeDirectory(getParentPath(event.mountPath));
         return;
       }
 
+      var rescanDirectory = (event.status == 'success');

[tbarzic, 2011/08/24 03:59:44]

I think smth like rescanDirectoryNeeded would be clearer name..

[sidor, 2011/08/24 04:26:06]

Will do this tommorrow.

+      for (var i = 0; i < mountPoints.length; i++) {
+        if (event.sourceUrl == mountPoints[i].sourceUrl &&

[tbarzic, 2011/08/24 03:59:44]

why don't you just add specialData field to the event?

[sidor, 2011/08/24 04:26:06]

Because I need to perform check later on double click. 

[tbarzic, 2011/08/25 02:03:44]

yeah, I know..
What I ment is you could avoid search here by adding specialData field to both
event and mount point info 

+            mountPoints[i].specialData != '') {
+          rescanDirectory = true;
+        }
+      }
       // TODO(dgozman): rescan directory, only if it contains mounted points,
       // when mounts location will be decided.
-      if (event.status == 'success' ||
-          event.status == 'error_unknown_filesystem' ||
-          event.status == 'error_unsuported_filesystem')
+      if (rescanDirectory)
         self.rescanDirectory_();
     });
   };
 
   /**
    * Event handler called when some internal task should be executed.
    */
   FileManager.prototype.onFileTaskExecute_ = function(id, details) {
     var urls = details.entries.map(function(entry) {
         return entry.toURL();
@@ skipping 14 matching lines @@
       for (var index = 0; index < urls.length; ++index) {
         chrome.fileBrowserPrivate.removeMount(urls[index]);
       }
     } else if (id == 'format-device') {
       this.confirm.show(str('FORMATTING_WARNING'), function() {
         chrome.fileBrowserPrivate.formatDevice(urls[0]);
       });
     }
   };
 
+  FileManager.prototype.getDeviceNumber = function(entry) {
+    if (!entry.isDirectory) return false;
+    for (var i = 0; i < this.mountPoints_.length; i++) {
+      if (normalizeAbsolutePath(entry.fullPath) ==
+          normalizeAbsolutePath(this.mountPoints_[i].mountPath)) {
+        return i;
+      }
+    }
+    return undefined;
+  }
+
   FileManager.prototype.openImageEditor_ = function(entry) {
     var self = this;
 
     var editorFrame = this.document_.createElement('iframe');
     editorFrame.className = 'overlay-pane';
     editorFrame.scrolling = 'no';
 
     editorFrame.onload = function() {
       self.cacheMetadata_(entry, function(metadata) {
         editorFrame.contentWindow.ImageEditor.open(
@@ skipping 84 matching lines @@
       this.previewFilename_.textContent = '';
       return;
     }
 
     var previewName = this.selection.leadEntry.name;
     if (this.currentDirEntry_.name == '')
       previewName = this.getLabelForRootPath_(previewName);
 
     this.previewFilename_.textContent = previewName;
 
-    var iconType = getIconType(this.selection.leadEntry);
+    var iconType = this.getIconType(this.selection.leadEntry);
     if (iconType == 'image') {
       if (fileManager.selection.totalCount > 1)
         this.previewImage_.classList.add('multiple-selected');
     }
 
     var self = this;
     var leadEntry = this.selection.leadEntry;
 
     this.getThumbnailURL(leadEntry, function(iconType, url) {
       if (self.selection.leadEntry != leadEntry) {
@@ skipping 136 matching lines @@
       addProperty('DIMENSIONS_LABEL',
                   strf('DIMENSIONS_FORMAT', exifDir[0xa002].value,
                        exifDir[0xa003].value));
     }
   };
 
   FileManager.prototype.getThumbnailURL = function(entry, callback) {
     if (!entry)
       return;
 
-    var iconType = getIconType(entry);
+    var iconType = this.getIconType(entry);
 
     this.cacheMetadata_(entry, function (metadata) {
       var url = metadata.thumbnailURL;
       if (!url) {
         if (iconType == 'image') {
           url = entry.toURL();
         } else {
           url = previewArt[iconType] || previewArt['unknown'];
         }
       }
@@ skipping 379 matching lines @@
       // Don't pay attention to double clicks during a rename.
       return;
     }
 
     var entry = this.selection.leadEntry;
     if (!entry) {
       console.log('Invalid selection');
       return;
     }
 
-    if (entry.isDirectory)
-      return this.changeDirectory(entry.fullPath);
+    if (entry.isDirectory) {
+      var deviceNumber = this.getDeviceNumber(entry);
 
+      if (deviceNumber != undefined &&
+          this.mountPoints_[deviceNumber].specialData ==
+          'unreadable_unknown_filesystem') {
+        return this.showButter(str('UNKNOWN_FILESYSTEM_WARNING'));

[tbarzic, 2011/08/24 03:59:44]

do we really need different error messages for unknown and unsupported devices.
I think something like "Cannot open device which is not mounted." would be
sufficient.

[sidor, 2011/08/24 04:26:06]

In the future I will add a message suggesting formatting to unknown device
message. For unsupported filesystem it seems a little bit to huge to suggest
formatting. That's what I established with Robert.

[tbarzic, 2011/08/25 02:03:44]

ok

+      } else if (deviceNumber != undefined &&
+                 this.mountPoints_[deviceNumber].specialData ==
+                 'unreadable_unsupported_filesystem') {
+        return this.showButter(str('UNSUPPORTED_FILESYSTEM_WARNING'));
+      } else {
+        return this.changeDirectory(entry.fullPath);
+      }
+    }
     if (!this.okButton_.disabled)
       this.onOk_();
 
   };
 
   /**
    * Update the UI when the current directory changes.
    *
    * @param {cr.Event} event The directory-changed event.
    */
@@ skipping 642 matching lines @@
 
     if (msg) {
       console.log('no no no');
       this.alert.show(msg, onAccept);
       return false;
     }
 
     return true;
   };
 })();