#include "extensions/browser/lazy_background_task_queue.h"
#include "base/bind.h"
-#include "base/command_line.h"
-#include "chrome/browser/extensions/extension_process_manager.h"
-#include "chrome/browser/extensions/extension_service_unittest.h"
-#include "chrome/browser/extensions/test_extension_system.h"
-#include "chrome/common/extensions/extension.h"
-#include "chrome/common/extensions/extension_builder.h"
-#include "chrome/test/base/testing_profile.h"
-#include "content/public/test/test_browser_thread_bundle.h"
+#include "components/keyed_service/content/browser_context_dependency_manager.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/test/test_browser_context.h"
+#include "extensions/browser/extension_registry.h"
+#include "extensions/browser/extension_registry_factory.h"
+#include "extensions/browser/extension_system.h"
+#include "extensions/browser/extension_system_provider.h"
+#include "extensions/browser/extensions_test.h"
+#include "extensions/browser/mock_extension_system.h"
+#include "extensions/browser/process_manager.h"
+#include "extensions/browser/test_extensions_browser_client.h"
+#include "extensions/common/extension.h"
+#include "extensions/common/extension_builder.h"
#include "testing/gtest/include/gtest/gtest.h"
+using content::BrowserContext;
+
namespace extensions {
+namespace {
-// An ExtensionProcessManager that doesn't create background host pages.
-class TestExtensionProcessManager : public ExtensionProcessManager {
+// A ProcessManager that doesn't create background host pages.
+class TestProcessManager : public ProcessManager {
public:
- explicit TestExtensionProcessManager(Profile* profile)
- : ExtensionProcessManager(profile),
- create_count_(0) {}
- virtual ~TestExtensionProcessManager() {}
+ explicit TestProcessManager(BrowserContext* context)
+ : ProcessManager(context, context, ExtensionRegistry::Get(context)),
+ create_count_(0) {
+ // ProcessManager constructor above assumes non-incognito.
+ DCHECK(!context->IsOffTheRecord());
+ }
+ virtual ~TestProcessManager() {}
int create_count() { return create_count_; }
- // ExtensionProcessManager overrides:
- virtual extensions::ExtensionHost* CreateBackgroundHost(
- const extensions::Extension* extension,
- const GURL& url) OVERRIDE {
+ // ProcessManager overrides:
+ virtual bool CreateBackgroundHost(const Extension* extension,
+ const GURL& url) OVERRIDE {
// Don't actually try to create a web contents.
create_count_++;
- return NULL;
+ return false;
}
private:
int create_count_;
- DISALLOW_COPY_AND_ASSIGN(TestExtensionProcessManager);
+ DISALLOW_COPY_AND_ASSIGN(TestProcessManager);
};
-// Derives from ExtensionServiceTestBase because ExtensionService is difficult
-// to initialize alone.
-class LazyBackgroundTaskQueueTest : public ExtensionServiceTestBase {
+// A simple ExtensionSystem that returns a TestProcessManager.
+class MockExtensionSystemWithProcessManager : public MockExtensionSystem {
public:
- LazyBackgroundTaskQueueTest() : task_run_count_(0) {}
+ explicit MockExtensionSystemWithProcessManager(BrowserContext* context)
+ : MockExtensionSystem(context), test_process_manager_(context) {}
+ virtual ~MockExtensionSystemWithProcessManager() {}
+
+ virtual ProcessManager* process_manager() OVERRIDE {
+ return &test_process_manager_;
+ }
+
+ private:
+ TestProcessManager test_process_manager_;
+};
+
+} // namespace
+
+// Derives from ExtensionsTest to provide content module and keyed service
+// initialization.
+class LazyBackgroundTaskQueueTest : public ExtensionsTest {
+ public:
+ LazyBackgroundTaskQueueTest()
+ : notification_service_(content::NotificationService::Create()),
+ task_run_count_(0) {
+ extensions_browser_client()->set_extension_system_factory(
+ &extension_system_factory_);
+ }
virtual ~LazyBackgroundTaskQueueTest() {}
int task_run_count() { return task_run_count_; }
.Set("manifest_version", 2))
.SetID("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
.Build();
- service_->AddExtension(extension);
+ ExtensionRegistry::Get(browser_context())->AddEnabled(extension);
return extension;
}
.SetBoolean("persistent", false)))
.SetID("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
.Build();
- service_->AddExtension(extension);
+ ExtensionRegistry::Get(browser_context())->AddEnabled(extension);
return extension;
}
private:
+ scoped_ptr<content::NotificationService> notification_service_;
+ MockExtensionSystemFactory<MockExtensionSystemWithProcessManager>
+ extension_system_factory_;
+
// The total number of pending tasks that have been executed.
int task_run_count_;
// Tests that only extensions with background pages should have tasks queued.
TEST_F(LazyBackgroundTaskQueueTest, ShouldEnqueueTask) {
- InitializeEmptyExtensionService();
- InitializeExtensionProcessManager();
-
- LazyBackgroundTaskQueue queue(profile_.get());
+ LazyBackgroundTaskQueue queue(browser_context());
// Build a simple extension with no background page.
scoped_refptr<Extension> no_background = CreateSimpleExtension();
- EXPECT_FALSE(queue.ShouldEnqueueTask(profile_.get(), no_background.get()));
+ EXPECT_FALSE(queue.ShouldEnqueueTask(browser_context(), no_background.get()));
// Build another extension with a background page.
scoped_refptr<Extension> with_background = CreateLazyBackgroundExtension();
- EXPECT_TRUE(queue.ShouldEnqueueTask(profile_.get(), with_background.get()));
+ EXPECT_TRUE(
+ queue.ShouldEnqueueTask(browser_context(), with_background.get()));
}
// Tests that adding tasks actually increases the pending task count, and that
// multiple extensions can have pending tasks.
TEST_F(LazyBackgroundTaskQueueTest, AddPendingTask) {
- InitializeEmptyExtensionService();
-
- // Swap in our stub TestExtensionProcessManager.
- TestExtensionSystem* extension_system =
- static_cast<extensions::TestExtensionSystem*>(
- ExtensionSystem::Get(profile_.get()));
- // Owned by |extension_system|.
- TestExtensionProcessManager* process_manager =
- new TestExtensionProcessManager(profile_.get());
- extension_system->SetExtensionProcessManager(process_manager);
+ // Get our TestProcessManager.
+ MockExtensionSystem* extension_system = static_cast<MockExtensionSystem*>(
+ ExtensionSystem::Get(browser_context()));
+ TestProcessManager* process_manager =
+ static_cast<TestProcessManager*>(extension_system->process_manager());
- LazyBackgroundTaskQueue queue(profile_.get());
+ LazyBackgroundTaskQueue queue(browser_context());
// Build a simple extension with no background page.
scoped_refptr<Extension> no_background = CreateSimpleExtension();
// Adding a pending task increases the number of extensions with tasks, but
// doesn't run the task.
- queue.AddPendingTask(profile_.get(),
+ queue.AddPendingTask(browser_context(),
no_background->id(),
base::Bind(&LazyBackgroundTaskQueueTest::RunPendingTask,
base::Unretained(this)));
// Another task on the same extension doesn't increase the number of
// extensions that have tasks and doesn't run any tasks.
- queue.AddPendingTask(profile_.get(),
+ queue.AddPendingTask(browser_context(),
no_background->id(),
base::Bind(&LazyBackgroundTaskQueueTest::RunPendingTask,
base::Unretained(this)));
// Adding a task on an extension with a lazy background page tries to create
// a background host, and if that fails, runs the task immediately.
scoped_refptr<Extension> lazy_background = CreateLazyBackgroundExtension();
- queue.AddPendingTask(profile_.get(),
+ queue.AddPendingTask(browser_context(),
lazy_background->id(),
base::Bind(&LazyBackgroundTaskQueueTest::RunPendingTask,
base::Unretained(this)));
// Tests that pending tasks are actually run.
TEST_F(LazyBackgroundTaskQueueTest, ProcessPendingTasks) {
- InitializeEmptyExtensionService();
-
- LazyBackgroundTaskQueue queue(profile_.get());
+ LazyBackgroundTaskQueue queue(browser_context());
// ProcessPendingTasks is a no-op if there are no tasks.
scoped_refptr<Extension> extension = CreateSimpleExtension();
- queue.ProcessPendingTasks(NULL, profile_.get(), extension);
+ queue.ProcessPendingTasks(NULL, browser_context(), extension);
EXPECT_EQ(0, task_run_count());
// Schedule a task to run.
- queue.AddPendingTask(profile_.get(),
+ queue.AddPendingTask(browser_context(),
extension->id(),
base::Bind(&LazyBackgroundTaskQueueTest::RunPendingTask,
base::Unretained(this)));
EXPECT_EQ(0, task_run_count());
EXPECT_EQ(1u, queue.extensions_with_pending_tasks());
- // Trying to run tasks for an unrelated profile should do nothing.
- TestingProfile profile2;
- queue.ProcessPendingTasks(NULL, &profile2, extension);
+ // Trying to run tasks for an unrelated BrowserContext should do nothing.
+ content::TestBrowserContext unrelated_context;
+ queue.ProcessPendingTasks(NULL, &unrelated_context, extension);
EXPECT_EQ(0, task_run_count());
EXPECT_EQ(1u, queue.extensions_with_pending_tasks());
// Processing tasks when there is one pending runs the task and removes the
// extension from the list of extensions with pending tasks.
- queue.ProcessPendingTasks(NULL, profile_.get(), extension);
+ queue.ProcessPendingTasks(NULL, browser_context(), extension);
EXPECT_EQ(1, task_run_count());
EXPECT_EQ(0u, queue.extensions_with_pending_tasks());
}
projects / platform / framework / web / crosswalk.git / blobdiff