Home | History | Annotate | Download | only in system_storage 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include <vector>
      6 
      7 #include "base/message_loop/message_loop.h"
      8 #include "base/strings/utf_string_conversions.h"
      9 #include "chrome/browser/extensions/api/system_storage/storage_api_test_util.h"
     10 #include "chrome/browser/extensions/extension_apitest.h"
     11 #include "components/storage_monitor/storage_monitor.h"
     12 #include "components/storage_monitor/test_storage_monitor.h"
     13 #include "extensions/browser/api/system_storage/storage_info_provider.h"
     14 #include "extensions/test/extension_test_message_listener.h"
     15 #include "extensions/test/result_catcher.h"
     16 
     17 namespace {
     18 
     19 using extensions::StorageUnitInfoList;
     20 using extensions::test::TestStorageUnitInfo;
     21 using extensions::test::kRemovableStorageData;
     22 using storage_monitor::StorageMonitor;
     23 using storage_monitor::TestStorageMonitor;
     24 
     25 const struct TestStorageUnitInfo kTestingData[] = {
     26   {"dcim:device:001", "0xbeaf", 4098, 1},
     27   {"path:device:002", "/home", 4098, 2},
     28   {"path:device:003", "/data", 10000, 3}
     29 };
     30 
     31 }  // namespace
     32 
     33 class TestStorageInfoProvider : public extensions::StorageInfoProvider {
     34  public:
     35   TestStorageInfoProvider(const struct TestStorageUnitInfo* testing_data,
     36                           size_t n);
     37 
     38  private:
     39   virtual ~TestStorageInfoProvider();
     40 
     41   // StorageInfoProvider implementations.
     42   virtual double GetStorageFreeSpaceFromTransientIdOnFileThread(
     43       const std::string& transient_id) OVERRIDE;
     44 
     45   std::vector<struct TestStorageUnitInfo> testing_data_;
     46 };
     47 
     48 TestStorageInfoProvider::TestStorageInfoProvider(
     49     const struct TestStorageUnitInfo* testing_data, size_t n)
     50         : testing_data_(testing_data, testing_data + n) {
     51 }
     52 
     53 TestStorageInfoProvider::~TestStorageInfoProvider() {
     54 }
     55 
     56 double TestStorageInfoProvider::GetStorageFreeSpaceFromTransientIdOnFileThread(
     57     const std::string& transient_id) {
     58   std::string device_id =
     59       StorageMonitor::GetInstance()->GetDeviceIdForTransientId(
     60           transient_id);
     61   for (size_t i = 0; i < testing_data_.size(); ++i) {
     62     if (testing_data_[i].device_id == device_id) {
     63       return static_cast<double>(testing_data_[i].available_capacity);
     64     }
     65   }
     66   return -1;
     67 }
     68 
     69 class SystemStorageApiTest : public ExtensionApiTest {
     70  public:
     71   SystemStorageApiTest() {}
     72   virtual ~SystemStorageApiTest() {}
     73 
     74   virtual void SetUpOnMainThread() OVERRIDE {
     75     TestStorageMonitor::CreateForBrowserTests();
     76   }
     77 
     78   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
     79     ExtensionApiTest::SetUpInProcessBrowserTestFixture();
     80     message_loop_.reset(new base::MessageLoopForUI);
     81   }
     82 
     83   void SetUpAllMockStorageDevices() {
     84     for (size_t i = 0; i < arraysize(kTestingData); ++i) {
     85       AttachRemovableStorage(kTestingData[i]);
     86     }
     87   }
     88 
     89   void AttachRemovableStorage(
     90       const struct TestStorageUnitInfo& removable_storage_info) {
     91     StorageMonitor::GetInstance()->receiver()->ProcessAttach(
     92         extensions::test::BuildStorageInfoFromTestStorageUnitInfo(
     93             removable_storage_info));
     94   }
     95 
     96   void DetachRemovableStorage(const std::string& id) {
     97     StorageMonitor::GetInstance()->receiver()->ProcessDetach(id);
     98   }
     99 
    100  private:
    101   scoped_ptr<base::MessageLoop> message_loop_;
    102 };
    103 
    104 IN_PROC_BROWSER_TEST_F(SystemStorageApiTest, Storage) {
    105   SetUpAllMockStorageDevices();
    106   TestStorageInfoProvider* provider =
    107       new TestStorageInfoProvider(kTestingData,
    108                                   arraysize(kTestingData));
    109   extensions::StorageInfoProvider::InitializeForTesting(provider);
    110   std::vector<linked_ptr<ExtensionTestMessageListener> > device_ids_listeners;
    111   for (size_t i = 0; i < arraysize(kTestingData); ++i) {
    112     linked_ptr<ExtensionTestMessageListener> listener(
    113         new ExtensionTestMessageListener(
    114             StorageMonitor::GetInstance()->GetTransientIdForDeviceId(
    115                 kTestingData[i].device_id),
    116             false));
    117     device_ids_listeners.push_back(listener);
    118   }
    119   ASSERT_TRUE(RunPlatformAppTest("system/storage")) << message_;
    120   for (size_t i = 0; i < device_ids_listeners.size(); ++i)
    121     EXPECT_TRUE(device_ids_listeners[i]->WaitUntilSatisfied());
    122 }
    123 
    124 IN_PROC_BROWSER_TEST_F(SystemStorageApiTest, StorageAttachment) {
    125   extensions::ResultCatcher catcher;
    126   ExtensionTestMessageListener attach_listener("attach", false);
    127   ExtensionTestMessageListener detach_listener("detach", false);
    128 
    129   EXPECT_TRUE(LoadExtension(
    130       test_data_dir_.AppendASCII("system/storage_attachment")));
    131   // Simulate triggering onAttached event.
    132   ASSERT_TRUE(attach_listener.WaitUntilSatisfied());
    133 
    134   AttachRemovableStorage(kRemovableStorageData);
    135 
    136   std::string removable_storage_transient_id =
    137       StorageMonitor::GetInstance()->GetTransientIdForDeviceId(
    138           kRemovableStorageData.device_id);
    139   ExtensionTestMessageListener detach_device_id_listener(
    140       removable_storage_transient_id, false);
    141 
    142   // Simulate triggering onDetached event.
    143   ASSERT_TRUE(detach_listener.WaitUntilSatisfied());
    144   DetachRemovableStorage(kRemovableStorageData.device_id);
    145 
    146   ASSERT_TRUE(detach_device_id_listener.WaitUntilSatisfied());
    147 
    148   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
    149 }
    150