Connect MediaFileSystemRegistry with MediaGalleriesPreferences

chrome/browser/media_gallery/media_storage_util.cc

 // 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.
 
 // chrome::MediaStorageUtil implementation.
 
 #include "chrome/browser/media_gallery/media_storage_util.h"
 
 #include <vector>
 
@@ skipping 15 matching lines @@
 // Prefix constants for different device id spaces.
 const char kRemovableMassStorageWithDCIMPrefix[] = "dcim:";
 const char kRemovableMassStorageNoDCIMPrefix[] = "nodcim:";
 const char kFixedMassStoragePrefix[] = "path:";
 const char kMtpPtpPrefix[] = "mtp:";
 
 static void (*g_test_get_device_info_from_path_function)(
     const FilePath& path, std::string* device_id, string16* device_name,
     FilePath* relative_path) = NULL;
 
-void EmptyPathIsFalseCallback(const MediaStorageUtil::BoolCallback& callback,
-                              FilePath path) {
-  callback.Run(!path.empty());
-}
-
 void ValidatePathOnFileThread(
-    const FilePath& path, const MediaStorageUtil::FilePathCallback& callback) {
+    const FilePath& path, const MediaStorageUtil::BoolCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  FilePath result;
-  if (file_util::PathExists(path))
-    result = path;
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                          base::Bind(callback, path));
+                          base::Bind(callback, file_util::PathExists(path)));
 }
 
 FilePath::StringType FindRemovableStorageLocationById(
     const std::string& device_id) {
   RemovableStorageInfo media_devices =
       SystemMonitor::Get()->GetAttachedRemovableStorage();
   for (RemovableStorageInfo::const_iterator it = media_devices.begin();
        it != media_devices.end();
        ++it) {
     if (it->device_id == device_id)
@@ skipping 57 matching lines @@
       (type == REMOVABLE_MASS_STORAGE_WITH_DCIM || type == MTP_OR_PTP);
 }
 
 // static
 bool MediaStorageUtil::IsRemovableDevice(const std::string& device_id) {
   Type type;
   return CrackDeviceId(device_id, &type, NULL) && type != FIXED_MASS_STORAGE;
 }
 
 // static
+bool MediaStorageUtil::IsMassStorageDevice(const std::string& device_id) {
+  Type type;
+  return CrackDeviceId(device_id, &type, NULL) && type != MTP_OR_PTP;
+}
+
+// static
 void MediaStorageUtil::IsDeviceAttached(const std::string& device_id,
                                         const BoolCallback& callback) {
   Type type;
   std::string unique_id;
   if (!CrackDeviceId(device_id, &type, &unique_id)) {
     callback.Run(false);
     return;
   }
 
   switch (type) {
     case MTP_OR_PTP:  // Fall through.
     case REMOVABLE_MASS_STORAGE_WITH_DCIM: // Fall through.
     case REMOVABLE_MASS_STORAGE_NO_DCIM:
       // We should be able to find removable storage in SystemMonitor.
       callback.Run(!FindRemovableStorageLocationById(device_id).empty());
       break;
     case FIXED_MASS_STORAGE:
       // For this type, the unique_id is the path.
-      BrowserThread::PostTask(
-          BrowserThread::FILE, FROM_HERE,
-          base::Bind(&ValidatePathOnFileThread,
-                     FilePath::FromUTF8Unsafe(unique_id),
-                     base::Bind(&EmptyPathIsFalseCallback, callback)));
+      BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+                              base::Bind(&ValidatePathOnFileThread,
+                                         FilePath::FromUTF8Unsafe(unique_id),
+                                         callback));
       break;
   }
   NOTREACHED();
   callback.Run(false);
 }
 
 // static
 void MediaStorageUtil::GetDeviceInfoFromPath(const FilePath& path,
                                              std::string* device_id,
                                              string16* device_name,
                                              FilePath* relative_path) {
   if (g_test_get_device_info_from_path_function) {
     g_test_get_device_info_from_path_function(path, device_id, device_name,
                                               relative_path);
   } else {
     GetDeviceInfoFromPathImpl(path, device_id, device_name, relative_path);
   }
 }
 
 // static
-void MediaStorageUtil::FindDevicePathById(const std::string& device_id,
-                                          const FilePathCallback& callback) {
+FilePath MediaStorageUtil::FindDevicePathById(const std::string& device_id) {
   Type type;
   std::string unique_id;
   if (!CrackDeviceId(device_id, &type, &unique_id))
-    callback.Run(FilePath());
+    return FilePath();
 
   switch (type) {
     case MTP_OR_PTP:
       // TODO(kmadhusu) We may want to return the MTP device location here.
-      callback.Run(FilePath());
-      break;
+      return FilePath();
     case REMOVABLE_MASS_STORAGE_WITH_DCIM:  // Fall through.
     case REMOVABLE_MASS_STORAGE_NO_DCIM:
-      callback.Run(FilePath(FindRemovableStorageLocationById(device_id)));
-      break;
+      return FilePath(FindRemovableStorageLocationById(device_id));
     case FIXED_MASS_STORAGE:
       // For this type, the unique_id is the path.
-      BrowserThread::PostTask(
-          BrowserThread::FILE, FROM_HERE,
-          base::Bind(&ValidatePathOnFileThread,
-                     FilePath::FromUTF8Unsafe(unique_id), callback));
-      break;
+      return FilePath::FromUTF8Unsafe(unique_id);
   }
+
   NOTREACHED();
-  callback.Run(FilePath());
+  return FilePath();
 }
 
 // static
 void MediaStorageUtil::SetGetDeviceInfoFromPathFunctionForTesting(
     GetDeviceInfoFromPathFunction function) {
   g_test_get_device_info_from_path_function = function;
 }
 
 MediaStorageUtil::MediaStorageUtil() {}
 
@@ skipping 12 matching lines @@
   if (device_id)
     *device_id = MakeDeviceId(FIXED_MASS_STORAGE, path.AsUTF8Unsafe());
   if (device_name)
     *device_name = path.BaseName().LossyDisplayName();
   if (relative_path)
     *relative_path = FilePath();
 }
 #endif
 
 }  // namespace chrome