Add in-profile external_extensions.json file for Chrome OS OEM customization.

chrome/browser/extensions/extension_service.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.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 221 matching lines @@
         : frontend_(NULL),
           install_directory_(install_directory),
           alert_on_error_(false) {
 }
 
 ExtensionServiceBackend::~ExtensionServiceBackend() {
 }
 
 void ExtensionServiceBackend::LoadSingleExtension(
     const FilePath& path_in, scoped_refptr<ExtensionService> frontend) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   frontend_ = frontend;
 
   // Explicit UI loads are always noisy.
   alert_on_error_ = true;
 
   FilePath extension_path = path_in;
   file_util::AbsolutePath(&extension_path);
 
   std::string error;
@@ skipping 12 matching lines @@
   // prefs.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(frontend_,
                         &ExtensionService::OnExtensionInstalled,
                         extension));
 }
 
 void ExtensionServiceBackend::ReportExtensionLoadError(
     const FilePath& extension_path, const std::string &error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(
           frontend_,
           &ExtensionService::ReportExtensionLoadError, extension_path,
           error, NotificationType::EXTENSION_INSTALL_ERROR, alert_on_error_));
 }
 
 void ExtensionService::CheckExternalUninstall(const std::string& id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Check if the providers know about this extension.
   ProviderCollection::const_iterator i;
   for (i = external_extension_providers_.begin();
        i != external_extension_providers_.end(); ++i) {
     DCHECK(i->get()->IsReady());
     if (i->get()->HasExtension(id))
       return;  // Yup, known extension, don't uninstall.
   }
 
   // This is an external extension that we don't have registered.  Uninstall.
   UninstallExtension(id, true);
 }
 
 void ExtensionService::ClearProvidersForTesting() {
   external_extension_providers_.clear();
 }
 
 void ExtensionService::AddProviderForTesting(
     ExternalExtensionProviderInterface* test_provider) {
-  DCHECK(test_provider);
+  CHECK(test_provider);
   external_extension_providers_.push_back(
       linked_ptr<ExternalExtensionProviderInterface>(test_provider));
 }
 
 void ExtensionService::OnExternalExtensionUpdateUrlFound(
     const std::string& id,
     const GURL& update_url,
     Extension::Location location) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(Extension::IdIsValid(id));
 
   if (GetExtensionById(id, true)) {
     // Already installed.  Do not change the update URL that the extension set.
     return;
   }
   AddPendingExtensionFromExternalUpdateUrl(id, update_url, location);
-  external_extension_added_ |= true;
+  external_extension_url_added_ |= true;
 }
 
 bool ExtensionService::IsDownloadFromGallery(const GURL& download_url,
-                                              const GURL& referrer_url) {
+                                             const GURL& referrer_url) {
   // Special-case the themes mini-gallery.
   // TODO(erikkay) When that gallery goes away, remove this code.
   if (IsDownloadFromMiniGallery(download_url) &&
       StartsWithASCII(referrer_url.spec(),
                       extension_urls::kMiniGalleryBrowsePrefix, false)) {
     return true;
   }
 
   const Extension* download_extension = GetExtensionByWebExtent(download_url);
   const Extension* referrer_extension = GetExtensionByWebExtent(referrer_url);
@@ skipping 47 matching lines @@
 
   // Check for packaged app.
   const Extension* extension = GetExtensionByURL(url);
   return extension != NULL && extension->is_app();
 }
 
 // static
 bool ExtensionService::UninstallExtensionHelper(
     ExtensionService* extensions_service,
     const std::string& extension_id) {
-  DCHECK(extensions_service);
+  CHECK(extensions_service);

[Erik does not do reviews, 2011/01/21 17:05:25]

you can remove this since the next line crashes the same way

[Sam Kerner (Chrome), 2011/01/21 17:59:26]

Done.

 
   // We can't call UninstallExtension with an invalid extension ID, so check it
   // first.
   if (extensions_service->GetExtensionById(extension_id, true)) {
     extensions_service->UninstallExtension(extension_id, false);
   } else {
     LOG(WARNING) << "Attempted uninstallation of non-existent extension with "
       << "id: " << extension_id;
     return false;
   }
 
   return true;
 }
 
 ExtensionService::ExtensionService(Profile* profile,
                                    const CommandLine* command_line,
                                    const FilePath& install_directory,
                                    ExtensionPrefs* extension_prefs,
                                    bool autoupdate_enabled)
     : profile_(profile),
       extension_prefs_(extension_prefs),
       install_directory_(install_directory),
       extensions_enabled_(true),
       show_extensions_prompts_(true),
       ready_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(toolbar_model_(this)),
       default_apps_(profile->GetPrefs(),
                     g_browser_process->GetApplicationLocale()),
       event_routers_initialized_(false) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Figure out if extension installation should be enabled.
   if (command_line->HasSwitch(switches::kDisableExtensions)) {
     extensions_enabled_ = false;
   } else if (profile->GetPrefs()->GetBoolean(prefs::kDisableExtensions)) {
     extensions_enabled_ = false;
   }
 
   registrar_.Add(this, NotificationType::EXTENSION_PROCESS_TERMINATED,
                  NotificationService::AllSources());
