Exempt default apps from external-extension alerts.

chrome/browser/extensions/extension_service_unittest.cc

 // Copyright (c) 2011 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 137 matching lines @@
   // ExternalExtensionProvider implementation:
   virtual void VisitRegisteredExtension() {
     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_,
-          Extension::NO_FLAGS);
+          Extension::NO_FLAGS, false);
     }
     visitor_->OnExternalProviderReady(this);
   }
 
   virtual bool HasExtension(const std::string& id) const {
     return extension_map_.find(id) != extension_map_.end();
   }
 
   virtual bool GetExtensionDetails(const std::string& id,
                                    Extension::Location* location,
@@ skipping 78 matching lines @@
     // Ask the provider to look up all extensions and return them.
     provider_->VisitRegisteredExtension();
 
     return ids_found_;
   }
 
   virtual void OnExternalExtensionFileFound(const std::string& id,
                                             const Version* version,
                                             const FilePath& path,
                                             Extension::Location unused,
-                                            int creation_flags) {
+                                            int creation_flags,
+                                            bool mark_acknowledged) {
     EXPECT_EQ(Extension::NO_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";
 
@@ skipping 980 matching lines @@
   InitializeEmptyExtensionService();
 
   FilePath path = data_dir_.AppendASCII("good.crx");
   set_extensions_enabled(true);
 
   scoped_ptr<Version> version;
   version.reset(Version::GetVersionFromString("1.0.0.0"));
   // Install an external extension.
   service_->OnExternalExtensionFileFound(good_crx, version.get(),
                                          path, Extension::EXTERNAL_PREF,
-                                         Extension::FROM_BOOKMARK);
+                                         Extension::FROM_BOOKMARK, false);
   loop_.RunAllPending();
 
   const Extension* extension = service_->GetExtensionById(good_crx, false);
   ASSERT_TRUE(extension);
   ASSERT_EQ(Extension::FROM_BOOKMARK,
             Extension::FROM_BOOKMARK & extension->creation_flags());
 }
 
 // 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;
   version.reset(Version::GetVersionFromString("1.0.0.0"));
   // Install an external extension.
   service_->OnExternalExtensionFileFound(good_crx, version.get(),
                                          path, Extension::EXTERNAL_PREF,
-                                         Extension::NO_FLAGS);
+                                         Extension::NO_FLAGS, false);
   loop_.RunAllPending();
   ASSERT_TRUE(service_->GetExtensionById(good_crx, false));
 
   // Uninstall it and check that its killbit gets set.
   UninstallExtension(good_crx, false);
   ValidateIntegerPref(good_crx, "location",
                       Extension::EXTERNAL_EXTENSION_UNINSTALLED);
 
   // Try to re-install it externally. This should fail because of the killbit.
   service_->OnExternalExtensionFileFound(good_crx, version.get(),
                                          path, Extension::EXTERNAL_PREF,
-                                         Extension::NO_FLAGS);
+                                         Extension::NO_FLAGS, false);
   loop_.RunAllPending();
   ASSERT_TRUE(NULL == service_->GetExtensionById(good_crx, false));
   ValidateIntegerPref(good_crx, "location",
                       Extension::EXTERNAL_EXTENSION_UNINSTALLED);
 
   version.reset(Version::GetVersionFromString("1.0.0.1"));
   // Repeat the same thing with a newer version of the extension.
   path = data_dir_.AppendASCII("good2.crx");
   service_->OnExternalExtensionFileFound(good_crx, version.get(),
                                          path, Extension::EXTERNAL_PREF,
-                                         Extension::NO_FLAGS);
+                                         Extension::NO_FLAGS, false);
   loop_.RunAllPending();
   ASSERT_TRUE(NULL == service_->GetExtensionById(good_crx, false));
   ValidateIntegerPref(good_crx, "location",
                       Extension::EXTERNAL_EXTENSION_UNINSTALLED);
 
   // Try adding the same extension from an external update URL.
   service_->pending_extension_manager()->AddFromExternalUpdateUrl(
       good_crx,
       GURL("http:://fake.update/url"),
       Extension::EXTERNAL_PREF_DOWNLOAD);
