src/chrome/browser/extensions/api/system_storage/system_storage_apitest.cc

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