[StorageMonitor] Move gallery name generation to StorageInfo.

chrome/browser/media_galleries/media_galleries_preferences.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.
 
 #include "chrome/browser/media_galleries/media_galleries_preferences.h"
 
 #include "base/base_paths_posix.h"
 #include "base/callback.h"
 #include "base/i18n/time_formatting.h"
 #include "base/path_service.h"
@@ skipping 20 matching lines @@
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/pref_names.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/permissions/api_permission.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/text/bytes_formatting.h"

[vandebo (ex-Chrome), 2014/03/03 19:58:31]

Is this include still used?

[Haojian Wu, 2014/03/04 05:00:12]

Done.

 
 using base::DictionaryValue;
 using base::ListValue;
 using extensions::ExtensionPrefs;
 using storage_monitor::MediaStorageUtil;
 using storage_monitor::StorageInfo;
 using storage_monitor::StorageMonitor;
 
 namespace {
 
@@ skipping 237 matching lines @@
   if (dict->GetString(kMediaGalleryIdKey, &string_id) &&
       base::StringToUint64(string_id, &out_permission->pref_id) &&
       dict->GetBoolean(kMediaGalleryHasPermissionKey,
                        &out_permission->has_permission)) {
     return true;
   }
   NOTREACHED();
   return false;
 }
 
-base::string16 GetDisplayNameForDevice(uint64 storage_size_in_bytes,
-                                       const base::string16& name) {
-  DCHECK(!name.empty());
-  return (storage_size_in_bytes == 0) ?
-      name :
-      ui::FormatBytes(storage_size_in_bytes) + base::ASCIIToUTF16(" ") + name;
-}
-
 // For a device with |device_name| and a relative path |sub_folder|, construct
 // a display name. If |sub_folder| is empty, then just return |device_name|.
 base::string16 GetDisplayNameForSubFolder(const base::string16& device_name,
                                           const base::FilePath& sub_folder) {
   if (sub_folder.empty())
     return device_name;
   return (sub_folder.BaseName().LossyDisplayName() +
           base::ASCIIToUTF16(" - ") +
           device_name);
 }
 
-base::string16 GetFullProductName(const base::string16& vendor_name,
-                                  const base::string16& model_name) {
-  if (vendor_name.empty() && model_name.empty())
-    return base::string16();
-
-  base::string16 product_name;
-  if (vendor_name.empty())
-    product_name = model_name;
-  else if (model_name.empty())
-    product_name = vendor_name;
-  else if (!vendor_name.empty() && !model_name.empty())
-    product_name = vendor_name + base::UTF8ToUTF16(", ") + model_name;
-
-  return product_name;
-}
-
 }  // namespace
 
 MediaGalleryPrefInfo::MediaGalleryPrefInfo()
     : pref_id(kInvalidMediaGalleryPrefId),
       type(kInvalidType),
       total_size_in_bytes(0),
       volume_metadata_valid(false),
       audio_count(0),
       image_count(0),
       video_count(0),
@@ skipping 29 matching lines @@
       base::FilePath relative;
       if (download_path.AppendRelativePath(path, &relative))
         return relative.LossyDisplayName();
     }
     return path.BaseName().LossyDisplayName();
 #else
     return path.LossyDisplayName();
 #endif
   }
 
-  base::string16 name = display_name;
-  if (name.empty())
-    name = volume_label;
-  if (name.empty())
-    name = GetFullProductName(vendor_name, model_name);
-  if (name.empty())
-    name = l10n_util::GetStringUTF16(IDS_MEDIA_GALLERIES_UNLABELED_DEVICE);
-
-  name = GetDisplayNameForDevice(total_size_in_bytes, name);
-
+  StorageInfo info(device_id,
+                   MediaStorageUtil::FindDevicePathById(device_id).value(),
+                   volume_label, vendor_name, model_name, total_size_in_bytes);
+  base::string16 name = info.GetDisplayNameWithOverride(display_name, true);
   if (!path.empty())
     name = GetDisplayNameForSubFolder(name, path);
-
   return name;
 }
 
 base::string16 MediaGalleryPrefInfo::GetGalleryTooltip() const {
   return AbsolutePath().LossyDisplayName();
 }
 
 base::string16 MediaGalleryPrefInfo::GetGalleryAdditionalDetails() const {
   base::string16 attached;
   if (StorageInfo::IsRemovableDevice(device_id)) {
@@ skipping 136 matching lines @@
   };
 
   for (size_t i = 0; i < arraysize(kDirectoryKeys); ++i) {
     base::FilePath path;
     if (!PathService::Get(kDirectoryKeys[i], &path))
       continue;
 
     base::FilePath relative_path;
     StorageInfo info;
     if (MediaStorageUtil::GetDeviceInfoFromPath(path, &info, &relative_path)) {
-      AddGalleryInternal(info.device_id(), info.name(), relative_path,
+      AddGalleryInternal(info.device_id(), base::string16(), relative_path,
                          MediaGalleryPrefInfo::kAutoDetected,
                          info.storage_label(), info.vendor_name(),
                          info.model_name(), info.total_size_in_bytes(),
                          base::Time(), true, 0, 0, 0, kCurrentPrefsVersion);
     }
   }
 }
 
 bool MediaGalleriesPreferences::UpdateDeviceIDForSingletonType(
     const std::string& device_id) {
@@ skipping 686 matching lines @@
   if (extension_prefs_for_testing_)
     return extension_prefs_for_testing_;
   return extensions::ExtensionPrefs::Get(profile_);
 }
 
 void MediaGalleriesPreferences::SetExtensionPrefsForTesting(
     extensions::ExtensionPrefs* extension_prefs) {
   DCHECK(IsInitialized());
   extension_prefs_for_testing_ = extension_prefs;
 }