Move system.storage tests to extensions/

Also add the LoadExtension method to ShellApiTest used by
several test cases. This method returns an Extension instance
that can be used for recoverying the MainFrame and injecting
JavaScript commands.

BUG=392842

Review URL: https://codereview.chromium.org/764763003

Cr-Commit-Position: refs/heads/master@{#306607}

4 files changed, 317 insertions, 0 deletions

diff --git a/extensions/browser/api/system_storage/storage_api_test_util.cc b/extensions/browser/api/system_storage/storage_api_test_util.cc
new file mode 100644
index 0000000..f06c357
--- /dev/null
+++ b/extensions/browser/api/system_storage/storage_api_test_util.cc
@@ -0,0 +1,28 @@
+// Copyright 2013 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 "extensions/browser/api/system_storage/storage_api_test_util.h"
+
+#include "base/strings/utf_string_conversions.h"
+
+namespace extensions {
+namespace test {
+
+const struct TestStorageUnitInfo kRemovableStorageData = {"dcim:device:001",
+                                                          "/media/usb1",
+                                                          4098,
+                                                          1000};
+
+storage_monitor::StorageInfo BuildStorageInfoFromTestStorageUnitInfo(
+    const TestStorageUnitInfo& unit) {
+  return storage_monitor::StorageInfo(
+      unit.device_id, base::FilePath::StringType(), /* no location */
+      base::UTF8ToUTF16(unit.name),                 /* storage label */
+      base::string16(),                             /* no storage vendor */
+      base::string16(),                             /* no storage model */
+      unit.capacity);
+}
+
+}  // namespace test
+}  // namespace extensions
diff --git a/extensions/browser/api/system_storage/storage_api_test_util.h b/extensions/browser/api/system_storage/storage_api_test_util.h
new file mode 100644
index 0000000..a035906
--- /dev/null
+++ b/extensions/browser/api/system_storage/storage_api_test_util.h
@@ -0,0 +1,33 @@
+// Copyright 2013 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.
+
+#ifndef EXTENSIONS_BROWSER_API_SYSTEM_STORAGE_STORAGE_API_TEST_UTIL_H_
+#define EXTENSIONS_BROWSER_API_SYSTEM_STORAGE_STORAGE_API_TEST_UTIL_H_
+
+#include <vector>
+
+#include "components/storage_monitor/storage_info.h"
+#include "extensions/browser/api/system_storage/storage_info_provider.h"
+
+namespace extensions {
+namespace test {
+
+struct TestStorageUnitInfo {
+  const char* device_id;
+  const char* name;
+  // Total amount of the storage device space, in bytes.
+  double capacity;
+  // The available amount of the storage space, in bytes.
+  double available_capacity;
+};
+
+extern const struct TestStorageUnitInfo kRemovableStorageData;
+
+storage_monitor::StorageInfo BuildStorageInfoFromTestStorageUnitInfo(
+    const TestStorageUnitInfo& unit);
+
+}  // namespace test
+}  // namespace extensions
+
+#endif  // EXTENSIONS_BROWSER_API_SYSTEM_STORAGE_STORAGE_API_TEST_UTIL_H_
diff --git a/extensions/browser/api/system_storage/system_storage_apitest.cc b/extensions/browser/api/system_storage/system_storage_apitest.cc
new file mode 100644
index 0000000..af7262f
--- /dev/null
+++ b/extensions/browser/api/system_storage/system_storage_apitest.cc
@@ -0,0 +1,147 @@
+// Copyright 2013 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 <vector>
+
+#include "base/message_loop/message_loop.h"
+#include "base/strings/utf_string_conversions.h"
+#include "components/storage_monitor/storage_monitor.h"
+#include "components/storage_monitor/test_storage_monitor.h"
+#include "extensions/browser/api/system_storage/storage_api_test_util.h"
+#include "extensions/browser/api/system_storage/storage_info_provider.h"
+#include "extensions/shell/test/shell_apitest.h"
+#include "extensions/test/extension_test_message_listener.h"
+#include "extensions/test/result_catcher.h"
+
+namespace {
+
+using extensions::StorageUnitInfoList;
+using extensions::test::TestStorageUnitInfo;
+using extensions::test::kRemovableStorageData;
+using storage_monitor::StorageMonitor;
+using storage_monitor::TestStorageMonitor;
+
+const struct TestStorageUnitInfo kTestingData[] = {
+    {"dcim:device:001", "0xbeaf", 4098, 1},
+    {"path:device:002", "/home", 4098, 2},
+    {"path:device:003", "/data", 10000, 3}};
+
+}  // namespace
+
+class TestStorageInfoProvider : public extensions::StorageInfoProvider {
+ public:
+  TestStorageInfoProvider(const struct TestStorageUnitInfo* testing_data,
+                          size_t n);
+
+ private:
+  ~TestStorageInfoProvider() override;
+
+  // StorageInfoProvider implementations.
+  double GetStorageFreeSpaceFromTransientIdOnFileThread(
+      const std::string& transient_id) override;
+
+  std::vector<struct TestStorageUnitInfo> testing_data_;
+};
+
+TestStorageInfoProvider::TestStorageInfoProvider(
+    const struct TestStorageUnitInfo* testing_data,
+    size_t n)
+    : testing_data_(testing_data, testing_data + n) {
+}
+
+TestStorageInfoProvider::~TestStorageInfoProvider() {
+}
+
+double TestStorageInfoProvider::GetStorageFreeSpaceFromTransientIdOnFileThread(
+    const std::string& transient_id) {
+  std::string device_id =
+      StorageMonitor::GetInstance()->GetDeviceIdForTransientId(transient_id);
+  for (size_t i = 0; i < testing_data_.size(); ++i) {
+    if (testing_data_[i].device_id == device_id) {
+      return static_cast<double>(testing_data_[i].available_capacity);
+    }
+  }
+  return -1;
+}
+
+class SystemStorageApiTest : public extensions::ShellApiTest {
+ public:
+  SystemStorageApiTest() {}
+  ~SystemStorageApiTest() override {}
+
+  void SetUpOnMainThread() override {
+    ShellApiTest::SetUpOnMainThread();
+    TestStorageMonitor::CreateForBrowserTests();
+  }
+
+  void SetUpInProcessBrowserTestFixture() override {
+    ShellApiTest::SetUpInProcessBrowserTestFixture();
+    message_loop_.reset(new base::MessageLoopForUI);
+  }
+
+  void SetUpAllMockStorageDevices() {
+    for (size_t i = 0; i < arraysize(kTestingData); ++i) {
+      AttachRemovableStorage(kTestingData[i]);
+    }
+  }
+
+  void AttachRemovableStorage(
+      const struct TestStorageUnitInfo& removable_storage_info) {
+    StorageMonitor::GetInstance()->receiver()->ProcessAttach(
+        extensions::test::BuildStorageInfoFromTestStorageUnitInfo(
+            removable_storage_info));
+  }
+
+  void DetachRemovableStorage(const std::string& id) {
+    StorageMonitor::GetInstance()->receiver()->ProcessDetach(id);
+  }
+
+ private:
+  scoped_ptr<base::MessageLoop> message_loop_;
+};
+
+IN_PROC_BROWSER_TEST_F(SystemStorageApiTest, Storage) {
+  SetUpAllMockStorageDevices();
+  TestStorageInfoProvider* provider =
+      new TestStorageInfoProvider(kTestingData, arraysize(kTestingData));
+  extensions::StorageInfoProvider::InitializeForTesting(provider);
+  std::vector<linked_ptr<ExtensionTestMessageListener>> device_ids_listeners;
+  for (size_t i = 0; i < arraysize(kTestingData); ++i) {
+    linked_ptr<ExtensionTestMessageListener> listener(
+        new ExtensionTestMessageListener(
+            StorageMonitor::GetInstance()->GetTransientIdForDeviceId(
+                kTestingData[i].device_id),
+            false));
+    device_ids_listeners.push_back(listener);
+  }
+  ASSERT_TRUE(RunAppTest("system/storage")) << message_;
+  for (size_t i = 0; i < device_ids_listeners.size(); ++i)
+    EXPECT_TRUE(device_ids_listeners[i]->WaitUntilSatisfied());
+}
+
+IN_PROC_BROWSER_TEST_F(SystemStorageApiTest, StorageAttachment) {
+  extensions::ResultCatcher catcher;
+  ExtensionTestMessageListener attach_listener("attach", false);
+  ExtensionTestMessageListener detach_listener("detach", false);
+
+  EXPECT_TRUE(LoadApp("system/storage_attachment"));
+  // Simulate triggering onAttached event.
+  ASSERT_TRUE(attach_listener.WaitUntilSatisfied());
+
+  AttachRemovableStorage(kRemovableStorageData);
+
+  std::string removable_storage_transient_id =
+      StorageMonitor::GetInstance()->GetTransientIdForDeviceId(
+          kRemovableStorageData.device_id);
+  ExtensionTestMessageListener detach_device_id_listener(
+      removable_storage_transient_id, false);
+
+  // Simulate triggering onDetached event.
+  ASSERT_TRUE(detach_listener.WaitUntilSatisfied());
+  DetachRemovableStorage(kRemovableStorageData.device_id);
+
+  ASSERT_TRUE(detach_device_id_listener.WaitUntilSatisfied());
+
+  EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
+}
diff --git a/extensions/browser/api/system_storage/system_storage_eject_apitest.cc b/extensions/browser/api/system_storage/system_storage_eject_apitest.cc
new file mode 100644
index 0000000..da9a59d
--- /dev/null
+++ b/extensions/browser/api/system_storage/system_storage_eject_apitest.cc
@@ -0,0 +1,109 @@
+// Copyright 2013 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.
+//
+// SystemStorage eject API browser tests.
+
+#include "base/files/file_path.h"
+#include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversions.h"
+#include "components/storage_monitor/storage_info.h"
+#include "components/storage_monitor/storage_monitor.h"
+#include "components/storage_monitor/test_storage_monitor.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/test/test_utils.h"
+#include "extensions/browser/api/system_storage/storage_api_test_util.h"
+#include "extensions/browser/api/system_storage/storage_info_provider.h"
+#include "extensions/browser/extension_host.h"
+#include "extensions/browser/process_manager.h"
+#include "extensions/common/extension.h"
+#include "extensions/shell/test/shell_apitest.h"
+#include "extensions/test/extension_test_message_listener.h"
+
+namespace {
+
+using extensions::test::TestStorageUnitInfo;
+using extensions::test::kRemovableStorageData;
+using storage_monitor::StorageMonitor;
+using storage_monitor::TestStorageMonitor;
+
+}  // namespace
+
+class SystemStorageEjectApiTest : public extensions::ShellApiTest {
+ public:
+  SystemStorageEjectApiTest() : monitor_(NULL) {}
+  ~SystemStorageEjectApiTest() override {}
+
+ protected:
+  void SetUpOnMainThread() override {
+    monitor_ = TestStorageMonitor::CreateForBrowserTests();
+    ShellApiTest::SetUpOnMainThread();
+  }
+
+  content::RenderViewHost* GetHost() {
+    ExtensionTestMessageListener listener("loaded", false);
+    const extensions::Extension* extension = LoadApp("system/storage_eject");
+
+    // Wait for the extension to load completely so we can execute
+    // the JavaScript function from test case.
+    EXPECT_TRUE(listener.WaitUntilSatisfied());
+
+    return extensions::ProcessManager::Get(browser_context())
+        ->GetBackgroundHostForExtension(extension->id())
+        ->render_view_host();
+  }
+
+  void ExecuteCmdAndCheckReply(content::RenderViewHost* host,
+                               const std::string& js_command,
+                               const std::string& ok_message) {
+    ExtensionTestMessageListener listener(ok_message, false);
+    host->GetMainFrame()->ExecuteJavaScript(base::ASCIIToUTF16(js_command));
+    EXPECT_TRUE(listener.WaitUntilSatisfied());
+  }
+
+  void Attach() {
+    DCHECK(StorageMonitor::GetInstance()->IsInitialized());
+    StorageMonitor::GetInstance()->receiver()->ProcessAttach(
+        extensions::test::BuildStorageInfoFromTestStorageUnitInfo(
+            kRemovableStorageData));
+    content::RunAllPendingInMessageLoop();
+  }
+
+  void Detach() {
+    DCHECK(StorageMonitor::GetInstance()->IsInitialized());
+    StorageMonitor::GetInstance()->receiver()->ProcessDetach(
+        kRemovableStorageData.device_id);
+    content::RunAllPendingInMessageLoop();
+  }
+
+ protected:
+  TestStorageMonitor* monitor_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SystemStorageEjectApiTest);
+};
+
+IN_PROC_BROWSER_TEST_F(SystemStorageEjectApiTest, EjectTest) {
+  content::RenderViewHost* host = GetHost();
+  ExecuteCmdAndCheckReply(host, "addAttachListener()", "add_attach_ok");
+
+  // Attach / detach
+  const std::string expect_attach_msg =
+      base::StringPrintf("%s,%s", "attach_test_ok", kRemovableStorageData.name);
+  ExtensionTestMessageListener attach_finished_listener(expect_attach_msg,
+                                                        false /* no reply */);
+  Attach();
+  EXPECT_TRUE(attach_finished_listener.WaitUntilSatisfied());
+
+  ExecuteCmdAndCheckReply(host, "ejectTest()", "eject_ok");
+  EXPECT_EQ(kRemovableStorageData.device_id, monitor_->ejected_device());
+
+  Detach();
+}
+
+IN_PROC_BROWSER_TEST_F(SystemStorageEjectApiTest, EjectBadDeviceTest) {
+  ExecuteCmdAndCheckReply(GetHost(), "ejectFailTest()", "eject_no_such_device");
+
+  EXPECT_EQ("", monitor_->ejected_device());
+}