[Media Gallery][Linux] Improve device media gallery names.

chrome/browser/system_monitor/removable_device_notifications_linux_unittest.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.
 
 // RemovableDeviceNotificationsLinux unit tests.
 
 #include "chrome/browser/system_monitor/removable_device_notifications_linux.h"
 
 #include <mntent.h>
 #include <stdio.h>
 
 #include <string>
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "base/system_monitor/system_monitor.h"
 #include "base/test/mock_devices_changed_observer.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/system_monitor/media_device_notifications_utils.h"
 #include "chrome/browser/system_monitor/media_storage_util.h"
 #include "chrome/browser/system_monitor/removable_device_constants.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chrome {
 
 namespace {
 
 using testing::_;
@@ skipping 13 matching lines @@
 
 const char kMountPointA[] = "mnt_a";
 const char kMountPointB[] = "mnt_b";
 const char kMountPointC[] = "mnt_c";
 
 struct TestDeviceData {
   const char* device_path;
   const char* unique_id;
   const char* device_name;
   MediaStorageUtil::Type type;
+  uint64 partition_size_in_bytes;
 };
 
 const TestDeviceData kTestDeviceData[] = {
   { kDeviceDCIM1, "UUID:FFF0-000F", "TEST_USB_MODEL_1",
-    MediaStorageUtil::REMOVABLE_MASS_STORAGE_WITH_DCIM},
+    MediaStorageUtil::REMOVABLE_MASS_STORAGE_WITH_DCIM, 88997788 },
   { kDeviceDCIM2, "VendorModelSerial:ComName:Model2010:8989",
-    "TEST_USB_MODEL_2", MediaStorageUtil::REMOVABLE_MASS_STORAGE_WITH_DCIM},
+    "TEST_USB_MODEL_2", MediaStorageUtil::REMOVABLE_MASS_STORAGE_WITH_DCIM,
+    8773 },
   { kDeviceDCIM3, "VendorModelSerial:::WEM319X792", "TEST_USB_MODEL_3",
-    MediaStorageUtil::REMOVABLE_MASS_STORAGE_WITH_DCIM},
+    MediaStorageUtil::REMOVABLE_MASS_STORAGE_WITH_DCIM, 22377892837 },
   { kDeviceNoDCIM, "UUID:ABCD-1234", "TEST_USB_MODEL_4",
-    MediaStorageUtil::REMOVABLE_MASS_STORAGE_NO_DCIM},
-  { kDeviceFixed, "UUID:743A91FD2349", "TEST_USB_MODEL_5",
-    MediaStorageUtil::FIXED_MASS_STORAGE},
+    MediaStorageUtil::REMOVABLE_MASS_STORAGE_NO_DCIM, 512 },
+  { kDeviceFixed, "UUID:743A-2349", "743A-2349",
+    MediaStorageUtil::FIXED_MASS_STORAGE, 172892 },
 };
 
