extensions/browser/lazy_background_task_queue_unittest.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 "extensions/browser/lazy_background_task_queue.h"
   6
   7 #include "base/bind.h"
   8 #include "base/command_line.h"
   9 #include "chrome/browser/extensions/extension_service_unittest.h"
  10 #include "chrome/browser/extensions/test_extension_system.h"
  11 #include "chrome/test/base/testing_profile.h"
  12 #include "content/public/test/test_browser_thread_bundle.h"
  13 #include "extensions/browser/process_manager.h"
  14 #include "extensions/common/extension.h"
  15 #include "extensions/common/extension_builder.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 namespace extensions {
  19
  20 // A ProcessManager that doesn't create background host pages.
  21 class TestProcessManager : public ProcessManager {
  22  public:
  23   explicit TestProcessManager(Profile* profile)
  24       : ProcessManager(profile, profile->GetOriginalProfile()),
  25         create_count_(0) {}
  26   virtual ~TestProcessManager() {}
  27
  28   int create_count() { return create_count_; }
  29
  30   // ProcessManager overrides:
  31   virtual ExtensionHost* CreateBackgroundHost(const Extension* extension,
  32                                               const GURL& url) OVERRIDE {
  33     // Don't actually try to create a web contents.
  34     create_count_++;
  35     return NULL;
  36   }
  37
  38  private:
  39   int create_count_;
  40
  41   DISALLOW_COPY_AND_ASSIGN(TestProcessManager);
  42 };
  43
  44 // Derives from ExtensionServiceTestBase because ExtensionService is difficult
  45 // to initialize alone.
  46 class LazyBackgroundTaskQueueTest : public ExtensionServiceTestBase {
  47  public:
  48   LazyBackgroundTaskQueueTest() : task_run_count_(0) {}
  49   virtual ~LazyBackgroundTaskQueueTest() {}
  50
  51   int task_run_count() { return task_run_count_; }
  52
  53   // A simple callback for AddPendingTask.
  54   void RunPendingTask(ExtensionHost* host) {
  55     task_run_count_++;
  56   }
  57
  58   // Creates and registers an extension without a background page.
  59   scoped_refptr<Extension> CreateSimpleExtension() {
  60     scoped_refptr<Extension> extension = ExtensionBuilder()
  61         .SetManifest(DictionaryBuilder()
  62                      .Set("name", "No background")
  63                      .Set("version", "1")
  64                      .Set("manifest_version", 2))
  65         .SetID("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
  66         .Build();
  67     service_->AddExtension(extension);
  68     return extension;
  69   }
  70
  71   // Creates and registers an extension with a lazy background page.
  72   scoped_refptr<Extension> CreateLazyBackgroundExtension() {
  73     scoped_refptr<Extension> extension = ExtensionBuilder()
  74         .SetManifest(DictionaryBuilder()
  75             .Set("name", "Lazy background")
  76             .Set("version", "1")
  77             .Set("manifest_version", 2)
  78             .Set("background",
  79                   DictionaryBuilder()
  80                   .Set("page", "background.html")
  81                   .SetBoolean("persistent", false)))
  82         .SetID("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
  83         .Build();
  84     service_->AddExtension(extension);
  85     return extension;
  86   }
  87
  88  private:
  89   // The total number of pending tasks that have been executed.
  90   int task_run_count_;
  91
  92   DISALLOW_COPY_AND_ASSIGN(LazyBackgroundTaskQueueTest);
  93 };
  94
  95 // Tests that only extensions with background pages should have tasks queued.
  96 TEST_F(LazyBackgroundTaskQueueTest, ShouldEnqueueTask) {
  97   InitializeEmptyExtensionService();
  98   InitializeProcessManager();
  99
 100   LazyBackgroundTaskQueue queue(profile_.get());
 101
 102   // Build a simple extension with no background page.
 103   scoped_refptr<Extension> no_background = CreateSimpleExtension();
 104   EXPECT_FALSE(queue.ShouldEnqueueTask(profile_.get(), no_background.get()));
 105
 106   // Build another extension with a background page.
 107   scoped_refptr<Extension> with_background = CreateLazyBackgroundExtension();
 108   EXPECT_TRUE(queue.ShouldEnqueueTask(profile_.get(), with_background.get()));
 109 }
 110
 111 // Tests that adding tasks actually increases the pending task count, and that
 112 // multiple extensions can have pending tasks.
 113 TEST_F(LazyBackgroundTaskQueueTest, AddPendingTask) {
 114   InitializeEmptyExtensionService();
 115
 116   // Swap in our stub TestProcessManager.
 117   TestExtensionSystem* extension_system =
 118       static_cast<extensions::TestExtensionSystem*>(
 119           ExtensionSystem::Get(profile_.get()));
 120   // Owned by |extension_system|.
 121   TestProcessManager* process_manager = new TestProcessManager(profile_.get());
 122   extension_system->SetProcessManager(process_manager);
 123
 124   LazyBackgroundTaskQueue queue(profile_.get());
 125
 126   // Build a simple extension with no background page.
 127   scoped_refptr<Extension> no_background = CreateSimpleExtension();
 128
 129   // Adding a pending task increases the number of extensions with tasks, but
 130   // doesn't run the task.
 131   queue.AddPendingTask(profile_.get(),
 132                        no_background->id(),
 133                        base::Bind(&LazyBackgroundTaskQueueTest::RunPendingTask,
 134                                   base::Unretained(this)));
 135   EXPECT_EQ(1u, queue.extensions_with_pending_tasks());
 136   EXPECT_EQ(0, task_run_count());
 137
 138   // Another task on the same extension doesn't increase the number of
 139   // extensions that have tasks and doesn't run any tasks.
 140   queue.AddPendingTask(profile_.get(),
 141                        no_background->id(),
 142                        base::Bind(&LazyBackgroundTaskQueueTest::RunPendingTask,
 143                                   base::Unretained(this)));
 144   EXPECT_EQ(1u, queue.extensions_with_pending_tasks());
 145   EXPECT_EQ(0, task_run_count());
 146
 147   // Adding a task on an extension with a lazy background page tries to create
 148   // a background host, and if that fails, runs the task immediately.
 149   scoped_refptr<Extension> lazy_background = CreateLazyBackgroundExtension();
 150   queue.AddPendingTask(profile_.get(),
 151                        lazy_background->id(),
 152                        base::Bind(&LazyBackgroundTaskQueueTest::RunPendingTask,
 153                                   base::Unretained(this)));
 154   EXPECT_EQ(2u, queue.extensions_with_pending_tasks());
 155   // The process manager tried to create a background host.
 156   EXPECT_EQ(1, process_manager->create_count());
 157   // The task ran immediately because the creation failed.
 158   EXPECT_EQ(1, task_run_count());
 159 }
 160
 161 // Tests that pending tasks are actually run.
 162 TEST_F(LazyBackgroundTaskQueueTest, ProcessPendingTasks) {
 163   InitializeEmptyExtensionService();
 164
 165   LazyBackgroundTaskQueue queue(profile_.get());
 166
 167   // ProcessPendingTasks is a no-op if there are no tasks.
 168   scoped_refptr<Extension> extension = CreateSimpleExtension();
 169   queue.ProcessPendingTasks(NULL, profile_.get(), extension);
 170   EXPECT_EQ(0, task_run_count());
 171
 172   // Schedule a task to run.
 173   queue.AddPendingTask(profile_.get(),
 174                        extension->id(),
 175                        base::Bind(&LazyBackgroundTaskQueueTest::RunPendingTask,
 176                                   base::Unretained(this)));
 177   EXPECT_EQ(0, task_run_count());
 178   EXPECT_EQ(1u, queue.extensions_with_pending_tasks());
 179
 180   // Trying to run tasks for an unrelated profile should do nothing.
 181   TestingProfile profile2;
 182   queue.ProcessPendingTasks(NULL, &profile2, extension);
 183   EXPECT_EQ(0, task_run_count());
 184   EXPECT_EQ(1u, queue.extensions_with_pending_tasks());
 185
 186   // Processing tasks when there is one pending runs the task and removes the
 187   // extension from the list of extensions with pending tasks.
 188   queue.ProcessPendingTasks(NULL, profile_.get(), extension);
 189   EXPECT_EQ(1, task_run_count());
 190   EXPECT_EQ(0u, queue.extensions_with_pending_tasks());
 191 }
 192
 193 }  // namespace extensions