[Win, MediaGallery] Enumerate and handle mtp device attach/detach events.

chrome/browser/system_monitor/removable_device_notifications_window_win_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.
 
 #include "chrome/browser/system_monitor/removable_device_notifications_window_win.h"
 
 #include <dbt.h>
 
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
+#include "base/memory/ref_counted.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_storage_util.h"
+#include "chrome/browser/system_monitor/portable_device_watcher_win.h"
+#include "chrome/browser/system_monitor/removable_device_constants.h"
 #include "chrome/browser/system_monitor/volume_mount_watcher_win.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace chrome {
+
 namespace {
 
 using content::BrowserThread;
-using chrome::RemovableDeviceNotificationsWindowWin;
+
+// Mtp device interface path constants.
+const char16 kMtpDeviceWithInvalidInfo[] =
+    L"\\?\usb#vid_00&pid_00#0&2&1#{0000-0000-0000-0000-0000})";
+const char16 kMtpDeviceWithValidInfo[] =
+    L"\\?\usb#vid_ff&pid_000f#32&2&1#{abcd-1234-ffde-1112-9172})";
+const char16 kMtpDeviceWithMultipleStorage[] =
+    L"\\?\usb#vid_ff&pid_18#32&2&1#{ab33-1de4-f22e-1882-9724})";
+
+// Sample mtp device storage information.
+const char16 kMtpDeviceFriendlyName[] = L"Camera V1.1";
+const char16 kStorageLabelA[] = L"Camera V1.1 (s10001)";
+const char16 kStorageLabelB[] = L"Camera V1.1 (s20001)";
+const char16 kStorageObjectIdA[] = L"s10001";
+const char16 kStorageObjectIdB[] = L"s20001";
+const char kStorageUniqueIdA[] =
+    "mtp:StorageSerial:SID-{s10001, D, 12378}:123123";
+const char kStorageUniqueIdB[] =
+    "mtp:StorageSerial:SID-{s20001, S, 2238}:123123";
 
 // Inputs of 'A:\' - 'Z:\' are valid. 'N:\' is not removable.
-bool GetDeviceDetails(const FilePath& device_path, string16* device_location,
-                      std::string* unique_id, string16* name, bool* removable) {
+bool GetMassStorageDeviceDetails(const FilePath& device_path,
+                                 string16* device_location,
+                                 std::string* unique_id,
+                                 string16* name,
+                                 bool* removable) {
   if (device_path.value().length() != 3 || device_path.value()[0] < L'A' ||
       device_path.value()[0] > L'Z') {
     return false;
   }
 
   if (device_location)
     *device_location = device_path.value();
   if (unique_id) {
     *unique_id = "\\\\?\\Volume{00000000-0000-0000-0000-000000000000}\\";
     (*unique_id)[11] = device_path.value()[0];
@@ skipping 16 matching lines @@
   result.push_back(DriveNumberToFilePath(0));
   result.push_back(DriveNumberToFilePath(1));
   result.push_back(DriveNumberToFilePath(2));
   result.push_back(DriveNumberToFilePath(3));
   result.push_back(DriveNumberToFilePath(5));
   result.push_back(DriveNumberToFilePath(7));
   result.push_back(DriveNumberToFilePath(25));
   return result;
 }
 
+// Returns the persistent storage unique id of the device specified by the
+// |pnp_device_id|. |storage_object_id| specifies the temporary object
+// identifier that uniquely identifies the object on the device.
+std::string GetMtpStorageUniqueId(const string16& pnp_device_id,
+                                  const string16& storage_object_id)  {
+  if (storage_object_id == kStorageObjectIdA)
+    return kStorageUniqueIdA;
+
+  return (storage_object_id == kStorageObjectIdB) ?
+         kStorageUniqueIdB : std::string();
+}
+
+// Returns the storage name of the device specified by |pnp_device_id|.
+// |storage_object_id| specifies the temporary object identifier that
+// uniquely identifies the object on the device.
+string16 GetMtpStorageName(const string16& pnp_device_id,
+                           const string16& storage_object_id) {
+  if (pnp_device_id == kMtpDeviceWithInvalidInfo)
+    return string16();
+
+  if (storage_object_id == kStorageObjectIdA)
+    return kStorageLabelA;
+
+  return (storage_object_id == kStorageObjectIdB) ?
+         kStorageLabelB : string16();
+}
+
+// Returns a list of storage object identifiers of the device given a
+// |pnp_device_id|.
+std::vector<string16> GetMtpStorageObjectIds(const string16& pnp_device_id) {
+  std::vector<string16> storage_object_ids;
+  storage_object_ids.push_back(kStorageObjectIdA);
+
+  if (pnp_device_id == kMtpDeviceWithMultipleStorage)
+    storage_object_ids.push_back(kStorageObjectIdB);
+  return storage_object_ids;
+}
+
+// Gets the mtp device storage details given a |pnp_device_id| and
+// |storage_object_id|. On success, returns true and fills in
+// |device_location|, |unique_id| and |name|.
+void GetMtpStorageDetails(const string16& pnp_device_id,
+                          const string16& storage_object_id,
+                          string16* device_location,
+                          std::string* unique_id,
+                          string16* name) {
+  std::string storage_unique_id = GetMtpStorageUniqueId(pnp_device_id,
+                                                        storage_object_id);
+
+  if (device_location) {
+    std::string root_path("\\\\");
+    *device_location = UTF8ToUTF16(root_path + storage_unique_id);
+  }
+
+  if (unique_id)
+    *unique_id = storage_unique_id;
+
+  if (name)
+    *name = GetMtpStorageName(pnp_device_id, storage_object_id);
+}
+
+// Returns a list of device storage details for the given device specified by
+// |pnp_device_id|.
+std::vector<PortableDeviceWatcherWin::DeviceStorageInfo>
+GetDeviceStorageInfoList(const string16& pnp_device_id) {
+  std::vector<PortableDeviceWatcherWin::DeviceStorageInfo> storage_info_list;
+  std::vector<string16> storage_object_ids =
+      GetMtpStorageObjectIds(pnp_device_id);
+  for (size_t index = 0; index < storage_object_ids.size(); ++index) {
+    PortableDeviceWatcherWin::DeviceStorageInfo storage;
+    storage.unique_id = GetMtpStorageUniqueId(pnp_device_id,
+                                              storage_object_ids[index]);
+    storage.storage_object_id = storage_object_ids[index];
+    storage_info_list.push_back(storage);
+  }
+  return storage_info_list;
+}
+
 }  // namespace
 
-namespace chrome {
+// Wrapper class for testing PortableDeviceWatcherWin.
+class TestPortableDeviceWatcherWin : public PortableDeviceWatcherWin {
+ public:
+  TestPortableDeviceWatcherWin();
+  virtual ~TestPortableDeviceWatcherWin();
+
+ private:
+  // Override PortableDeviceWatcherWin::
+  virtual void EnumerateAttachedDevices() OVERRIDE;
+  virtual void HandleDeviceAttachEvent(const string16& pnp_device_id) OVERRIDE;
+
+  DISALLOW_COPY_AND_ASSIGN(TestPortableDeviceWatcherWin);
+};
 
 // Wrapper class for testing VolumeMountWatcherWin.
 class TestVolumeMountWatcherWin : public VolumeMountWatcherWin {
  public:
-  TestVolumeMountWatcherWin() : pre_attach_devices_(false) {
-  }
+  TestVolumeMountWatcherWin();
 
-  // Override VolumeMountWatcherWin::GetDeviceInfo().
-  virtual bool GetDeviceInfo(const FilePath& device_path,
-    string16* device_location, std::string* unique_id, string16* name,
-    bool* removable) OVERRIDE {
-    return GetDeviceDetails(device_path, device_location, unique_id, name,
-                            removable);
-  }
-
-  // Override VolumeMountWatcherWin::GetAttachedDevices().
-  virtual std::vector<FilePath> GetAttachedDevices() OVERRIDE{
-    if (pre_attach_devices_)
-      return GetTestAttachedDevices();
-    return std::vector<FilePath>();
-  }
-
-  void set_pre_attach_devices(bool pre_attach_devices) {
-    pre_attach_devices_ = pre_attach_devices;
-  }
+  void set_pre_attach_devices(bool pre_attach_devices);
 
  private:
   // Private, this class is ref-counted.
-  virtual ~TestVolumeMountWatcherWin() {
-  }
+  virtual ~TestVolumeMountWatcherWin();
+
+  // Override VolumeMountWatcherWin::
+  virtual bool GetDeviceInfo(const FilePath& device_path,
+                             string16* device_location,
+                             std::string* unique_id,
+                             string16* name,
+                             bool* removable) OVERRIDE;
+  virtual std::vector<FilePath> GetAttachedDevices() OVERRIDE;
 
   // Set to true to pre-attach test devices.
   bool pre_attach_devices_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestVolumeMountWatcherWin);
 };
 
 // Wrapper class for testing RemovableDeviceNotificationsWindowWin.
 class TestRemovableDeviceNotificationsWindowWin
     : public RemovableDeviceNotificationsWindowWin {
  public:
-  explicit TestRemovableDeviceNotificationsWindowWin(
-      TestVolumeMountWatcherWin* volume_mount_watcher)
-      : RemovableDeviceNotificationsWindowWin(volume_mount_watcher),
-        volume_mount_watcher_(volume_mount_watcher) {
-    DCHECK(volume_mount_watcher_);
-  }
+  TestRemovableDeviceNotificationsWindowWin(
+      TestVolumeMountWatcherWin* volume_mount_watcher,
+      TestPortableDeviceWatcherWin* portable_device_watcher);
 
-  virtual ~TestRemovableDeviceNotificationsWindowWin() {
-  }
+  virtual ~TestRemovableDeviceNotificationsWindowWin();
 
-  void InitWithTestData() {
-    volume_mount_watcher_->set_pre_attach_devices(false);
-    Init();
-  }
-
-  void InitWithTestDataAndAttachedDevices() {
-    volume_mount_watcher_->set_pre_attach_devices(true);
-    Init();
-  }
-
-  void InjectDeviceChange(UINT event_type, DWORD data) {
-    OnDeviceChange(event_type, data);
-  }
+  void InitWithTestData();
+  void InitWithTestDataAndAttachedDevices();
+  void InjectDeviceChange(UINT event_type, DWORD data);
 
  private:
   scoped_refptr<TestVolumeMountWatcherWin> volume_mount_watcher_;
 };
 
 class RemovableDeviceNotificationsWindowWinTest : public testing::Test {
  public:
-  RemovableDeviceNotificationsWindowWinTest()
-      : ui_thread_(BrowserThread::UI, &message_loop_),
-        file_thread_(BrowserThread::FILE, &message_loop_) { }
-  virtual ~RemovableDeviceNotificationsWindowWinTest() { }
+  RemovableDeviceNotificationsWindowWinTest();
+  virtual ~RemovableDeviceNotificationsWindowWinTest();
 
  protected:
-  virtual void SetUp() OVERRIDE {
-    ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    volume_mount_watcher_ = new TestVolumeMountWatcherWin;
-    window_.reset(new TestRemovableDeviceNotificationsWindowWin(
-        volume_mount_watcher_.get()));
-    window_->InitWithTestData();
-    message_loop_.RunAllPending();
-    system_monitor_.AddDevicesChangedObserver(&observer_);
-  }
+  virtual void SetUp() OVERRIDE;
+  virtual void TearDown();
 
-  virtual void TearDown() {
-    message_loop_.RunAllPending();
-    system_monitor_.RemoveDevicesChangedObserver(&observer_);
-  }
+  void AddMassStorageDeviceAttachExpectation(FilePath drive);
+  void PreAttachDevices();
 
-  void AddAttachExpectation(FilePath drive) {
-    std::string unique_id;
-    string16 device_name;
-    bool removable;
-    ASSERT_TRUE(GetDeviceDetails(drive, NULL, &unique_id, &device_name,
-                &removable));
-    if (removable) {
-      MediaStorageUtil::Type type =
-          MediaStorageUtil::REMOVABLE_MASS_STORAGE_NO_DCIM;
-      std::string device_id = MediaStorageUtil::MakeDeviceId(type, unique_id);
-      EXPECT_CALL(observer_, OnRemovableStorageAttached(device_id, device_name,
-                                                        drive.value()))
-          .Times(1);
-    }
-  }
+  // Runs all the pending tasks on UI thread, FILE thread and blocking thread.
+  void RunAllPending();
 
-  void PreAttachDevices() {
-    window_.reset();
-    {
-      testing::InSequence sequence;
-      std::vector<FilePath> initial_devices = GetTestAttachedDevices();
-      for (size_t i = 0; i < initial_devices.size(); i++)
-        AddAttachExpectation(initial_devices[i]);
-    }
-    window_.reset(new TestRemovableDeviceNotificationsWindowWin(
-        volume_mount_watcher_.get()));
-    window_->InitWithTestDataAndAttachedDevices();
-    message_loop_.RunAllPending();
-  }
-
-  void DoDevicesAttachedTest(const std::vector<int>& device_indices);
-  void DoDevicesDetachedTest(const std::vector<int>& device_indices);
+  void DoMassStorageDeviceAttachedTest(const std::vector<int>& device_indices);
+  void DoMassStorageDevicesDetachedTest(const std::vector<int>& device_indices);
+  void DoMtpDeviceAttachedTest(const string16& pnp_device_id);
+  void DoMtpDeviceDetachedTest(const string16& pnp_device_id);
 
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
 
   base::SystemMonitor system_monitor_;
   base::MockDevicesChangedObserver observer_;
   scoped_ptr<TestRemovableDeviceNotificationsWindowWin> window_;
   scoped_refptr<TestVolumeMountWatcherWin> volume_mount_watcher_;
 };
 
-void RemovableDeviceNotificationsWindowWinTest::DoDevicesAttachedTest(
-    const std::vector<int>& device_indices) {
+// TestPortableDeviceWatcherWin implementation.
+TestPortableDeviceWatcherWin::TestPortableDeviceWatcherWin() {
+}
+
+TestPortableDeviceWatcherWin::~TestPortableDeviceWatcherWin() {
+}
+
+void TestPortableDeviceWatcherWin::EnumerateAttachedDevices() {
+}
+
+void TestPortableDeviceWatcherWin::HandleDeviceAttachEvent(
+    const string16& pnp_device_id) {
+  DeviceDetails device_details;
+  std::vector<DeviceStorageInfo> storage_info_list;
+  device_details.storage_info_list = GetDeviceStorageInfoList(pnp_device_id);
+  device_details.name = (pnp_device_id != kMtpDeviceWithInvalidInfo) ?
+                        kMtpDeviceFriendlyName : string16();
+  device_details.location = pnp_device_id;
+  OnHandleDeviceAttachEvent(device_details);
+}
+
+// TestVolumeMountWatcherWin implementation.
+TestVolumeMountWatcherWin::TestVolumeMountWatcherWin()
+    : pre_attach_devices_(false) {
+}
+
+void TestVolumeMountWatcherWin::set_pre_attach_devices(
+    bool pre_attach_devices) {
+    pre_attach_devices_ = pre_attach_devices;
+}
+
+TestVolumeMountWatcherWin::~TestVolumeMountWatcherWin() {
+}
+
+bool TestVolumeMountWatcherWin::GetDeviceInfo(const FilePath& device_path,
+                                              string16* device_location,
+                                              std::string* unique_id,
+                                              string16* name,
+                                              bool* removable) {
+  return GetMassStorageDeviceDetails(device_path, device_location, unique_id,
+                                     name, removable);
+}
+
+std::vector<FilePath> TestVolumeMountWatcherWin::GetAttachedDevices() {
+  return pre_attach_devices_ ? GetTestAttachedDevices() :
+                               std::vector<FilePath>();
+}
+
+// TestRemovableDeviceNotificationsWindowWin implementation.
+TestRemovableDeviceNotificationsWindowWin::
+TestRemovableDeviceNotificationsWindowWin(
+    TestVolumeMountWatcherWin* volume_mount_watcher,
+    TestPortableDeviceWatcherWin* portable_device_watcher)
+    : RemovableDeviceNotificationsWindowWin(volume_mount_watcher,
+                                            portable_device_watcher),
+      volume_mount_watcher_(volume_mount_watcher) {
+  DCHECK(volume_mount_watcher_);
+}
+
+TestRemovableDeviceNotificationsWindowWin::
+~TestRemovableDeviceNotificationsWindowWin() {
+}
+
+void TestRemovableDeviceNotificationsWindowWin::InitWithTestData() {
+  volume_mount_watcher_->set_pre_attach_devices(false);
+  Init();
+}
+
+void TestRemovableDeviceNotificationsWindowWin::
+InitWithTestDataAndAttachedDevices() {
+  volume_mount_watcher_->set_pre_attach_devices(true);
+  Init();
+}
+
+void TestRemovableDeviceNotificationsWindowWin::InjectDeviceChange(
+    UINT event_type, DWORD data) {
+  OnDeviceChange(event_type, data);
+}
+
+// RemovableDeviceNotificationsWindowWinTest implementation.
+RemovableDeviceNotificationsWindowWinTest::
+RemovableDeviceNotificationsWindowWinTest()
+   : ui_thread_(BrowserThread::UI, &message_loop_),
+     file_thread_(BrowserThread::FILE, &message_loop_) {
+}
+
+RemovableDeviceNotificationsWindowWinTest::
+~RemovableDeviceNotificationsWindowWinTest() {
+}
+
+void RemovableDeviceNotificationsWindowWinTest::SetUp() {
+  ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  volume_mount_watcher_ = new TestVolumeMountWatcherWin;
+  window_.reset(new TestRemovableDeviceNotificationsWindowWin(
+      volume_mount_watcher_.get(), new TestPortableDeviceWatcherWin));
+  window_->InitWithTestData();
+  RunAllPending();
+  system_monitor_.AddDevicesChangedObserver(&observer_);
+}
+
+void RemovableDeviceNotificationsWindowWinTest::TearDown() {
+  RunAllPending();
+  system_monitor_.RemoveDevicesChangedObserver(&observer_);
+}
+
+void RemovableDeviceNotificationsWindowWinTest::
+AddMassStorageDeviceAttachExpectation(FilePath drive) {
+  std::string unique_id;
+  string16 device_name;
+  bool removable;
+  ASSERT_TRUE(GetMassStorageDeviceDetails(drive, NULL, &unique_id,
+                                          &device_name, &removable));
+  if (removable) {
+    MediaStorageUtil::Type type =
+        MediaStorageUtil::REMOVABLE_MASS_STORAGE_NO_DCIM;
+    std::string device_id = MediaStorageUtil::MakeDeviceId(type, unique_id);
+    EXPECT_CALL(observer_, OnRemovableStorageAttached(device_id, device_name,
+                                                      drive.value()))
+        .Times(1);
+  }
+}
+
+void RemovableDeviceNotificationsWindowWinTest::PreAttachDevices() {
+  window_.reset();
+  {
+    testing::InSequence sequence;
+    std::vector<FilePath> initial_devices = GetTestAttachedDevices();
+    for (size_t i = 0; i < initial_devices.size(); i++)
+      AddMassStorageDeviceAttachExpectation(initial_devices[i]);
+  }
+  window_.reset(new TestRemovableDeviceNotificationsWindowWin(
+      volume_mount_watcher_.get(),  new TestPortableDeviceWatcherWin));
+  window_->InitWithTestDataAndAttachedDevices();
+  RunAllPending();
+}
+
+void RemovableDeviceNotificationsWindowWinTest::RunAllPending() {
+  message_loop_.RunAllPending();
+}
+
+void RemovableDeviceNotificationsWindowWinTest::
+DoMassStorageDeviceAttachedTest(const std::vector<int>& device_indices) {
   DEV_BROADCAST_VOLUME volume_broadcast;
   volume_broadcast.dbcv_size = sizeof(volume_broadcast);
   volume_broadcast.dbcv_devicetype = DBT_DEVTYP_VOLUME;
   volume_broadcast.dbcv_unitmask = 0x0;
   volume_broadcast.dbcv_flags = 0x0;
   {
     testing::InSequence sequence;
     for (std::vector<int>::const_iterator it = device_indices.begin();
          it != device_indices.end();
          ++it) {
       volume_broadcast.dbcv_unitmask |= 0x1 << *it;
-      AddAttachExpectation(DriveNumberToFilePath(*it));
+      AddMassStorageDeviceAttachExpectation(DriveNumberToFilePath(*it));
     }
   }
   window_->InjectDeviceChange(DBT_DEVICEARRIVAL,
                               reinterpret_cast<DWORD>(&volume_broadcast));
-  message_loop_.RunAllPending();
+  RunAllPending();
 }
 
-void RemovableDeviceNotificationsWindowWinTest::DoDevicesDetachedTest(
-    const std::vector<int>& device_indices) {
+void RemovableDeviceNotificationsWindowWinTest::
+DoMassStorageDevicesDetachedTest(const std::vector<int>& device_indices) {
   DEV_BROADCAST_VOLUME volume_broadcast;
   volume_broadcast.dbcv_size = sizeof(volume_broadcast);
   volume_broadcast.dbcv_devicetype = DBT_DEVTYP_VOLUME;
   volume_broadcast.dbcv_unitmask = 0x0;
   volume_broadcast.dbcv_flags = 0x0;
   {
     testing::InSequence sequence;
     for (std::vector<int>::const_iterator it = device_indices.begin();
          it != device_indices.end();
          ++it) {
       volume_broadcast.dbcv_unitmask |= 0x1 << *it;
       std::string unique_id;
       bool removable;
-      ASSERT_TRUE(GetDeviceDetails(DriveNumberToFilePath(*it), NULL, &unique_id,
-                                   NULL, &removable));
+      ASSERT_TRUE(GetMassStorageDeviceDetails(DriveNumberToFilePath(*it), NULL,
+                                              &unique_id, NULL, &removable));
       if (removable) {
         MediaStorageUtil::Type type =
             MediaStorageUtil::REMOVABLE_MASS_STORAGE_NO_DCIM;
         std::string device_id = MediaStorageUtil::MakeDeviceId(type, unique_id);
         EXPECT_CALL(observer_, OnRemovableStorageDetached(device_id)).Times(1);
       }
     }
   }
   window_->InjectDeviceChange(DBT_DEVICEREMOVECOMPLETE,
                               reinterpret_cast<DWORD>(&volume_broadcast));
-  message_loop_.RunAllPending();
+  RunAllPending();
+}
+
+void RemovableDeviceNotificationsWindowWinTest::DoMtpDeviceAttachedTest(
+    const string16& pnp_device_id) {
+  GUID guidDevInterface = GUID_NULL;
+  HRESULT hr = CLSIDFromString(kWPDDevInterfaceGUID, &guidDevInterface);
+  if (FAILED(hr))
+    return;
+
+  size_t device_id_size = pnp_device_id.size() * sizeof(char16);
+  size_t size = sizeof(DEV_BROADCAST_DEVICEINTERFACE) + device_id_size;
+  scoped_ptr_malloc<DEV_BROADCAST_DEVICEINTERFACE> dev_interface_broadcast(
+      static_cast<DEV_BROADCAST_DEVICEINTERFACE*>(malloc(size)));
+  DCHECK(dev_interface_broadcast.get());
+  ZeroMemory(dev_interface_broadcast.get(), size);
+  dev_interface_broadcast->dbcc_size = size;
+  dev_interface_broadcast->dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
+  dev_interface_broadcast->dbcc_classguid = guidDevInterface;
+  memcpy(dev_interface_broadcast->dbcc_name, pnp_device_id.data(),
+         device_id_size);
+  {
+    testing::InSequence sequence;
+    std::vector<string16> storage_object_ids =
+        GetMtpStorageObjectIds(pnp_device_id);
+    for (size_t index = 0; index < storage_object_ids.size(); ++index) {
+      std::string unique_id;
+      string16 name;
+      string16 location;
+      GetMtpStorageDetails(pnp_device_id, storage_object_ids[index],
+                           &location, &unique_id, &name);
+      int cardinality = 1;
+      if (name.empty() || unique_id.empty())
+        cardinality = 0;
+      EXPECT_CALL(observer_, OnRemovableStorageAttached(unique_id, name,
+                                                        location))
+          .Times(cardinality);
+    }
+  }
+  window_->InjectDeviceChange(
+      DBT_DEVICEARRIVAL,
+      reinterpret_cast<DWORD>(dev_interface_broadcast.get()));
+  RunAllPending();
+}
+
+void RemovableDeviceNotificationsWindowWinTest::DoMtpDeviceDetachedTest(
+    const string16& pnp_device_id) {
+  GUID guidDevInterface = GUID_NULL;
+  HRESULT hr = CLSIDFromString(kWPDDevInterfaceGUID, &guidDevInterface);
+  if (FAILED(hr))
+    return;
+
+  size_t device_id_size = pnp_device_id.size() * sizeof(char16);
+  size_t size = sizeof(DEV_BROADCAST_DEVICEINTERFACE) + device_id_size;
+
+  scoped_ptr_malloc<DEV_BROADCAST_DEVICEINTERFACE> dev_interface_broadcast(
+      static_cast<DEV_BROADCAST_DEVICEINTERFACE*>(malloc(size)));
+  DCHECK(dev_interface_broadcast.get());
+  ZeroMemory(dev_interface_broadcast.get(), size);
+  dev_interface_broadcast->dbcc_size = size;
+  dev_interface_broadcast->dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
+  dev_interface_broadcast->dbcc_classguid = guidDevInterface;
+  memcpy(dev_interface_broadcast->dbcc_name, pnp_device_id.data(),
+         device_id_size);
+  {
+    testing::InSequence sequence;
+    std::vector<string16> storage_object_ids =
+        GetMtpStorageObjectIds(pnp_device_id);
+    for (size_t index = 0; index < storage_object_ids.size(); ++index) {
+      std::string unique_id;
+      string16 name;
+      GetMtpStorageDetails(pnp_device_id, storage_object_ids[index], NULL,
+                           &unique_id, &name);
+      int cardinality = 1;
+      if (name.empty() || unique_id.empty())
+        cardinality = 0;
+      EXPECT_CALL(observer_, OnRemovableStorageDetached(unique_id))
+          .Times(cardinality);
+    }
+  }
+  window_->InjectDeviceChange(
+      DBT_DEVICEREMOVECOMPLETE,
+      reinterpret_cast<DWORD>(dev_interface_broadcast.get()));
+  RunAllPending();
 }
 
 TEST_F(RemovableDeviceNotificationsWindowWinTest, RandomMessage) {
   window_->InjectDeviceChange(DBT_DEVICEQUERYREMOVE, NULL);
-  message_loop_.RunAllPending();
+  RunAllPending();
 }
 
 TEST_F(RemovableDeviceNotificationsWindowWinTest, DevicesAttached) {
   std::vector<int> device_indices;
   device_indices.push_back(1);
   device_indices.push_back(5);
   device_indices.push_back(7);
   device_indices.push_back(13);
 
-  DoDevicesAttachedTest(device_indices);
+  DoMassStorageDeviceAttachedTest(device_indices);
 }
 
 TEST_F(RemovableDeviceNotificationsWindowWinTest, DevicesAttachedHighBoundary) {
   std::vector<int> device_indices;
   device_indices.push_back(25);
 
-  DoDevicesAttachedTest(device_indices);
+  DoMassStorageDeviceAttachedTest(device_indices);
 }
 
 TEST_F(RemovableDeviceNotificationsWindowWinTest, DevicesAttachedLowBoundary) {
   std::vector<int> device_indices;
   device_indices.push_back(0);
 
-  DoDevicesAttachedTest(device_indices);
+  DoMassStorageDeviceAttachedTest(device_indices);
 }
 
 TEST_F(RemovableDeviceNotificationsWindowWinTest, DevicesAttachedAdjacentBits) {
   std::vector<int> device_indices;
   device_indices.push_back(0);
   device_indices.push_back(1);
   device_indices.push_back(2);
   device_indices.push_back(3);
 
-  DoDevicesAttachedTest(device_indices);
+  DoMassStorageDeviceAttachedTest(device_indices);
 }
 
 TEST_F(RemovableDeviceNotificationsWindowWinTest, DevicesDetached) {
   PreAttachDevices();
 
   std::vector<int> device_indices;
   device_indices.push_back(1);
   device_indices.push_back(5);
   device_indices.push_back(7);
   device_indices.push_back(13);
 
-  DoDevicesDetachedTest(device_indices);
+  DoMassStorageDevicesDetachedTest(device_indices);
 }
 
 TEST_F(RemovableDeviceNotificationsWindowWinTest, DevicesDetachedHighBoundary) {
   PreAttachDevices();
 
   std::vector<int> device_indices;
   device_indices.push_back(25);
 
-  DoDevicesDetachedTest(device_indices);
+  DoMassStorageDevicesDetachedTest(device_indices);
 }
 
 TEST_F(RemovableDeviceNotificationsWindowWinTest, DevicesDetachedLowBoundary) {
   PreAttachDevices();
 
   std::vector<int> device_indices;
   device_indices.push_back(0);
 
-  DoDevicesDetachedTest(device_indices);
+  DoMassStorageDevicesDetachedTest(device_indices);
 }
 
 TEST_F(RemovableDeviceNotificationsWindowWinTest, DevicesDetachedAdjacentBits) {
   PreAttachDevices();
 
   std::vector<int> device_indices;
   device_indices.push_back(0);
   device_indices.push_back(1);
   device_indices.push_back(2);
   device_indices.push_back(3);
 
-  DoDevicesDetachedTest(device_indices);
+  DoMassStorageDevicesDetachedTest(device_indices);
 }
 
 TEST_F(RemovableDeviceNotificationsWindowWinTest, DeviceInfoFoPath) {
   PreAttachDevices();
 
   // An invalid path.
   EXPECT_FALSE(window_->GetDeviceInfoForPath(FilePath(L"COM1:\\"), NULL));
 
   // An unconnected removable device.
   EXPECT_FALSE(window_->GetDeviceInfoForPath(FilePath(L"E:\\"), NULL));
 
   // A connected removable device.
   FilePath removable_device(L"F:\\");
   base::SystemMonitor::RemovableStorageInfo device_info;
   EXPECT_TRUE(window_->GetDeviceInfoForPath(removable_device, &device_info));
 
   std::string unique_id;
   string16 device_name;
   bool removable;
-  ASSERT_TRUE(GetDeviceDetails(removable_device, NULL, &unique_id, &device_name,
-                               &removable));
+  ASSERT_TRUE(GetMassStorageDeviceDetails(removable_device, NULL, &unique_id,
+                                          &device_name, &removable));
   EXPECT_TRUE(removable);
   std::string device_id = MediaStorageUtil::MakeDeviceId(
       MediaStorageUtil::REMOVABLE_MASS_STORAGE_NO_DCIM, unique_id);
   EXPECT_EQ(device_id, device_info.device_id);
   EXPECT_EQ(device_name, device_info.name);
   EXPECT_EQ(removable_device.value(), device_info.location);
 
   // A fixed device.
   FilePath fixed_device(L"N:\\");
   EXPECT_TRUE(window_->GetDeviceInfoForPath(fixed_device, &device_info));
 
-  ASSERT_TRUE(GetDeviceDetails(fixed_device, NULL, &unique_id, &device_name,
-                               &removable));
+  ASSERT_TRUE(GetMassStorageDeviceDetails(fixed_device, NULL, &unique_id,
+                                          &device_name, &removable));
   EXPECT_FALSE(removable);
   device_id = MediaStorageUtil::MakeDeviceId(
       MediaStorageUtil::FIXED_MASS_STORAGE, unique_id);
   EXPECT_EQ(device_id, device_info.device_id);
   EXPECT_EQ(device_name, device_info.name);
   EXPECT_EQ(fixed_device.value(), device_info.location);
 }
 
+// Test to verify basic mtp storage attach and detach notifications.
+TEST_F(RemovableDeviceNotificationsWindowWinTest, MtpDeviceBasicAttachDetach) {
+  // Attach a mtp device.
+  DoMtpDeviceAttachedTest(kMtpDeviceWithValidInfo);
+
+  // Detach the attached device.
+  DoMtpDeviceDetachedTest(kMtpDeviceWithValidInfo);
+}
+
+// When a mtp storage device with invalid storage label and id is
+// attached/detached, there should not be any device attach/detach
+// notifications.
+TEST_F(RemovableDeviceNotificationsWindowWinTest, MtpDeviceWithInvalidInfo) {
+  // Attach the mtp storage with invalid storage info.
+  DoMtpDeviceAttachedTest(kMtpDeviceWithInvalidInfo);
+
+  // Detach the attached storage.
+  DoMtpDeviceDetachedTest(kMtpDeviceWithInvalidInfo);
+}
+
+// Attach a device with two data partitions. Verify that attach/detach
+// notifications are sent out for each removable storage.
+TEST_F(RemovableDeviceNotificationsWindowWinTest,
+       MtpDeviceWithMultipleStorages) {
+  // Attach the mtp device with multiple storage.
+  DoMtpDeviceAttachedTest(kMtpDeviceWithMultipleStorage);
+
+  // Detach the attached device.
+  DoMtpDeviceDetachedTest(kMtpDeviceWithMultipleStorage);
+}
+
 }  // namespace chrome