-void GetDeviceInfo(const FilePath& device_path, std::string* id,
-                   string16* name, bool* removable) {
+void GetDeviceInfo(const FilePath& device_path,
+                   std::string* id,
+                   string16* name,
+                   bool* removable,
+                   uint64* partition_size_in_bytes) {
   for (size_t i = 0; i < arraysize(kTestDeviceData); i++) {
     if (device_path.value() == kTestDeviceData[i].device_path) {
       if (id)
         *id = kTestDeviceData[i].unique_id;
       if (name)
         *name = ASCIIToUTF16(kTestDeviceData[i].device_name);
       if (removable) {
         MediaStorageUtil::Type type = kTestDeviceData[i].type;
         *removable =
           (type == MediaStorageUtil::REMOVABLE_MASS_STORAGE_WITH_DCIM) ||
           (type == MediaStorageUtil::REMOVABLE_MASS_STORAGE_NO_DCIM);
       }
+      if (partition_size_in_bytes)
+        *partition_size_in_bytes = kTestDeviceData[i].partition_size_in_bytes;
       return;
     }
   }
   NOTREACHED();
 }
 
+uint64 GetDevicePartitionSize(const std::string& device) {
+  for (size_t i= 0; i < arraysize(kTestDeviceData); ++i) {

[Lei Zhang, 2012/11/13 01:16:12]

nit: "i ="

[kmadhusu, 2012/11/13 17:47:44]

Done.

+    if (device == kTestDeviceData[i].device_path)
+      return kTestDeviceData[i].partition_size_in_bytes;
+  }
+  return 0;
+}
+
 std::string GetDeviceId(const std::string& device) {
-  for (size_t i = 0; i < arraysize(kTestDeviceData); i++) {
+  for (size_t i = 0; i < arraysize(kTestDeviceData); ++i) {
     if (device == kTestDeviceData[i].device_path) {
       return MediaStorageUtil::MakeDeviceId(kTestDeviceData[i].type,
                                             kTestDeviceData[i].unique_id);
     }
   }
   if (device == kInvalidDevice) {
     return MediaStorageUtil::MakeDeviceId(MediaStorageUtil::FIXED_MASS_STORAGE,
                                           kInvalidDevice);
   }
   return std::string();
 }
+
+string16 GetDeviceNameWithSizeDetails(const std::string& device) {
+  for (size_t i = 0; i < arraysize(kTestDeviceData); ++i) {
+    if (device == kTestDeviceData[i].device_path) {
+      return GetDisplayNameForDevice(
+          kTestDeviceData[i].partition_size_in_bytes,
+          ASCIIToUTF16(kTestDeviceData[i].device_name));
+    }
+  }
+  return string16();
+}
+
 string16 GetDeviceName(const std::string& device) {
   for (size_t i = 0; i < arraysize(kTestDeviceData); i++) {
     if (device == kTestDeviceData[i].device_path)
       return ASCIIToUTF16(kTestDeviceData[i].device_name);
   }
   return string16();
 }
 
 class RemovableDeviceNotificationsLinuxTestWrapper
     : public RemovableDeviceNotificationsLinux {
@@ skipping 196 matching lines @@
   testing::Sequence mock_sequence;
   FilePath test_path = CreateMountPointWithDCIMDir(kMountPointA);
   ASSERT_FALSE(test_path.empty());
   MtabTestData test_data[] = {
     MtabTestData(kDeviceDCIM2, test_path.value(), kValidFS),
     MtabTestData(kDeviceFixed, kInvalidPath, kValidFS),
   };
   // Only |kDeviceDCIM2| should be attached, since |kDeviceFixed| has a bad
   // path.
   EXPECT_CALL(observer(),
-              OnRemovableStorageAttached(GetDeviceId(kDeviceDCIM2),
-                                         GetDeviceName(kDeviceDCIM2),
-                                         test_path.value()))
+              OnRemovableStorageAttached(
+                  GetDeviceId(kDeviceDCIM2),
+                  GetDeviceNameWithSizeDetails(kDeviceDCIM2),
+                  test_path.value()))
       .InSequence(mock_sequence);
   AppendToMtabAndRunLoop(test_data, arraysize(test_data));
 
   // |kDeviceDCIM2| should be detached here.
   EXPECT_CALL(observer(), OnRemovableStorageDetached(GetDeviceId(kDeviceDCIM2)))
       .InSequence(mock_sequence);
   WriteEmptyMtabAndRunLoop();
 }
 
 // Only removable devices are recognized.
 TEST_F(RemovableDeviceNotificationLinuxTest, Removable) {
   testing::Sequence mock_sequence;
   FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
   ASSERT_FALSE(test_path_a.empty());
   MtabTestData test_data1[] = {
     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
   };
   // |kDeviceDCIM1| should be attached as expected.
   EXPECT_CALL(observer(),
-              OnRemovableStorageAttached(GetDeviceId(kDeviceDCIM1),
-                                         GetDeviceName(kDeviceDCIM1),
-                                         test_path_a.value()))
+              OnRemovableStorageAttached(
+                  GetDeviceId(kDeviceDCIM1),
+                  GetDeviceNameWithSizeDetails(kDeviceDCIM1),
+                  test_path_a.value()))
       .InSequence(mock_sequence);
   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
 
   // This should do nothing, since |kDeviceFixed| is not removable.
   FilePath test_path_b = CreateMountPointWithoutDCIMDir(kMountPointB);
   ASSERT_FALSE(test_path_b.empty());
   MtabTestData test_data2[] = {
     MtabTestData(kDeviceFixed, test_path_b.value(), kValidFS),
   };
   AppendToMtabAndRunLoop(test_data2, arraysize(test_data2));
 
   // |kDeviceDCIM1| should be detached as expected.
   EXPECT_CALL(observer(), OnRemovableStorageDetached(GetDeviceId(kDeviceDCIM1)))
       .InSequence(mock_sequence);
   WriteEmptyMtabAndRunLoop();
 
   // |kDeviceNoDCIM| should be attached as expected.
   EXPECT_CALL(observer(),
-              OnRemovableStorageAttached(GetDeviceId(kDeviceNoDCIM),
-                                         GetDeviceName(kDeviceNoDCIM),
-                                         test_path_b.value()))
+              OnRemovableStorageAttached(
+                  GetDeviceId(kDeviceNoDCIM),
+                  GetDeviceNameWithSizeDetails(kDeviceNoDCIM),
+                  test_path_b.value()))
       .InSequence(mock_sequence);
   MtabTestData test_data3[] = {
     MtabTestData(kDeviceNoDCIM, test_path_b.value(), kValidFS),
   };
   AppendToMtabAndRunLoop(test_data3, arraysize(test_data3));
 
   // |kDeviceNoDCIM| should be detached as expected.
   EXPECT_CALL(observer(),
               OnRemovableStorageDetached(GetDeviceId(kDeviceNoDCIM)))
       .InSequence(mock_sequence);
