No longer start BG mode until a BackgroundContents is loaded

chrome/browser/background/background_application_list_model_unittest.cc

 // Copyright (c) 2012 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.
 
 // TODO(rickcam): Bug 73183: Add unit tests for image loading
 
 #include <cstdlib>
 #include <set>
 
 #include "chrome/browser/background/background_application_list_model.h"
@@ skipping 27 matching lines @@
 class BackgroundApplicationListModelTest : public ExtensionServiceTestBase {
  public:
   BackgroundApplicationListModelTest() {}
   virtual ~BackgroundApplicationListModelTest() {}
 
  protected:
   void InitializeAndLoadEmptyExtensionService() {
     InitializeEmptyExtensionService();
     service_->OnLoadedInstalledExtensions(); /* Sends EXTENSIONS_READY */
   }
+
+  bool IsBackgroundApp(const Extension& app) {
+    return BackgroundApplicationListModel::IsBackgroundApp(app,
+                                                           profile_.get());
+  }
 };
 
 // Returns a barebones test Extension object with the specified |name|.  The
 // returned extension will include background permission iff
 // |background_permission| is true.
 static scoped_refptr<Extension> CreateExtension(const std::string& name,
                                                 bool background_permission) {
   DictionaryValue manifest;
   manifest.SetString(extension_manifest_keys::kVersion, "1.0.0.0");
   manifest.SetString(extension_manifest_keys::kName, name);
@@ skipping 19 matching lines @@
 std::string GenerateUniqueExtensionName() {
   static int uniqueness = 0;
   std::ostringstream output;
   output << "Unique Named Extension " << uniqueness;
   ++uniqueness;
   return output.str();
 }
 
 void AddBackgroundPermission(ExtensionService* service,
                              Extension* extension) {
-  if (BackgroundApplicationListModel::IsBackgroundApp(*extension)) return;
+  if (BackgroundApplicationListModel::IsBackgroundApp(*extension,
+                                                      service->profile())) {
+    return;
+  }
 
   static scoped_refptr<Extension> temporary =
       CreateExtension(GenerateUniqueExtensionName(), true);
   scoped_refptr<const ExtensionPermissionSet> permissions =
       temporary->GetActivePermissions();
   extensions::PermissionsUpdater(service->profile()).AddPermissions(
       extension, permissions.get());
 }
 
 void RemoveBackgroundPermission(ExtensionService* service,
                                 Extension* extension) {
-  if (!BackgroundApplicationListModel::IsBackgroundApp(*extension)) return;
+  if (!BackgroundApplicationListModel::IsBackgroundApp(*extension,
+                                                       service->profile())) {
+    return;
+  }
   extensions::PermissionsUpdater(service->profile()).RemovePermissions(
       extension, extension->GetActivePermissions());
 }
 }  // namespace
 
 // With minimal test logic, verifies behavior over an explicit set of
 // extensions, of which some are Background Apps and others are not.
 TEST_F(BackgroundApplicationListModelTest, ExplicitTest) {
   InitializeAndLoadEmptyExtensionService();
   ExtensionService* service = profile_->GetExtensionService();
   ASSERT_TRUE(service);
   ASSERT_TRUE(service->is_ready());
   ASSERT_TRUE(service->extensions());
   ASSERT_TRUE(service->extensions()->is_empty());
   scoped_ptr<BackgroundApplicationListModel> model(
       new BackgroundApplicationListModel(profile_.get()));
   ASSERT_EQ(0U, model->size());
 
   scoped_refptr<Extension> ext1 = CreateExtension("alpha", false);
   scoped_refptr<Extension> ext2 = CreateExtension("bravo", false);
   scoped_refptr<Extension> ext3 = CreateExtension("charlie", false);
   scoped_refptr<Extension> bgapp1 = CreateExtension("delta", true);
   scoped_refptr<Extension> bgapp2 = CreateExtension("echo", true);
   ASSERT_TRUE(service->extensions() != NULL);
   ASSERT_EQ(0U, service->extensions()->size());
   ASSERT_EQ(0U, model->size());
 
   // Add alternating Extensions and Background Apps
-  ASSERT_FALSE(BackgroundApplicationListModel::IsBackgroundApp(*ext1));
+  ASSERT_FALSE(IsBackgroundApp(*ext1));
   service->AddExtension(ext1);
   ASSERT_EQ(1U, service->extensions()->size());
   ASSERT_EQ(0U, model->size());
-  ASSERT_TRUE(BackgroundApplicationListModel::IsBackgroundApp(*bgapp1));
+  ASSERT_TRUE(IsBackgroundApp(*bgapp1));
   service->AddExtension(bgapp1);
   ASSERT_EQ(2U, service->extensions()->size());
   ASSERT_EQ(1U, model->size());
-  ASSERT_FALSE(BackgroundApplicationListModel::IsBackgroundApp(*ext2));
+  ASSERT_FALSE(IsBackgroundApp(*ext2));
   service->AddExtension(ext2);
   ASSERT_EQ(3U, service->extensions()->size());
   ASSERT_EQ(1U, model->size());
-  ASSERT_TRUE(BackgroundApplicationListModel::IsBackgroundApp(*bgapp2));
+  ASSERT_TRUE(IsBackgroundApp(*bgapp2));
   service->AddExtension(bgapp2);
   ASSERT_EQ(4U, service->extensions()->size());
   ASSERT_EQ(2U, model->size());
-  ASSERT_FALSE(BackgroundApplicationListModel::IsBackgroundApp(*ext3));
+  ASSERT_FALSE(IsBackgroundApp(*ext3));
   service->AddExtension(ext3);
   ASSERT_EQ(5U, service->extensions()->size());
   ASSERT_EQ(2U, model->size());
 
   // Remove in FIFO order.
-  ASSERT_FALSE(BackgroundApplicationListModel::IsBackgroundApp(*ext1));
+  ASSERT_FALSE(IsBackgroundApp(*ext1));
   service->UninstallExtension(ext1->id(), false, NULL);
   ASSERT_EQ(4U, service->extensions()->size());
   ASSERT_EQ(2U, model->size());
-  ASSERT_TRUE(BackgroundApplicationListModel::IsBackgroundApp(*bgapp1));
+  ASSERT_TRUE(IsBackgroundApp(*bgapp1));
   service->UninstallExtension(bgapp1->id(), false, NULL);
   ASSERT_EQ(3U, service->extensions()->size());
   ASSERT_EQ(1U, model->size());
-  ASSERT_FALSE(BackgroundApplicationListModel::IsBackgroundApp(*ext2));
+  ASSERT_FALSE(IsBackgroundApp(*ext2));
   service->UninstallExtension(ext2->id(), false, NULL);
   ASSERT_EQ(2U, service->extensions()->size());
   ASSERT_EQ(1U, model->size());
-  ASSERT_TRUE(BackgroundApplicationListModel::IsBackgroundApp(*bgapp2));
+  ASSERT_TRUE(IsBackgroundApp(*bgapp2));
   service->UninstallExtension(bgapp2->id(), false, NULL);
   ASSERT_EQ(1U, service->extensions()->size());
   ASSERT_EQ(0U, model->size());
-  ASSERT_FALSE(BackgroundApplicationListModel::IsBackgroundApp(*ext3));
+  ASSERT_FALSE(IsBackgroundApp(*ext3));
   service->UninstallExtension(ext3->id(), false, NULL);
   ASSERT_EQ(0U, service->extensions()->size());
   ASSERT_EQ(0U, model->size());
 }
 
 // With minimal test logic, verifies behavior with dynamic permissions.
 TEST_F(BackgroundApplicationListModelTest, AddRemovePermissionsTest) {
   InitializeAndLoadEmptyExtensionService();
   ExtensionService* service = profile_->GetExtensionService();
   ASSERT_TRUE(service);
   ASSERT_TRUE(service->is_ready());
   ASSERT_TRUE(service->extensions());
   ASSERT_TRUE(service->extensions()->is_empty());
   scoped_ptr<BackgroundApplicationListModel> model(
       new BackgroundApplicationListModel(profile_.get()));
   ASSERT_EQ(0U, model->size());
 
   scoped_refptr<Extension> ext = CreateExtension("extension", false);
   scoped_refptr<Extension> bgapp = CreateExtension("application", true);
   ASSERT_TRUE(service->extensions() != NULL);
   ASSERT_EQ(0U, service->extensions()->size());
   ASSERT_EQ(0U, model->size());
 
   // Add one (non-background) extension and one background application
-  ASSERT_FALSE(BackgroundApplicationListModel::IsBackgroundApp(*ext));
+  ASSERT_FALSE(IsBackgroundApp(*ext));
   service->AddExtension(ext);
   ASSERT_EQ(1U, service->extensions()->size());
   ASSERT_EQ(0U, model->size());
-  ASSERT_TRUE(BackgroundApplicationListModel::IsBackgroundApp(*bgapp));
+  ASSERT_TRUE(IsBackgroundApp(*bgapp));
   service->AddExtension(bgapp);
   ASSERT_EQ(2U, service->extensions()->size());
   ASSERT_EQ(1U, model->size());
 
   // Change permissions back and forth
   AddBackgroundPermission(service, ext.get());
   ASSERT_EQ(2U, service->extensions()->size());
   ASSERT_EQ(2U, model->size());
   RemoveBackgroundPermission(service, bgapp.get());
   ASSERT_EQ(2U, service->extensions()->size());
@@ skipping 14 matching lines @@
                   BackgroundApplicationListModel* model,
                   size_t* expected,
                   size_t* count) {
   bool create_background = false;
   if (rand() % 2) {
     create_background = true;
     ++*expected;
   }
   scoped_refptr<Extension> extension =
       CreateExtension(GenerateUniqueExtensionName(), create_background);
-  ASSERT_EQ(BackgroundApplicationListModel::IsBackgroundApp(*extension),
+  ASSERT_EQ(BackgroundApplicationListModel::IsBackgroundApp(*extension,
+                                                            service->profile()),
             create_background);
   extensions->insert(extension);
   ++*count;
   ASSERT_EQ(*count, extensions->size());
   service->AddExtension(extension);
   ASSERT_EQ(*count, service->extensions()->size());
   ASSERT_EQ(*expected, model->size());
 }
 
 void RemoveExtension(ExtensionService* service,
@@ skipping 10 matching lines @@
     ASSERT_EQ(0U, model->size());
   } else {
     // Randomly select which extension to remove
     if (extensions->size() > 1) {
       int offset = rand() % (extensions->size() - 1);
       for (int index = 0; index < offset; ++index)
         ++cursor;
     }
     scoped_refptr<Extension> extension = cursor->get();
     std::string id = extension->id();
-    if (BackgroundApplicationListModel::IsBackgroundApp(*extension))
+    if (BackgroundApplicationListModel::IsBackgroundApp(*extension,
+                                                        service->profile())) {
       --*expected;
+    }
     extensions->erase(cursor);
     --*count;
     ASSERT_EQ(*count, extensions->size());
     service->UninstallExtension(extension->id(), false, NULL);
     ASSERT_EQ(*count, service->extensions()->size());
     ASSERT_EQ(*expected, model->size());
   }
 }
 
 void TogglePermission(ExtensionService* service,
@@ skipping 10 matching lines @@
     ASSERT_EQ(0U, model->size());
   } else {
     // Randomly select which extension to toggle.
     if (extensions->size() > 1) {
       int offset = rand() % (extensions->size() - 1);
       for (int index = 0; index < offset; ++index)
         ++cursor;
     }
     scoped_refptr<Extension> extension = cursor->get();
     std::string id = extension->id();
-    if (BackgroundApplicationListModel::IsBackgroundApp(*extension)) {
+    if (BackgroundApplicationListModel::IsBackgroundApp(*extension,
+                                                        service->profile())) {
       --*expected;
       ASSERT_EQ(*count, extensions->size());
       RemoveBackgroundPermission(service, extension);
       ASSERT_EQ(*count, service->extensions()->size());
       ASSERT_EQ(*expected, model->size());
     } else {
       ++*expected;
       ASSERT_EQ(*count, extensions->size());
       AddBackgroundPermission(service, extension);
       ASSERT_EQ(*count, service->extensions()->size());
@@ skipping 31 matching lines @@
         break;
       case 2:
         TogglePermission(service, &extensions, model.get(), &expected, &count);
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 }