[Media Gallery] Added code to support mtp device media file system on Windows.

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/bind.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
+#include "base/sequenced_task_runner.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/system_monitor/system_monitor.h"
 #include "base/test/mock_devices_changed_observer.h"
+#include "base/threading/sequenced_worker_pool.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 {
@@ skipping 290 matching lines @@
   // Runs all the pending tasks on UI thread, FILE thread and blocking thread.
   void RunUntilIdle();
 
   void DoMassStorageDeviceAttachedTest(const DeviceIndices& device_indices);
   void DoMassStorageDevicesDetachedTest(const DeviceIndices& device_indices);
 
   // Injects a device attach or detach change (depending on the value of
   // |test_attach|) and tests that the appropriate handler is called.
   void DoMTPDeviceTest(const string16& pnp_device_id, bool test_attach);
 
+  // Gets the MTP details of the storage specified by the |storage_device_id|.
+  // On success, returns true and fills in |pnp_device_id| and
+  // |storage_object_id|.
+  bool GetMTPStorageInfo(const std::string& storage_device_id,
+                         string16* pnp_device_id,
+                         string16* storage_object_id);
+
+  scoped_ptr<TestRemovableDeviceNotificationsWindowWin> window_;
+
+ private:
+  // Gets the MTP details of the storage on the blocking pool thread.
+  void GetMTPStorageInfoOnBlockingThread(const std::string& storage_device_id,
+                                         string16* pnp_device_id,
+                                         string16* storage_object_id,
+                                         bool* result,
+                                         base::WaitableEvent* completion);
+
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
+  scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
 
   base::SystemMonitor system_monitor_;
   base::MockDevicesChangedObserver observer_;
-  scoped_ptr<TestRemovableDeviceNotificationsWindowWin> window_;
   scoped_refptr<TestVolumeMountWatcherWin> volume_mount_watcher_;
 };
 
 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));
+  scoped_refptr<base::SequencedWorkerPool> pool =
+     content::BrowserThread::GetBlockingPool();
+  blocking_task_runner_ =
+        pool->GetSequencedTaskRunner(pool->GetSequenceToken());
   window_->InitWithTestData(false);
   RunUntilIdle();
   system_monitor_.AddDevicesChangedObserver(&observer_);
 }
 
 void RemovableDeviceNotificationsWindowWinTest::TearDown() {
   RunUntilIdle();
   system_monitor_.RemoveDevicesChangedObserver(&observer_);
 }
 
@@ skipping 120 matching lines @@
             .Times((name.empty() || unique_id.empty()) ? 0 : 1);
       }
     }
   }
   window_->InjectDeviceChange(
       test_attach ? DBT_DEVICEARRIVAL : DBT_DEVICEREMOVECOMPLETE,
       reinterpret_cast<DWORD>(dev_interface_broadcast.get()));
   RunUntilIdle();
 }
 
+bool RemovableDeviceNotificationsWindowWinTest::GetMTPStorageInfo(
+    const std::string& storage_device_id,
+    string16* pnp_device_id,
+    string16* storage_object_id) {
+  base::WaitableEvent completion(false, false);
+  bool result = false;
+  blocking_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&RemovableDeviceNotificationsWindowWinTest::
+                     GetMTPStorageInfoOnBlockingThread,
+                 base::Unretained(this),
+                 storage_device_id,
+                 pnp_device_id,
+                 storage_object_id,
+                 &result,
+                 &completion));
+  completion.Wait();
+  return result;
+}
+
+void RemovableDeviceNotificationsWindowWinTest::
+    GetMTPStorageInfoOnBlockingThread(
+        const std::string& storage_device_id,
+        string16* pnp_device_id,
+        string16* storage_object_id,
+        bool* result,
+        base::WaitableEvent* completion) {
+  *result = window_->GetMTPStorageInfoFromDeviceId(storage_device_id,
+                                                   pnp_device_id,
+                                                   storage_object_id);
+  completion->Signal();
+}
+
 TEST_F(RemovableDeviceNotificationsWindowWinTest, RandomMessage) {
   window_->InjectDeviceChange(DBT_DEVICEQUERYREMOVE, NULL);
   RunUntilIdle();
 }
 
 TEST_F(RemovableDeviceNotificationsWindowWinTest, DevicesAttached) {
   DeviceIndices device_indices;
   device_indices.push_back(1);
   device_indices.push_back(5);
   device_indices.push_back(7);
@@ skipping 131 matching lines @@
 }
 
 // Attach a device with two data partitions. Verify that attach/detach
 // notifications are sent out for each removable storage.
 TEST_F(RemovableDeviceNotificationsWindowWinTest,
        MTPDeviceWithMultipleStorageObjects) {
   DoMTPDeviceTest(kMTPDeviceWithMultipleStorageObjects, true);
   DoMTPDeviceTest(kMTPDeviceWithMultipleStorageObjects, false);
 }
 
+// Given a MTP storage persistent id, GetMTPStorageInfo() should fetch the
+// device interface path and local storage object identifier.
+TEST_F(RemovableDeviceNotificationsWindowWinTest, GetMTPStorageInfo) {
+  DoMTPDeviceTest(kMTPDeviceWithValidInfo, true);
+  PortableDeviceWatcherWin::StorageObjects storage_objects =
+      GetDeviceStorageObjects(kMTPDeviceWithValidInfo);
+  for (PortableDeviceWatcherWin::StorageObjects::const_iterator it =
+       storage_objects.begin(); it != storage_objects.end(); ++it) {
+    string16 pnp_device_id;
+    string16 storage_object_id;
+    ASSERT_TRUE(GetMTPStorageInfo(it->object_persistent_id, &pnp_device_id,
+                                  &storage_object_id));
+    EXPECT_EQ(kMTPDeviceWithValidInfo, pnp_device_id);
+    EXPECT_EQ(it->object_persistent_id,
+              GetMTPStorageUniqueId(pnp_device_id, storage_object_id));
+  }
+
+  DoMTPDeviceTest(kMTPDeviceWithValidInfo, false);
+}
+
 }  // namespace chrome