Use ApiUnitTest for storage API tests (storage_api_unittest and storage_frontend_unittest).

extensions/browser/api/storage/settings_test_util.cc

 // Copyright 2014 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/storage/settings_test_util.h"
 
 #include "base/files/file_path.h"
 #include "extensions/browser/api/storage/storage_frontend.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system_provider.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/permissions/permissions_data.h"
 
 namespace extensions {
 
 namespace settings_test_util {
 
+// Creates a kilobyte of data.
+scoped_ptr<base::Value> CreateKilobyte() {
+  std::string kilobyte_string;
+  for (int i = 0; i < 1024; ++i) {
+    kilobyte_string += "a";
+  }
+  return scoped_ptr<base::Value>(new base::StringValue(kilobyte_string));
+}
+
+// Creates a megabyte of data.
+scoped_ptr<base::Value> CreateMegabyte() {
+  base::ListValue* megabyte = new base::ListValue();
+  for (int i = 0; i < 1000; ++i) {

[Ken Rockot(use gerrit already), 2014/08/17 21:28:27]

I hate to be that guy, but this isn't a megabyte!

[Yoyo Zhou, 2014/08/17 21:45:28]

I noticed too!

[not at google - send to devlin, 2014/08/18 20:01:24]

My bad. It's half way between a real and a bizarro megabyte. I guess I was
compromising without realising it.

+    megabyte->Append(CreateKilobyte().release());
+  }
+  return scoped_ptr<base::Value>(megabyte);
+}
+
 // Intended as a StorageCallback from GetStorage.
 static void AssignStorage(ValueStore** dst, ValueStore* src) {
   *dst = src;
 }
 
 ValueStore* GetStorage(scoped_refptr<const Extension> extension,
                        settings_namespace::Namespace settings_namespace,
                        StorageFrontend* frontend) {
   ValueStore* storage = NULL;
   frontend->RunWithStorage(
       extension, settings_namespace, base::Bind(&AssignStorage, &storage));
   base::MessageLoop::current()->RunUntilIdle();
   return storage;
 }
 
 ValueStore* GetStorage(scoped_refptr<const Extension> extension,
                        StorageFrontend* frontend) {
   return GetStorage(extension, settings_namespace::SYNC, frontend);
 }
 
-scoped_refptr<const Extension> AddExtensionWithId(Profile* profile,
-                                                  const std::string& id,
-                                                  Manifest::Type type) {
+scoped_refptr<const Extension> AddExtensionWithId(
+    content::BrowserContext* context,
+    const std::string& id,
+    Manifest::Type type) {
   return AddExtensionWithIdAndPermissions(
-      profile, id, type, std::set<std::string>());
+      context, id, type, std::set<std::string>());
 }
 
 scoped_refptr<const Extension> AddExtensionWithIdAndPermissions(
-    Profile* profile,
+    content::BrowserContext* context,
     const std::string& id,
     Manifest::Type type,
     const std::set<std::string>& permissions_set) {
   base::DictionaryValue manifest;
   manifest.SetString("name", std::string("Test extension ") + id);
   manifest.SetString("version", "1.0");
 
   scoped_ptr<base::ListValue> permissions(new base::ListValue());
   for (std::set<std::string>::const_iterator it = permissions_set.begin();
       it != permissions_set.end(); ++it) {
@@ skipping 24 matching lines @@
                         Manifest::INTERNAL,
                         manifest,
                         Extension::NO_FLAGS,
                         id,
                         &error));
   DCHECK(extension.get());
   DCHECK(error.empty());
 
   // Ensure lookups via ExtensionRegistry (and ExtensionService) work even if
   // the test discards the referenced to the returned extension.
-  ExtensionRegistry::Get(profile)->AddEnabled(extension);
+  ExtensionRegistry::Get(context)->AddEnabled(extension);
 
   for (std::set<std::string>::const_iterator it = permissions_set.begin();
       it != permissions_set.end(); ++it) {
     DCHECK(extension->permissions_data()->HasAPIPermission(*it));
   }
 
   return extension;
 }
 
-// MockExtensionSystem
+// MockExtensionSystemWithEventRouter
 
-MockExtensionSystem::MockExtensionSystem(Profile* profile)
-      : TestExtensionSystem(profile) {}
-MockExtensionSystem::~MockExtensionSystem() {}
+MockExtensionSystemWithEventRouter::MockExtensionSystemWithEventRouter(
+    content::BrowserContext* context)
+    : MockExtensionSystem(context) {
+}
 
-EventRouter* MockExtensionSystem::event_router() {
+MockExtensionSystemWithEventRouter::~MockExtensionSystemWithEventRouter() {
+}
+
+KeyedService* MockExtensionSystemWithEventRouter::Build(
+    content::BrowserContext* context) {
+  return new MockExtensionSystemWithEventRouter(context);
+}
+
+EventRouter* MockExtensionSystemWithEventRouter::event_router() {
   if (!event_router_.get())
-    event_router_.reset(new EventRouter(profile_, NULL));
+    event_router_.reset(new EventRouter(browser_context(), NULL));
   return event_router_.get();
 }
 
-KeyedService* BuildMockExtensionSystem(content::BrowserContext* profile) {
-  return new MockExtensionSystem(static_cast<Profile*>(profile));
-}
-
-// MockProfile
-
-MockProfile::MockProfile(const base::FilePath& file_path)
-    : TestingProfile(file_path) {
-  ExtensionsBrowserClient::Get()
-      ->GetExtensionSystemFactory()
-      ->SetTestingFactoryAndUse(this, &BuildMockExtensionSystem);
-}
-
-MockProfile::~MockProfile() {}
-
 // ScopedSettingsFactory
 
 ScopedSettingsStorageFactory::ScopedSettingsStorageFactory() {}
 
 ScopedSettingsStorageFactory::ScopedSettingsStorageFactory(
     const scoped_refptr<SettingsStorageFactory>& delegate)
     : delegate_(delegate) {}
 
 ScopedSettingsStorageFactory::~ScopedSettingsStorageFactory() {}
 
@@ skipping 11 matching lines @@
 
 void ScopedSettingsStorageFactory::DeleteDatabaseIfExists(
     const base::FilePath& base_path,
     const std::string& extension_id) {
   delegate_->DeleteDatabaseIfExists(base_path, extension_id);
 }
 
 }  // namespace settings_test_util
 
 }  // namespace extensions