[Media Galleries] Populate volume metadata in ChromeOS/Linux

chrome/browser/storage_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/storage_monitor/removable_device_notifications_linux.h"
 
 #include <mntent.h>
 #include <stdio.h>
@@ skipping 51 matching lines @@
     8773 },
   { kDeviceDCIM3, "VendorModelSerial:::WEM319X792", "TEST_USB_MODEL_3",
     MediaStorageUtil::REMOVABLE_MASS_STORAGE_WITH_DCIM, 22837 },
   { kDeviceNoDCIM, "UUID:ABCD-1234", "TEST_USB_MODEL_4",
     MediaStorageUtil::REMOVABLE_MASS_STORAGE_NO_DCIM, 512 },
   { kDeviceFixed, "UUID:743A-2349", "743A-2349",
     MediaStorageUtil::FIXED_MASS_STORAGE, 17282 },
 };
 
 void GetDeviceInfo(const base::FilePath& device_path,
-                   std::string* id,
+                   const base::FilePath& mount_point,
+                   std::string* device_id,
                    string16* name,
                    bool* removable,
-                   uint64* partition_size_in_bytes) {
+                   uint64* partition_size_in_bytes,
+                   string16* out_volume_label,
+                   string16* out_vendor_name,
+                   string16* out_model_name) {
   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);
+      MediaStorageUtil::Type type = kTestDeviceData[i].type;
       if (removable) {
-        MediaStorageUtil::Type type = kTestDeviceData[i].type;
         *removable =
           (type == MediaStorageUtil::REMOVABLE_MASS_STORAGE_WITH_DCIM) ||
           (type == MediaStorageUtil::REMOVABLE_MASS_STORAGE_NO_DCIM);
       }
+      if (device_id) {
+        *device_id =
+            MediaStorageUtil::MakeDeviceId(type, kTestDeviceData[i].unique_id);
+      }
       if (partition_size_in_bytes)
         *partition_size_in_bytes = kTestDeviceData[i].partition_size_in_bytes;
+      if (out_volume_label)
+        *out_volume_label = ASCIIToUTF16("volume label");
+      if (out_vendor_name)
+        *out_vendor_name = ASCIIToUTF16("vendor name");
+      if (out_model_name)
+        *out_model_name = ASCIIToUTF16("model name");
       return;
     }
   }
   NOTREACHED();
 }
 
 uint64 GetDevicePartitionSize(const std::string& device) {
   for (size_t i = 0; i < arraysize(kTestDeviceData); ++i) {
     if (device == kTestDeviceData[i].device_path)
       return kTestDeviceData[i].partition_size_in_bytes;
@@ skipping 502 matching lines @@
 
 TEST_F(RemovableDeviceNotificationLinuxTest, DeviceLookUp) {
   base::FilePath test_path_a = CreateMountPointWithDCIMDir(kMountPointA);
   base::FilePath test_path_b = CreateMountPointWithoutDCIMDir(kMountPointB);
   base::FilePath test_path_c = CreateMountPointWithoutDCIMDir(kMountPointC);
   ASSERT_FALSE(test_path_a.empty());
   ASSERT_FALSE(test_path_b.empty());
   ASSERT_FALSE(test_path_c.empty());
 
   // Attach to one first.
-  // (*'d mounts are those RemovableStorageNotifications knows about.)
+  // (starred mounts are those RemovableStorageNotifications knows about.)
   // kDeviceDCIM1  -> kMountPointA *
   // kDeviceNoDCIM -> kMountPointB *
   // kDeviceFixed  -> kMountPointC
   MtabTestData test_data1[] = {
     MtabTestData(kDeviceDCIM1, test_path_a.value(), kValidFS),
     MtabTestData(kDeviceNoDCIM, test_path_b.value(), kValidFS),
     MtabTestData(kDeviceFixed, test_path_c.value(), kValidFS),
   };
   AppendToMtabAndRunLoop(test_data1, arraysize(test_data1));
   EXPECT_EQ(2, observer().attach_calls());
   EXPECT_EQ(0, observer().detach_calls());
 
   StorageMonitor::StorageInfo device_info;
   EXPECT_TRUE(notifier()->GetStorageInfoForPath(test_path_a, &device_info));
   EXPECT_EQ(GetDeviceId(kDeviceDCIM1), device_info.device_id);
   EXPECT_EQ(test_path_a.value(), device_info.location);
   EXPECT_EQ(GetDeviceName(kDeviceDCIM1), device_info.name);
+  EXPECT_EQ(88788ULL, device_info.total_size_in_bytes);
+  EXPECT_EQ(ASCIIToUTF16("volume label"), device_info.storage_label);
+  EXPECT_EQ(ASCIIToUTF16("vendor name"), device_info.vendor_name);
+  EXPECT_EQ(ASCIIToUTF16("model name"), device_info.model_name);
 
   EXPECT_TRUE(notifier()->GetStorageInfoForPath(test_path_b, &device_info));
   EXPECT_EQ(GetDeviceId(kDeviceNoDCIM), device_info.device_id);
   EXPECT_EQ(test_path_b.value(), device_info.location);
   EXPECT_EQ(GetDeviceName(kDeviceNoDCIM), device_info.name);
 
   EXPECT_TRUE(notifier()->GetStorageInfoForPath(test_path_c, &device_info));
   EXPECT_EQ(GetDeviceId(kDeviceFixed), device_info.device_id);
   EXPECT_EQ(test_path_c.value(), device_info.location);
   EXPECT_EQ(GetDeviceName(kDeviceFixed), device_info.name);
@@ skipping 53 matching lines @@
             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