@@ skipping 76 matching lines @@
   ExtensionWebNavigationEventRouter::GetInstance()->Init();
   event_routers_initialized_ = true;
 }
 
 const Extension* ExtensionService::GetExtensionById(const std::string& id,
                                                      bool include_disabled) {
   return GetExtensionByIdInternal(id, true, include_disabled);
 }
 
 void ExtensionService::Init() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DCHECK(!ready_);  // Can't redo init.
   DCHECK_EQ(extensions_.size(), 0u);
 
   // Hack: we need to ensure the ResourceDispatcherHost is ready before we load
   // the first extension, because its members listen for loaded notifications.
   g_browser_process->resource_dispatcher_host();
 
   LoadAllExtensions();
 
   // TODO(erikkay) this should probably be deferred to a future point
   // rather than running immediately at startup.
   CheckForExternalUpdates();
 
   // TODO(erikkay) this should probably be deferred as well.
   GarbageCollectExtensions();
 }
 
 void ExtensionService::InstallExtension(const FilePath& extension_path) {
   scoped_refptr<CrxInstaller> installer(
       new CrxInstaller(this,  // frontend
                        NULL));  // no client (silent install)
   installer->InstallCrx(extension_path);
 }
 
 namespace {
   // TODO(akalin): Put this somewhere where both crx_installer.cc and
   // this file can use it.
   void DeleteFileHelper(const FilePath& path, bool recursive) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+    CHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
     file_util::Delete(path, recursive);
   }
 }  // namespace
 
 void ExtensionService::UpdateExtension(const std::string& id,
                                         const FilePath& extension_path,
                                         const GURL& download_url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   PendingExtensionMap::const_iterator it = pending_extensions_.find(id);
   bool is_pending_extension = (it != pending_extensions_.end());
 
   const Extension* extension = GetExtensionByIdInternal(id, true, true);
   if (!is_pending_extension && !extension) {
     LOG(WARNING) << "Will not update extension " << id
                  << " because it is not installed or pending";
     // Delete extension_path since we're not creating a CrxInstaller
     // that would do it for us.
@@ skipping 97 matching lines @@
                               kEnableOnInstall, kEnableIncognitoOnInstall,
                               Extension::INTERNAL);
 }
 
 void ExtensionService::AddPendingExtensionInternal(
     const std::string& id, const GURL& update_url,
     ShouldInstallExtensionPredicate should_install_extension,
     bool is_from_sync, bool install_silently,
     bool enable_on_install, bool enable_incognito_on_install,
     Extension::Location install_source) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If a non-sync update is pending, a sync request should not
   // overwrite it.  This is important for external extensions.
   // If an external extension download is pending, and the user has
   // the extension in their sync profile, the install should set the
   // type to be external.  An external extension should not be
   // rejected if it fails the safty checks for a syncable extension.
   // TODO(skerner): Work out other potential overlapping conditions.
   // (crbug.com/61000)
   PendingExtensionMap::iterator it = pending_extensions_.find(id);
   if (it != pending_extensions_.end()) {
     VLOG(1) << "Extension id " << id
             << " was entered for update more than once."
             << "  old is_from_sync = " << it->second.is_from_sync
             << "  new is_from_sync = " << is_from_sync;
     if (!it->second.is_from_sync && is_from_sync)
       return;
   }
 
   pending_extensions_[id] =
       PendingExtensionInfo(update_url, should_install_extension,
                            is_from_sync, install_silently, enable_on_install,
                            enable_incognito_on_install, install_source);
 }
 
 void ExtensionService::ReloadExtension(const std::string& extension_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FilePath path;
   const Extension* current_extension = GetExtensionById(extension_id, false);
 
   // Disable the extension if it's loaded. It might not be loaded if it crashed.
   if (current_extension) {
     // If the extension has an inspector open for its background page, detach
     // the inspector and hang onto a cookie for it, so that we can reattach
     // later.
     ExtensionProcessManager* manager = profile_->GetExtensionProcessManager();
     ExtensionHost* host = manager->GetBackgroundHostForExtension(
@@ skipping 23 matching lines @@
   } else {
     // We should always be able to remember the extension's path. If it's not in
     // the map, someone failed to update |unloaded_extension_paths_|.
     CHECK(!path.empty());
     LoadExtension(path);
   }
 }
 
 void ExtensionService::UninstallExtension(const std::string& extension_id,
                                            bool external_uninstall) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const Extension* extension =
       GetExtensionByIdInternal(extension_id, true, true);
 
   // Callers should not send us nonexistent extensions.
   CHECK(extension);
 
   // Get hold of information we need after unloading, since the extension
   // pointer will be invalid then.
   GURL extension_url(extension->url());
@@ skipping 36 matching lines @@
       Details<UninstalledExtensionInfo>(&uninstalled_extension_info));
 }
 
 void ExtensionService::ClearExtensionData(const GURL& extension_url) {
   scoped_refptr<ExtensionDataDeleter> deleter(
       new ExtensionDataDeleter(profile_, extension_url));
   deleter->StartDeleting();
 }
 
 void ExtensionService::EnableExtension(const std::string& extension_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const Extension* extension =
       GetExtensionByIdInternal(extension_id, false, true);
   if (!extension)
     return;
 
   extension_prefs_->SetExtensionState(extension, Extension::ENABLED);
 
   // Move it over to the enabled list.
   extensions_.push_back(make_scoped_refptr(extension));
   ExtensionList::iterator iter = std::find(disabled_extensions_.begin(),
                                            disabled_extensions_.end(),
                                            extension);
   disabled_extensions_.erase(iter);
 
   // Make sure any browser action contained within it is not hidden.
   extension_prefs_->SetBrowserActionVisibility(extension, true);
 
   ExtensionDOMUI::RegisterChromeURLOverrides(profile_,
       extension->GetChromeURLOverrides());
 
   NotifyExtensionLoaded(extension);
   UpdateActiveExtensionsInCrashReporter();
 }
 
 void ExtensionService::DisableExtension(const std::string& extension_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const Extension* extension =
       GetExtensionByIdInternal(extension_id, true, false);
   // The extension may have been disabled already.
   if (!extension)
     return;
 
   extension_prefs_->SetExtensionState(extension, Extension::DISABLED);
 
   // Move it over to the disabled list.
@@ skipping 61 matching lines @@
     if (!extension.get()) {
       NOTREACHED() << error;
       return;
     }
 
     OnExtensionLoaded(extension);
   }
 }
 
 void ExtensionService::LoadAllExtensions() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::TimeTicks start_time = base::TimeTicks::Now();
 
   // Load any component extensions.
   LoadComponentExtensions();
 
   // Load the previously installed extensions.
   scoped_ptr<ExtensionPrefs::ExtensionsInfo> extensions_info(
       extension_prefs_->GetInstalledExtensionsInfo());
 
