This is UI side unreadable device support.

chrome/browser/chromeos/cros/mount_library.cc

 // 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.
 
 #include "chrome/browser/chromeos/cros/mount_library.h"
 
 #include <set>
 #include <vector>
 
 #include "base/message_loop.h"
@@ skipping 16 matching lines @@
     case MOUNT_TYPE_NETWORK_STORAGE:
       return "network";
     case MOUNT_TYPE_INVALID:
       return "invalid";
     default:
       NOTREACHED();
   }
   return "";
 }
 
+std::string MountLibrary::MountConditionToString(MountCondition condition) {
+  switch (condition) {
+    case MOUNT_CONDITION_NONE:
+      return "";
+    case MOUNT_CONDITION_UNKNOWN_FILESYSTEM:
+      return "unknown_filesystem";
+    case MOUNT_CONDITION_UNSUPPORTED_FILESYSTEM:
+      return "unsupported_filesystem";
+    default:
+      NOTREACHED();
+  }
+  return "";
+}
+
 // static
 MountType MountLibrary::MountTypeFromString(
     const std::string& type_str) {
   if (type_str == "device") {
     return MOUNT_TYPE_DEVICE;
   } else if (type_str == "network") {
     return MOUNT_TYPE_NETWORK_STORAGE;
   } else if (type_str == "file") {
     return MOUNT_TYPE_ARCHIVE;
   } else {
@@ skipping 119 matching lines @@
   virtual void RemoveObserver(Observer* observer) OVERRIDE {
     observers_.RemoveObserver(observer);
   }
 
   virtual void MountPath(const char* source_path,
                          MountType type,
                          const MountPathOptions& options) OVERRIDE {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (!CrosLibrary::Get()->EnsureLoaded()) {
       OnMountCompleted(MOUNT_ERROR_LIBRARY_NOT_LOADED,
-                       MountPointInfo(source_path, NULL, type));
+                       MountPointInfo(source_path,
+                                      NULL,
+                                      type,
+                                      MOUNT_CONDITION_NONE));
       return;
     }
     libcros_proxy_->CallMountPath(source_path, type, options,
                                   &MountCompletedHandler, this);
   }
 
   virtual void UnmountPath(const char* mount_path) OVERRIDE {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (!CrosLibrary::Get()->EnsureLoaded()) {
       OnUnmountPath(mount_path,
@@ skipping 136 matching lines @@
         &MonitorMountEventsHandler, &MountCompletedHandler, this);
   }
  private:
   // Callback for MountComplete signal and MountSourcePath method.
   static void MountCompletedHandler(void* object,
                                     MountError error_code,
                                     const char* source_path,
                                     MountType type,
                                     const char* mount_path) {
     DCHECK(object);
+    MountCondition mount_condition = MOUNT_CONDITION_NONE;
+    if (type == MOUNT_TYPE_DEVICE) {
+      if (error_code == MOUNT_ERROR_UNKNOWN_FILESYSTEM)
+          mount_condition = MOUNT_CONDITION_UNKNOWN_FILESYSTEM;
+      if (error_code == MOUNT_ERROR_UNSUPORTED_FILESYSTEM)
+          mount_condition = MOUNT_CONDITION_UNSUPPORTED_FILESYSTEM;
+    }
+
     MountLibraryImpl* self = static_cast<MountLibraryImpl*>(object);
     self->OnMountCompleted(static_cast<MountError>(error_code),
-                           MountPointInfo(source_path, mount_path, type));
+                           MountPointInfo(source_path,
+                                          mount_path,
+                                          type,
+                                          mount_condition));
   }
 
   // Callback for UnmountRemovableDevice method.
   static void UnmountMountPointCallback(void* object,
                                         const char* mount_path,
                                         MountMethodErrorType error,
                                         const char* error_message) {
     DCHECK(object);
     MountLibraryImpl* self = static_cast<MountLibraryImpl*>(object);
     self->OnUnmountPath(mount_path, error, error_message);
@@ skipping 84 matching lines @@
 
 
   void OnMountCompleted(MountError error_code,
                         const MountPointInfo& mount_info) {
     DCHECK(!mount_info.source_path.empty());
 
     FireMountCompleted(MOUNTING, error_code, mount_info);
 
     // If the device is corrupted but it's still possible to format it, it will
     // be fake mounted.
-    // TODO(sidor): Write more general condition when it will possible.
-    bool mount_corrupted_device =
-        (error_code == MOUNT_ERROR_UNKNOWN_FILESYSTEM ||
-         error_code == MOUNT_ERROR_UNSUPORTED_FILESYSTEM) &&
-        mount_info.mount_type == MOUNT_TYPE_DEVICE;
-
-    if ((error_code == MOUNT_ERROR_NONE || mount_corrupted_device) &&
+    if ((error_code == MOUNT_ERROR_NONE || mount_info.mount_condition) &&
         mount_points_.find(mount_info.mount_path) == mount_points_.end()) {
       mount_points_.insert(MountPointMap::value_type(
                                mount_info.mount_path.c_str(),
                                mount_info));
     }
 
-    if ((error_code == MOUNT_ERROR_NONE || mount_corrupted_device) &&
+    if ((error_code == MOUNT_ERROR_NONE || mount_info.mount_condition) &&
         mount_info.mount_type == MOUNT_TYPE_DEVICE &&
         !mount_info.source_path.empty() &&
         !mount_info.mount_path.empty()) {
       DiskMap::iterator iter = disks_.find(mount_info.source_path);
       if (iter == disks_.end()) {
         // disk might have been removed by now?
         return;
       }
       Disk* disk = iter->second;
       DCHECK(disk);
       disk->set_mount_path(mount_info.mount_path.c_str());
       FireDiskStatusUpdate(MOUNT_DISK_MOUNTED, disk);
     }
   }
 
   void OnUnmountPath(const char* mount_path,
                      MountMethodErrorType error,
                      const char* error_message) {
     DCHECK(mount_path);
     if (error == MOUNT_METHOD_ERROR_NONE && mount_path) {
       MountPointMap::iterator mount_points_it = mount_points_.find(mount_path);
       if (mount_points_it == mount_points_.end())
         return;
       // TODO(tbarzic): Add separate, PathUnmounted event to Observer.
       FireMountCompleted(
           UNMOUNTING,
           MOUNT_ERROR_NONE,
           MountPointInfo(mount_points_it->second.source_path.c_str(),
                          mount_points_it->second.mount_path.c_str(),
-                         mount_points_it->second.mount_type));
+                         mount_points_it->second.mount_type,
+                         mount_points_it->second.mount_condition));
       std::string path(mount_points_it->second.source_path);
       mount_points_.erase(mount_points_it);
       DiskMap::iterator iter = disks_.find(path);
       if (iter == disks_.end()) {
         // disk might have been removed by now.
         return;
       }
       Disk* disk = iter->second;
       DCHECK(disk);
       disk->clear_mount_path();
@@ skipping 306 matching lines @@
   else
     return new MountLibraryImpl();
 }
 
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until it's last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::MountLibraryImpl);