@@ skipping 252 matching lines @@
   EXPECT_TRUE(notifier()->GetDeviceInfoForPath(test_path_a, &device_info));
   EXPECT_EQ(GetDeviceId(kDeviceDCIM1), device_info.device_id);
 
   EXPECT_TRUE(notifier()->GetDeviceInfoForPath(test_path_b, &device_info));
   EXPECT_EQ(GetDeviceId(kDeviceFixed), device_info.device_id);
 
   EXPECT_TRUE(notifier()->GetDeviceInfoForPath(test_path_c, &device_info));
   EXPECT_EQ(GetDeviceId(kDeviceFixed), device_info.device_id);
 }
 
+TEST_F(RemovableDeviceNotificationLinuxTest, DevicePartitionSize) {
+  FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
+  FilePath test_path_b = CreateMountPointWithoutDCIMDir(kMountPointB);
+  ASSERT_FALSE(test_path_a.empty());
+  ASSERT_FALSE(test_path_b.empty());
+
+  MtabTestData test_data1[] = {
+    MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
+    MtabTestData(kDeviceNoDCIM, test_path_b.value(), kValidFS),
+    MtabTestData(kDeviceFixed, kInvalidPath, kInvalidFS),
+  };
+  EXPECT_CALL(observer(), OnRemovableStorageAttached(_, _, _)).Times(2);
+  EXPECT_CALL(observer(), OnRemovableStorageDetached(_)).Times(0);
+  AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
+
+  EXPECT_EQ(GetDevicePartitionSize(kDeviceDCIM1),
+            notifier()->GetStorageSize(test_path_a.value()));
+  EXPECT_EQ(GetDevicePartitionSize(kDeviceNoDCIM),
+            notifier()->GetStorageSize(test_path_b.value()));
+  EXPECT_EQ(GetDevicePartitionSize(kInvalidPath),
+            notifier()->GetStorageSize(kInvalidPath));
+}
+
 }  // namespace
 
 }  // namespace chrome