Instead of marking all default apps as bookmark apps, allow it to be specified per-app.

chrome/browser/extensions/extension_service_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.
 
 #include "chrome/browser/extensions/extension_service_unittest.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 134 matching lines @@
   extent->AddPattern(URLPattern(schemes, pattern));
 }
 
 }  // namespace
 
 class MockExtensionProvider : public ExternalExtensionProviderInterface {
  public:
   MockExtensionProvider(
       VisitorInterface* visitor,
       Extension::Location location)
-    : location_(location),
-      visitor_(visitor),
-      visit_count_(0),
-      creation_flags_(Extension::NO_FLAGS) {
-  }
-
-  MockExtensionProvider(
-      VisitorInterface* visitor,
-      Extension::Location location,
-      int creation_flags)
-  : location_(location),
-    visitor_(visitor),
-    visit_count_(0),
-    creation_flags_(creation_flags) {
+    : location_(location), visitor_(visitor), visit_count_(0) {
   }
 
   virtual ~MockExtensionProvider() {}
 
   void UpdateOrAddExtension(const std::string& id,
                             const std::string& version,
                             const FilePath& path) {
     extension_map_[id] = std::make_pair(version, path);
   }
 
   void RemoveExtension(const std::string& id) {
     extension_map_.erase(id);
   }
 
   // ExternalExtensionProvider implementation:
   virtual void VisitRegisteredExtension() OVERRIDE {
     visit_count_++;
     for (DataMap::const_iterator i = extension_map_.begin();
          i != extension_map_.end(); ++i) {
       scoped_ptr<Version> version;
       version.reset(Version::GetVersionFromString(i->second.first));
 
       visitor_->OnExternalExtensionFileFound(
           i->first, version.get(), i->second.second, location_,
-          creation_flags_, false);
+          Extension::NO_FLAGS, false);
     }
     visitor_->OnExternalProviderReady(this);
   }
 
   virtual bool HasExtension(const std::string& id) const OVERRIDE {
     return extension_map_.find(id) != extension_map_.end();
   }
 
   virtual bool GetExtensionDetails(
       const std::string& id,
       Extension::Location* location,
       scoped_ptr<Version>* version) const OVERRIDE {
     DataMap::const_iterator it = extension_map_.find(id);
     if (it == extension_map_.end())
       return false;
 
     if (version)
       version->reset(Version::GetVersionFromString(it->second.first));
 
     if (location)
       *location = location_;
 
     return true;
   }
 
   virtual bool IsReady() const OVERRIDE {
     return true;
   }
 
-  virtual int GetCreationFlags() const OVERRIDE {
-    return creation_flags_;
-  }
-
   virtual void ServiceShutdown() OVERRIDE {
   }
 
   int visit_count() const { return visit_count_; }
   void set_visit_count(int visit_count) {
     visit_count_ = visit_count;
   }
 
  private:
   typedef std::map< std::string, std::pair<std::string, FilePath> > DataMap;
   DataMap extension_map_;
   Extension::Location location_;
   VisitorInterface* visitor_;
 
   // visit_count_ tracks the number of calls to VisitRegisteredExtension().
   // Mutable because it must be incremented on each call to
   // VisitRegisteredExtension(), which must be a const method to inherit
   // from the class being mocked.
   mutable int visit_count_;
 
-  int creation_flags_;
-
   DISALLOW_COPY_AND_ASSIGN(MockExtensionProvider);
 };
 
 class MockProviderVisitor
     : public ExternalExtensionProviderInterface::VisitorInterface {
  public:
 
   // The provider will return |fake_base_path| from
   // GetBaseCrxFilePath().  User can test the behavior with
   // and without an empty path using this parameter.
   explicit MockProviderVisitor(FilePath fake_base_path)
       : ids_found_(0),
-        fake_base_path_(fake_base_path) {
+        fake_base_path_(fake_base_path),
+        expected_creation_flags_(Extension::NO_FLAGS) {
+  }
+
+  MockProviderVisitor(FilePath fake_base_path, int expected_creation_flags)
+      : ids_found_(0),
+        fake_base_path_(fake_base_path),
+        expected_creation_flags_(expected_creation_flags) {
   }
 
   int Visit(const std::string& json_data) {
     // Give the test json file to the provider for parsing.
     provider_.reset(new ExternalExtensionProviderImpl(
         this,
         new ExternalTestingExtensionLoader(json_data, fake_base_path_),
         Extension::EXTERNAL_PREF,
         Extension::EXTERNAL_PREF_DOWNLOAD,
         Extension::NO_FLAGS));
@@ skipping 19 matching lines @@
 
     return ids_found_;
   }
 
   virtual bool OnExternalExtensionFileFound(const std::string& id,
                                             const Version* version,
                                             const FilePath& path,
                                             Extension::Location unused,
                                             int creation_flags,
                                             bool mark_acknowledged) {
-    EXPECT_EQ(Extension::NO_FLAGS, creation_flags);
+    EXPECT_EQ(expected_creation_flags_, creation_flags);
 
     ++ids_found_;
     DictionaryValue* pref;
     // This tests is to make sure that the provider only notifies us of the
     // values we gave it. So if the id we doesn't exist in our internal
     // dictionary then something is wrong.
     EXPECT_TRUE(prefs_->GetDictionary(id, &pref))
        << "Got back ID (" << id.c_str() << ") we weren't expecting";
 
     EXPECT_TRUE(path.IsAbsolute());
@@ skipping 53 matching lines @@
 
   virtual void OnExternalProviderReady(
       const ExternalExtensionProviderInterface* provider) {
     EXPECT_EQ(provider, provider_.get());
     EXPECT_TRUE(provider->IsReady());
   }
 
  private:
   int ids_found_;
   FilePath fake_base_path_;
+  int expected_creation_flags_;
   scoped_ptr<ExternalExtensionProviderImpl> provider_;
   scoped_ptr<DictionaryValue> prefs_;
 
   DISALLOW_COPY_AND_ASSIGN(MockProviderVisitor);
 };
 
 // Our message loop may be used in tests which require it to be an IO loop.
 ExtensionServiceTestBase::ExtensionServiceTestBase()
     : loop_(MessageLoop::TYPE_IO),
       service_(NULL),
@@ skipping 870 matching lines @@
 // extension object.
 TEST_F(ExtensionServiceTest, InstallingExternalExtensionWithFlags) {
   const char kPrefFromBookmark[] = "from_bookmark";
 
   InitializeEmptyExtensionService();
 
   FilePath path = data_dir_.AppendASCII("good.crx");
   set_extensions_enabled(true);
 
   // Register and install an external extension.
-  MockExtensionProvider* provider =
-      new MockExtensionProvider(service_,
-                                Extension::EXTERNAL_POLICY_DOWNLOAD,
-                                Extension::FROM_BOOKMARK);
-  AddMockExternalProvider(provider);
-  provider->UpdateOrAddExtension(good_crx, "1.0.0.0",
-                                 data_dir_.AppendASCII("good.crx"));
-  service_->CheckForExternalUpdates();
+  scoped_ptr<Version> version(Version::GetVersionFromString("1.0.0.0"));
+  service_->OnExternalExtensionFileFound(
+      good_crx,
+      version.get(),
+      path,
+      Extension::EXTERNAL_PREF,
+      Extension::FROM_BOOKMARK,
+      false /* mark_acknowledged */);
   loop_.RunAllPending();
 
   const Extension* extension = service_->GetExtensionById(good_crx, false);
   ASSERT_TRUE(extension);
   ASSERT_TRUE(extension->from_bookmark());
   ValidateBooleanPref(good_crx, kPrefFromBookmark, true);
 
   // Upgrade to version 2.0, the flag should be preserved.
   path = data_dir_.AppendASCII("good2.crx");
   UpdateExtension(good_crx, path, ENABLED);
   ValidateBooleanPref(good_crx, kPrefFromBookmark, true);
   extension = service_->GetExtensionById(good_crx, false);
   ASSERT_TRUE(extension);
   ASSERT_TRUE(extension->from_bookmark());
-
-  // Somehow, the "from bookmark pref" gets reset (simulating
-  // http://crbug.com/109791).
-  SetPrefBool(extension->id(), kPrefFromBookmark, false);
-  service_->ReloadExtensions();
-  extension = service_->GetExtensionById(good_crx, false);
-  ASSERT_TRUE(extension);
-  ASSERT_FALSE(extension->from_bookmark());
-  ValidateBooleanPref(good_crx, kPrefFromBookmark, false);
-
-  // If the app gets updated again, we'll reset the "from bookmark" pref if
-  // the external extension provider is still serving that extension.
-  UpdateExtension(good_crx, path, ENABLED);
-  ValidateBooleanPref(good_crx, kPrefFromBookmark, true);
-  extension = service_->GetExtensionById(good_crx, false);
-  ASSERT_TRUE(extension);
-  ASSERT_TRUE(extension->from_bookmark());
 }
 
 // Test the handling of Extension::EXTERNAL_EXTENSION_UNINSTALLED
 TEST_F(ExtensionServiceTest, UninstallingExternalExtensions) {
   InitializeEmptyExtensionService();
 
   FilePath path = data_dir_.AppendASCII("good.crx");
   set_extensions_enabled(true);
 
   scoped_ptr<Version> version;
@@ skipping 1581 matching lines @@
   EXPECT_TRUE(service_->GetExtensionById(good_crx, false));
 }
 
 TEST_F(ExtensionServiceTest, ExternalExtensionAutoAcknowledgement) {
   InitializeEmptyExtensionService();
   set_extensions_enabled(true);
 
   {
     // Register and install an external extension.
     MockExtensionProvider* provider =
-        new MockExtensionProvider(service_, Extension::EXTERNAL_PREF, 0);
+        new MockExtensionProvider(service_, Extension::EXTERNAL_PREF);
     AddMockExternalProvider(provider);
     provider->UpdateOrAddExtension(good_crx, "1.0.0.0",
                                    data_dir_.AppendASCII("good.crx"));
   }
   {
     // Have policy force-install an extension.
     MockExtensionProvider* provider =
         new MockExtensionProvider(service_,
                                   Extension::EXTERNAL_POLICY_DOWNLOAD);
     AddMockExternalProvider(provider);
@@ skipping 861 matching lines @@
       "  \"cccccccccccccccccccccccccccccccc\": {"
       "    \"external_crx\": \"RandomExtension2.crx\","
       "    \"external_version\": \"3.0\","
       "    \"supported_locales\": [ \"en_US\", \"fr\" ]"
       "  }"
       "}";
   {
     ScopedBrowserLocale guard("en-US");
     EXPECT_EQ(2, visitor.Visit(json_data));
   }
+
+  // Test is_bookmark_app.
+  MockProviderVisitor from_bookmark_visitor(
+      base_path, Extension::FROM_BOOKMARK);
+  json_data =
+      "{"
+      "  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\": {"
+      "    \"external_crx\": \"RandomExtension.crx\","
+      "    \"external_version\": \"1.0\","
+      "    \"is_bookmark_app\": true"
+      "  }"
+      "}";
+  EXPECT_EQ(1, from_bookmark_visitor.Visit(json_data));
 }
 
 // Test loading good extensions from the profile directory.
 TEST_F(ExtensionServiceTest, LoadAndRelocalizeExtensions) {
   // Initialize the test dir with a good Preferences/extensions.
   FilePath source_install_dir = data_dir_
       .AppendASCII("l10n");
   FilePath pref_path = source_install_dir.AppendASCII("Preferences");
   InitializeInstalledExtensionService(pref_path, source_install_dir);
 
@@ skipping 1057 matching lines @@
   // Now that the extension is installed, sync request should fail
   // because the extension is already installed.
   ASSERT_FALSE(AddPendingSyncInstall());
 }
 
 TEST_F(ExtensionServiceTest, AlertableExtensionHappyPath) {
   InitializeEmptyExtensionService();
   scoped_ptr<ExtensionGlobalError> extension_global_error(
       new ExtensionGlobalError(service_));
   MockExtensionProvider* provider =
-      new MockExtensionProvider(service_,
-                                Extension::EXTERNAL_PREF,
-                                0);
+      new MockExtensionProvider(service_, Extension::EXTERNAL_PREF);
   AddMockExternalProvider(provider);
 
   // Should return false, meaning there aren't any extensions that the user
   // needs to know about.
   ASSERT_FALSE(service_->PopulateExtensionGlobalError(
       extension_global_error.get()));
 
   // This is a normal extension, installed normally.
   // This should NOT trigger an alert.
   set_extensions_enabled(true);
@@ skipping 10 matching lines @@
   provider->UpdateOrAddExtension(hosted_app, "1.0.0.0",
                                  data_dir_.AppendASCII("hosted_app.crx"));
 
   service_->CheckForExternalUpdates();
   loop_.RunAllPending();
 
   ASSERT_TRUE(service_->PopulateExtensionGlobalError(
       extension_global_error.get()));
   ASSERT_EQ(1u, extension_global_error->get_external_extension_ids()->size());
 }