@@ skipping 39 matching lines @@
   version.reset(Version::GetVersionFromString("1.0.0.0"));
 
   const std::string wrong_id = all_zero;
   const std::string correct_id = good_crx;
   ASSERT_NE(correct_id, wrong_id);
 
   // Install an external extension with an ID from the external
   // source that is not equal to the ID in the extension manifest.
   service_->OnExternalExtensionFileFound(
       wrong_id, version.get(), path, Extension::EXTERNAL_PREF,
-      Extension::NO_FLAGS);
+      Extension::NO_FLAGS, false);
 
   loop_.RunAllPending();
   ASSERT_FALSE(service_->GetExtensionById(good_crx, false));
 
   // Try again with the right ID. Expect success.
   service_->OnExternalExtensionFileFound(
       correct_id, version.get(), path, Extension::EXTERNAL_PREF,
-      Extension::NO_FLAGS);
+      Extension::NO_FLAGS, false);
   loop_.RunAllPending();
   ASSERT_TRUE(service_->GetExtensionById(good_crx, false));
 }
 
 // Test that external extensions with incorrect versions are not installed.
 TEST_F(ExtensionServiceTest, FailOnWrongVersion) {
   InitializeEmptyExtensionService();
   FilePath path = data_dir_.AppendASCII("good.crx");
   set_extensions_enabled(true);
 
   // Install an external extension with a version from the external
   // source that is not equal to the version in the extension manifest.
   scoped_ptr<Version> wrong_version;
   wrong_version.reset(Version::GetVersionFromString("1.2.3.4"));
   service_->OnExternalExtensionFileFound(
       good_crx, wrong_version.get(), path, Extension::EXTERNAL_PREF,
-      Extension::NO_FLAGS);
+      Extension::NO_FLAGS, false);
 
   loop_.RunAllPending();
   ASSERT_FALSE(service_->GetExtensionById(good_crx, false));
 
   // Try again with the right version. Expect success.
   scoped_ptr<Version> correct_version;
   correct_version.reset(Version::GetVersionFromString("1.0.0.0"));
   service_->OnExternalExtensionFileFound(
       good_crx, correct_version.get(), path, Extension::EXTERNAL_PREF,
-      Extension::NO_FLAGS);
+      Extension::NO_FLAGS, false);
   loop_.RunAllPending();
   ASSERT_TRUE(service_->GetExtensionById(good_crx, false));
 }
 
 // Install a user script (they get converted automatically to an extension)
 TEST_F(ExtensionServiceTest, InstallUserScript) {
   // The details of script conversion are tested elsewhere, this just tests
   // integration with ExtensionService.
   InitializeEmptyExtensionService();
 
@@ skipping 2757 matching lines @@
         crx_id_, GURL(), Extension::EXTERNAL_PREF_DOWNLOAD);
   }
 
   // Fake an external file from external_extensions.json.
   void AddPendingExternalPrefFileInstall() {
     scoped_ptr<Version> version;
     version.reset(Version::GetVersionFromString("1.0.0.0"));
 
     service_->OnExternalExtensionFileFound(
         crx_id_, version.get(), crx_path_, Extension::EXTERNAL_PREF,
-        Extension::NO_FLAGS);
+        Extension::NO_FLAGS, false);
   }
 
   // Fake a request from sync to install an extension.
   bool AddPendingSyncInstall() {
     return service_->pending_extension_manager()->AddFromSync(
         crx_id_, GURL(kGoodUpdateURL), &IsExtension, kGoodInstallSilently);
   }
 
   // Fake a policy install.
   void AddPendingPolicyInstall() {
@@ skipping 103 matching lines @@
   ASSERT_FALSE(AddPendingSyncInstall());
 
   // Wait for the external source to install.
   WaitForCrxInstall(crx_path_, INSTALL_NEW);
   ASSERT_TRUE(IsCrxInstalled());
 
   // Now that the extension is installed, sync request should fail
   // because the extension is already installed.
   ASSERT_FALSE(AddPendingSyncInstall());
 }