@@ skipping 405 matching lines @@
 
 // Some extensions will autoupdate themselves externally from Chrome.  These
 // are typically part of some larger client application package.  To support
 // these, the extension will register its location in the the preferences file
 // (and also, on Windows, in the registry) and this code will periodically
 // check that location for a .crx file, which it will then install locally if
 // a new version is available.
 // Errors are reported through ExtensionErrorReporter. Succcess is not
 // reported.
 void ExtensionService::CheckForExternalUpdates() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Note that this installation is intentionally silent (since it didn't
   // go through the front-end).  Extensions that are registered in this
   // way are effectively considered 'pre-bundled', and so implicitly
   // trusted.  In general, if something has HKLM or filesystem access,
   // they could install an extension manually themselves anyway.
-  external_extension_added_ = false;
+
+  // If any external extension records give a URL, a provider will set
+  // this to true.  Used by OnExternalProviderReady() to see if we need
+  // to start an update check to fetch a new external extension.
+  external_extension_url_added_ = false;
 
   // Ask each external extension provider to give us a call back for each
   // extension they know about. See OnExternalExtension(File|UpdateUrl)Found.
   ProviderCollection::const_iterator i;
   for (i = external_extension_providers_.begin();
        i != external_extension_providers_.end(); ++i) {
     ExternalExtensionProviderInterface* provider = i->get();
     provider->VisitRegisteredExtension();
   }
 
   // Uninstall of unclaimed extensions will happen after all the providers
-  // had reported ready. Trigger uninstall even if there are no providers
-  // installed:
-  OnExternalProviderReady();
+  // had reported ready.  Every provider calls OnExternalProviderReady()
+  // when it finishes, and OnExternalProviderReady() only acts when all
+  // providers are ready.  In case there are no providers, we call it
+  // to trigger removal of extensions that used to have an external source.
+  if (external_extension_providers_.empty())
+    OnExternalProviderReady();
 }
 
 void ExtensionService::OnExternalProviderReady() {
-  // An external provider has finished loading. We only take action
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // An external provider has finished loading.  We only take action
   // if all of them are finished. So we check them first.
   ProviderCollection::const_iterator i;
   for (i = external_extension_providers_.begin();
        i != external_extension_providers_.end(); ++i) {
     ExternalExtensionProviderInterface* provider = i->get();
-    if (!provider->IsReady()) {
+    if (!provider->IsReady())
       return;
-    }
   }
 
-  // All the providers are ready. Install any pending extensions.
-  if (external_extension_added_ && updater()) {
-    external_extension_added_ = false;
+  // All the providers are ready.  Install any pending extensions.
+  if (external_extension_url_added_ && updater()) {
+    external_extension_url_added_ = false;
     updater()->CheckNow();
   }
 
   // Uninstall all the unclaimed extensions.
   scoped_ptr<ExtensionPrefs::ExtensionsInfo> extensions_info(
       extension_prefs_->GetInstalledExtensionsInfo());
   for (size_t i = 0; i < extensions_info->size(); ++i) {
     ExtensionInfo* info = extensions_info->at(i).get();
     if (Extension::IsExternalLocation(info->extension_location))
       CheckExternalUninstall(info->extension_id);
@@ skipping 252 matching lines @@
   for (size_t i = 0; i < extensions_.size(); ++i) {
     if (!extensions_[i]->is_theme() &&
         extensions_[i]->location() != Extension::COMPONENT)
       extension_ids.insert(extensions_[i]->id());
   }
 
   child_process_logging::SetActiveExtensions(extension_ids);
 }
 
 void ExtensionService::OnExtensionInstalled(const Extension* extension) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Ensure extension is deleted unless we transfer ownership.
   scoped_refptr<const Extension> scoped_extension(extension);
   Extension::State initial_state = Extension::DISABLED;
   bool initial_enable_incognito = false;
   PendingExtensionMap::iterator it =
       pending_extensions_.find(extension->id());
   if (it != pending_extensions_.end()) {
     PendingExtensionInfo pending_extension_info = it->second;
     pending_extensions_.erase(it);
@@ skipping 315 matching lines @@
 }
 
 void ExtensionService::SetBeingUpgraded(const Extension* extension,
                                          bool value) {
   extension_runtime_data_[extension->id()].being_upgraded = value;
 }
 
 PropertyBag* ExtensionService::GetPropertyBag(const Extension* extension) {
   return &extension_runtime_data_[extension->id()].property_bag;
 }