Revert 113047 - Make ExtensionService use ExtensionSet.

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 426 matching lines @@
   omnibox_popup_icon_manager_.set_monochrome(true);
   omnibox_icon_manager_.set_monochrome(true);
   omnibox_icon_manager_.set_padding(gfx::Insets(0, kOmniboxIconPaddingLeft,
                                                 0, kOmniboxIconPaddingRight));
 
   // How long is the path to the Extensions directory?
   UMA_HISTOGRAM_CUSTOM_COUNTS("Extensions.ExtensionRootPathLength",
                               install_directory_.value().length(), 0, 500, 100);
 }
 
-const ExtensionSet* ExtensionService::extensions() const {
+const ExtensionList* ExtensionService::extensions() const {
   return &extensions_;
 }
 
-const ExtensionSet* ExtensionService::disabled_extensions() const {
+const ExtensionList* ExtensionService::disabled_extensions() const {
   return &disabled_extensions_;
 }
 
-const ExtensionSet* ExtensionService::terminated_extensions() const {
+const ExtensionList* ExtensionService::terminated_extensions() const {
   return &terminated_extensions_;
 }
 
 PendingExtensionManager* ExtensionService::pending_extension_manager() {
   return &pending_extension_manager_;
 }
 
 ExtensionService::~ExtensionService() {
   // No need to unload extensions here because they are profile-scoped, and the
   // profile is in the process of being deleted.
@@ skipping 293 matching lines @@
   // Therefore, we clear warnings of this type for all extensions.
   std::set<ExtensionWarningSet::WarningType> warnings;
   extension_warnings_.GetWarningsAffectingExtension(extension_id, &warnings);
   extension_warnings_.ClearWarnings(warnings);
 
   return true;
 }
 
 bool ExtensionService::IsExtensionEnabled(
     const std::string& extension_id) const {
-  if (extensions_.Contains(extension_id) ||
-      terminated_extensions_.Contains(extension_id))
+  const Extension* extension =
+      GetExtensionByIdInternal(extension_id, true, false, true);
+  if (extension)
     return true;
 
-  if (disabled_extensions_.Contains(extension_id))
+  extension =
+      GetExtensionByIdInternal(extension_id, false, true, false);
+  if (extension)
     return false;
 
   // If the extension hasn't been loaded yet, check the prefs for it. Assume
   // enabled unless otherwise noted.
   return !extension_prefs_->IsExtensionDisabled(extension_id) &&
       !extension_prefs_->IsExternalExtensionUninstalled(extension_id);
 }
 
 bool ExtensionService::IsExternalExtensionUninstalled(
     const std::string& extension_id) const {
   return extension_prefs_->IsExternalExtensionUninstalled(extension_id);
 }
 
 void ExtensionService::EnableExtension(const std::string& extension_id) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (IsExtensionEnabled(extension_id))
     return;
 
   extension_prefs_->SetExtensionState(extension_id, Extension::ENABLED);
 
   const Extension* extension =
       GetExtensionByIdInternal(extension_id, false, true, false);
   // This can happen if sync enables an extension that is not
   // installed yet.
   if (!extension)
     return;
 
   // Move it over to the enabled list.
-  extensions_.Insert(make_scoped_refptr(extension));
-  disabled_extensions_.Remove(extension->id());
+  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);
 
   NotifyExtensionLoaded(extension);
 
   SyncExtensionChangeIfNeeded(*extension);
 }
 
 void ExtensionService::DisableExtension(const std::string& extension_id) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // The extension may have been disabled already.
   if (!IsExtensionEnabled(extension_id))
     return;
 
   const Extension* extension = GetInstalledExtension(extension_id);
   // |extension| can be NULL if sync disables an extension that is not
   // installed yet.
   if (extension && !Extension::UserMayDisable(extension->location()))
     return;
 
   extension_prefs_->SetExtensionState(extension_id, Extension::DISABLED);
 
   extension = GetExtensionByIdInternal(extension_id, true, false, true);
   if (!extension)
     return;
 
   // Move it over to the disabled list.
-  disabled_extensions_.Insert(make_scoped_refptr(extension));
-  if (extensions_.Contains(extension->id()))
-    extensions_.Remove(extension->id());
-  else
-    terminated_extensions_.Remove(extension->id());
+  disabled_extensions_.push_back(make_scoped_refptr(extension));
+  ExtensionList::iterator iter = std::find(extensions_.begin(),
+                                           extensions_.end(),
+                                           extension);
+  if (iter != extensions_.end()) {
+    extensions_.erase(iter);
+  } else {
+    iter = std::find(terminated_extensions_.begin(),
+                     terminated_extensions_.end(),
+                     extension);
+    terminated_extensions_.erase(iter);
+  }
 
   NotifyExtensionUnloaded(extension, extension_misc::UNLOAD_REASON_DISABLE);
 
   SyncExtensionChangeIfNeeded(*extension);
 
   // Deactivating one extension might have solved the problems of others.
   // Therefore, we clear warnings of this type for all extensions.
   std::set<ExtensionWarningSet::WarningType> warnings;
   extension_warnings_.GetWarningsAffectingExtension(extension_id, &warnings);
   extension_warnings_.ClearWarnings(warnings);
@@ skipping 246 matching lines @@
   // Use this set to indicate if an extension in the blacklist has been used.
   std::set<std::string> blacklist_set;
   for (unsigned int i = 0; i < blacklist.size(); ++i) {
     if (Extension::IdIsValid(blacklist[i])) {
       blacklist_set.insert(blacklist[i]);
     }
   }
   extension_prefs_->UpdateBlacklist(blacklist_set);
   std::vector<std::string> to_be_removed;
   // Loop current extensions, unload installed extensions.
-  for (ExtensionSet::const_iterator iter = extensions_.begin();
+  for (ExtensionList::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
     const Extension* extension = (*iter);
     if (blacklist_set.find(extension->id()) != blacklist_set.end()) {
       to_be_removed.push_back(extension->id());
     }
   }
 
   // UnloadExtension will change the extensions_ list. So, we should
   // call it outside the iterator loop.
   for (unsigned int i = 0; i < to_be_removed.size(); ++i) {
@@ skipping 22 matching lines @@
   return ready_;
 }
 
 ExtensionUpdater* ExtensionService::updater() {
   return updater_.get();
 }
 
 void ExtensionService::CheckAdminBlacklist() {
   std::vector<std::string> to_be_removed;
   // Loop through extensions list, unload installed extensions.
-  for (ExtensionSet::const_iterator iter = extensions_.begin();
+  for (ExtensionList::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
     const Extension* extension = (*iter);
     if (!extension_prefs_->IsExtensionAllowedByPolicy(extension->id(),
                                                       extension->location())) {
       to_be_removed.push_back(extension->id());
     }
   }
 
   // UnloadExtension will change the extensions_ list. So, we should
   // call it outside the iterator loop.
@@ skipping 180 matching lines @@
       bundle->synced_extensions.erase(extension_sync_data.id());
     else
       bundle->synced_extensions.insert(extension_sync_data.id());
     ProcessExtensionSyncData(extension_sync_data, *bundle);
   }
 
   return SyncError();
 }
 
 void ExtensionService::GetSyncDataListHelper(
-    const ExtensionSet& extensions,
+    const ExtensionList& extensions,
     const SyncBundle& bundle,
     std::vector<ExtensionSyncData>* sync_data_list) const {
-  for (ExtensionSet::const_iterator it = extensions.begin();
+  for (ExtensionList::const_iterator it = extensions.begin();
        it != extensions.end(); ++it) {
     const Extension& extension = **it;
     if (bundle.filter(extension) &&
         // If we have pending extension data for this extension, then this
         // version is out of date.  We'll sync back the version we got from
         // sync.
         !bundle.HasPendingExtensionId(extension.id())) {
       sync_data_list->push_back(ExtensionSyncData(
           extension,
           IsExtensionEnabled(extension.id()),
@@ skipping 110 matching lines @@
 
   // Broadcast unloaded and loaded events to update browser state. Only bother
   // if the value changed and the extension is actually enabled, since there is
   // no UI otherwise.
   bool old_enabled = extension_prefs_->IsIncognitoEnabled(extension_id);
   if (enabled == old_enabled)
     return;
 
   extension_prefs_->SetIsIncognitoEnabled(extension_id, enabled);
 
-  bool extension_is_enabled = extensions_.Contains(extension->id());
+  bool extension_is_enabled = std::find(extensions_.begin(), extensions_.end(),
+                                        extension) != extensions_.end();
 
   // When we reload the extension the ID may be invalidated if we've passed it
   // by const ref everywhere. Make a copy to be safe.
   std::string id = extension_id;
   if (extension_is_enabled)
     ReloadExtension(extension->id());
 
   // Reloading the extension invalidates the |extension| pointer.
   extension = GetInstalledExtension(id);
   if (extension)
@@ skipping 56 matching lines @@
 void ExtensionService::SetAllowFileAccess(const Extension* extension,
                                           bool allow) {
   // Reload to update browser state. Only bother if the value changed and the
   // extension is actually enabled, since there is no UI otherwise.
   bool old_allow = AllowFileAccess(extension);
   if (allow == old_allow)
     return;
 
   extension_prefs_->SetAllowFileAccess(extension->id(), allow);
 
-  bool extension_is_enabled = extensions_.Contains(extension->id());
+  bool extension_is_enabled = std::find(extensions_.begin(), extensions_.end(),
+                                        extension) != extensions_.end();
   if (extension_is_enabled)
     ReloadExtension(extension->id());
 }
 
 bool ExtensionService::GetBrowserActionVisibility(const Extension* extension) {
   return extension_prefs_->GetBrowserActionVisibility(extension);
 }
 
 void ExtensionService::SetBrowserActionVisibility(const Extension* extension,
                                                   bool visible) {
@@ skipping 83 matching lines @@
           switches::kEnableExtensionAlerts)) {
     return;  // TODO(miket): enable unconditionally when done.
   }
 
   // Build up the lists of extensions that require acknowledgment.
   // If this is the first time, grandfather extensions that would have
   // caused notification.
   scoped_ptr<ExtensionGlobalError> global_error(
       new ExtensionGlobalError(AsWeakPtr()));
   bool needs_alert = false;
-  for (ExtensionSet::const_iterator iter = extensions_.begin();
+  for (ExtensionList::const_iterator iter = extensions_.begin();
        iter != extensions_.end(); ++iter) {
     const Extension* e = *iter;
+    if (!IsExtensionEnabled(e->id())) {
+      continue;
+    }
     if (Extension::IsExternalLocation(e->location())) {
       if (!extension_prefs_->IsExternalExtensionAcknowledged(e->id())) {
         global_error->AddExternalExtension(e->id());
         needs_alert = true;
       }
     }
     if (extension_prefs_->IsExtensionBlacklisted(e->id())) {
       if (!extension_prefs_->IsBlacklistedExtensionAcknowledged(e->id())) {
         global_error->AddBlacklistedExtension(e->id());
         needs_alert = true;
@@ skipping 79 matching lines @@
   // Keep information about the extension so that we can reload it later
   // even if it's not permanently installed.
   unloaded_extension_paths_[extension->id()] = extension->path();
 
   // Clean up if the extension is meant to be enabled after a reload.
   disabled_extension_paths_.erase(extension->id());
 
   // Clean up runtime data.
   extension_runtime_data_.erase(extension_id);
 
-if (disabled_extensions_.Contains(extension->id())) {
+  ExtensionList::iterator iter = std::find(disabled_extensions_.begin(),
+                                           disabled_extensions_.end(),
+                                           extension.get());
+  if (iter != disabled_extensions_.end()) {
     UnloadedExtensionInfo details(extension, reason);
     details.already_disabled = true;
-    disabled_extensions_.Remove(extension->id());
+    disabled_extensions_.erase(iter);
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_UNLOADED,
         content::Source<Profile>(profile_),
         content::Details<UnloadedExtensionInfo>(&details));
     // Make sure the profile cleans up its RequestContexts when an already
     // disabled extension is unloaded (since they are also tracking the disabled
     // extensions).
     profile_->UnregisterExtensionWithRequestContexts(extension_id, reason);
     return;
   }
 
-// Remove the extension from our list.
-  extensions_.Remove(extension->id());
+  iter = std::find(extensions_.begin(), extensions_.end(), extension.get());
+
+  // Remove the extension from our list.
+  extensions_.erase(iter);
 
   NotifyExtensionUnloaded(extension.get(), reason);
 }
 
 void ExtensionService::UnloadAllExtensions() {
   profile_->GetExtensionSpecialStoragePolicy()->
       RevokeRightsForAllExtensions();
 
-  extensions_.Clear();
-  disabled_extensions_.Clear();
-  terminated_extensions_.Clear();
+  extensions_.clear();
+  disabled_extensions_.clear();
+  terminated_extension_ids_.clear();
+  terminated_extensions_.clear();
   extension_runtime_data_.clear();
 
   // TODO(erikkay) should there be a notification for this?  We can't use
   // EXTENSION_UNLOADED since that implies that the extension has been disabled
   // or uninstalled, and UnloadAll is just part of shutdown.
 }
 
 void ExtensionService::ReloadExtensions() {
   UnloadAllExtensions();
   component_loader_->LoadAll();
@@ skipping 63 matching lines @@
   // If the extension was disabled for a reload, then enable it.
   if (disabled_extension_paths_.erase(extension->id()) > 0)
     EnableExtension(extension->id());
 
   // Check if the extension's privileges have changed and disable the
   // extension if necessary.
   InitializePermissions(extension);
 
   bool disabled = extension_prefs_->IsExtensionDisabled(extension->id());
   if (disabled) {
-    disabled_extensions_.Insert(scoped_extension);
-    // TODO(aa): This seems dodgy. AddExtension() could get called with a
-    // disabled extension for other reasons other than that an update was
-    // disabled, e.g. as in ExtensionManagementTest.InstallRequiresConfirm.
+    disabled_extensions_.push_back(scoped_extension);
+    // TODO(aa): This seems dodgy. It seems that AddExtension() could get called
+    // with a disabled extension for other reasons other than that an update was
+    // disabled.
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_EXTENSION_UPDATE_DISABLED,
         content::Source<Profile>(profile_),
         content::Details<const Extension>(extension));
     SyncExtensionChangeIfNeeded(*extension);
     return;
   }
 
-  extensions_.Insert(scoped_extension);
+  extensions_.push_back(scoped_extension);
   SyncExtensionChangeIfNeeded(*extension);
   NotifyExtensionLoaded(extension);
   IdentifyAlertableExtensions();
 }
 
 void ExtensionService::InitializePermissions(const Extension* extension) {
   // If the extension has used the optional permissions API, it will have a
   // custom set of active permissions defined in the extension prefs. Here,
   // we update the extension's active permissions based on the prefs.
   scoped_refptr<ExtensionPermissionSet> active_permissions =
@@ skipping 91 matching lines @@
       RecordPermissionMessagesHistogram(
           extension, "Extensions.Permissions_AutoDisable");
     }
     extension_prefs_->SetExtensionState(extension->id(), Extension::DISABLED);
     extension_prefs_->SetDidExtensionEscalatePermissions(extension, true);
   }
 }
 
 void ExtensionService::UpdateActiveExtensionsInCrashReporter() {
   std::set<std::string> extension_ids;
-  for (ExtensionSet::const_iterator iter = extensions_.begin();
-       iter != extensions_.end(); ++iter) {
-    const Extension* extension = *iter;
-    if (!extension->is_theme() && extension->location() != Extension::COMPONENT)
-      extension_ids.insert(extension->id());
+  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, bool from_webstore, int page_index) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Ensure extension is deleted unless we transfer ownership.
@@ skipping 72 matching lines @@
 
   // Transfer ownership of |extension| to AddExtension.
   AddExtension(scoped_extension);
 }
 
 const Extension* ExtensionService::GetExtensionByIdInternal(
     const std::string& id, bool include_enabled, bool include_disabled,
     bool include_terminated) const {
   std::string lowercase_id = StringToLowerASCII(id);
   if (include_enabled) {
-    const Extension* extension = extensions_.GetByID(lowercase_id);
-    if (extension)
-      return extension;
+    for (ExtensionList::const_iterator iter = extensions_.begin();
+        iter != extensions_.end(); ++iter) {
+      if ((*iter)->id() == lowercase_id)
+        return *iter;
+    }
   }
   if (include_disabled) {
-    const Extension* extension = disabled_extensions_.GetByID(lowercase_id);
-    if (extension)
-      return extension;
+    for (ExtensionList::const_iterator iter = disabled_extensions_.begin();
+        iter != disabled_extensions_.end(); ++iter) {
+      if ((*iter)->id() == lowercase_id)
+        return *iter;
+    }
   }
   if (include_terminated) {
-    const Extension* extension = terminated_extensions_.GetByID(lowercase_id);
-    if (extension)
-      return extension;
+    for (ExtensionList::const_iterator iter = terminated_extensions_.begin();
+        iter != terminated_extensions_.end(); ++iter) {
+      if ((*iter)->id() == lowercase_id)
+        return *iter;
+    }
   }
   return NULL;
 }
 
 void ExtensionService::TrackTerminatedExtension(const Extension* extension) {
-  if (!terminated_extensions_.Contains(extension->id()))
-    terminated_extensions_.Insert(make_scoped_refptr(extension));
+  if (terminated_extension_ids_.insert(extension->id()).second)
+    terminated_extensions_.push_back(make_scoped_refptr(extension));
 
+  // TODO(yoz): Listen to navcontrollers for that extension. Is this a todo?
+
+  // TODO(yoz): make sure this is okay in *ALL* the listeners!
   UnloadExtension(extension->id(), extension_misc::UNLOAD_REASON_TERMINATE);
 }
 
 void ExtensionService::UntrackTerminatedExtension(const std::string& id) {
   std::string lowercase_id = StringToLowerASCII(id);
-  terminated_extensions_.Remove(lowercase_id);
+  if (terminated_extension_ids_.erase(lowercase_id) <= 0)
+    return;
+
+  for (ExtensionList::iterator iter = terminated_extensions_.begin();
+       iter != terminated_extensions_.end(); ++iter) {
+    if ((*iter)->id() == lowercase_id) {
+      terminated_extensions_.erase(iter);
+      return;
+    }
+  }
 }
 
 const Extension* ExtensionService::GetTerminatedExtension(
     const std::string& id) const {
   return GetExtensionByIdInternal(id, false, false, true);
 }
 
 const Extension* ExtensionService::GetInstalledExtension(
     const std::string& id) const {
   return GetExtensionByIdInternal(id, true, true, true);
 }
 
 const Extension* ExtensionService::GetWebStoreApp() {
   return GetExtensionById(extension_misc::kWebStoreAppId, false);
 }
 
 const Extension* ExtensionService::GetExtensionByURL(const GURL& url) {
   return url.scheme() != chrome::kExtensionScheme ? NULL :
       GetExtensionById(url.host(), false);
 }
 
 const Extension* ExtensionService::GetExtensionByWebExtent(const GURL& url) {
-  // TODO(yoz): Should be ExtensionSet::GetByURL.
-  for (ExtensionSet::const_iterator iter = extensions_.begin();
-       iter != extensions_.end(); ++iter) {
-    if ((*iter)->web_extent().MatchesURL(url))
-      return *iter;
+  for (size_t i = 0; i < extensions_.size(); ++i) {
+    if (extensions_[i]->web_extent().MatchesURL(url))
+      return extensions_[i];
   }
   return NULL;
 }
 
 const Extension* ExtensionService::GetDisabledExtensionByWebExtent(
     const GURL& url) {
-  // TODO(yoz): Should be ExtensionSet::GetByURL.
-  for (ExtensionSet::const_iterator iter = disabled_extensions_.begin();
-       iter != disabled_extensions_.end(); ++iter) {
-    if ((*iter)->web_extent().MatchesURL(url))
-      return *iter;
+  for (size_t i = 0; i < disabled_extensions_.size(); ++i) {
+    if (disabled_extensions_[i]->web_extent().MatchesURL(url))
+      return disabled_extensions_[i];
   }
   return NULL;
 }
 
 bool ExtensionService::ExtensionBindingsAllowed(const GURL& url) {
   // Allow bindings for all packaged extensions.
   // Note that GetExtensionByURL may return an Extension for hosted apps
   // (excluding bookmark apps) if the URL came from GetEffectiveURL.
   const Extension* extension = GetExtensionByURL(url);
   if (extension && extension->GetType() != Extension::TYPE_HOSTED_APP)
     return true;
 
   // Allow bindings for all component, hosted apps.
   if (!extension)
     extension = GetExtensionByWebExtent(url);
   return (extension && extension->location() == Extension::COMPONENT);
 }
 
 const Extension* ExtensionService::GetExtensionByOverlappingWebExtent(
     const URLPatternSet& extent) {
-  // TODO(yoz): Should be in ExtensionSet.
-  for (ExtensionSet::const_iterator iter = extensions_.begin();
-       iter != extensions_.end(); ++iter) {
-    if ((*iter)->web_extent().OverlapsWith(extent))
-      return *iter;
+  for (size_t i = 0; i < extensions_.size(); ++i) {
+    if (extensions_[i]->web_extent().OverlapsWith(extent))
+      return extensions_[i];
   }
 
   return NULL;
 }
 
 const SkBitmap& ExtensionService::GetOmniboxIcon(
     const std::string& extension_id) {
   return omnibox_icon_manager_.GetIcon(extension_id);
 }
 
@@ skipping 114 matching lines @@
       ExtensionFunctionDispatcher::GetAllFunctionNames(&function_names);
       process->Send(new ExtensionMsg_SetFunctionNames(function_names));
 
       // Scripting whitelist. This is modified by tests and must be communicated
       // to renderers.
       process->Send(new ExtensionMsg_SetScriptingWhitelist(
           *Extension::GetScriptingWhitelist()));
 
       // Loaded extensions.
       std::vector<ExtensionMsg_Loaded_Params> loaded_extensions;
-      for (ExtensionSet::const_iterator iter = extensions_.begin();
-           iter != extensions_.end(); ++iter) {
-        loaded_extensions.push_back(ExtensionMsg_Loaded_Params(*iter));
+      for (size_t i = 0; i < extensions_.size(); ++i) {
+        loaded_extensions.push_back(
+            ExtensionMsg_Loaded_Params(extensions_[i]));
       }
       process->Send(new ExtensionMsg_Loaded(loaded_extensions));
       break;
     }
     case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED: {
       content::RenderProcessHost* process =
           content::Source<content::RenderProcessHost>(source).ptr();
       Profile* host_profile =
           Profile::FromBrowserContext(process->GetBrowserContext());
       if (!profile_->IsSameProfile(host_profile->GetOriginalProfile()))
@@ skipping 30 matching lines @@
       NOTREACHED() << "Unexpected notification type.";
   }
 }
 
 bool ExtensionService::HasApps() const {
   return !GetAppIds().empty();
 }
 
 ExtensionIdSet ExtensionService::GetAppIds() const {
   ExtensionIdSet result;
-  for (ExtensionSet::const_iterator it = extensions_.begin();
+  for (ExtensionList::const_iterator it = extensions_.begin();
        it != extensions_.end(); ++it) {
     if ((*it)->is_app() && (*it)->location() != Extension::COMPONENT)
       result.insert((*it)->id());
   }
 
   return result;
 }
 
 bool ExtensionService::IsBackgroundPageReady(const Extension* extension) {
   return (extension->background_url().is_empty() ||
@@ skipping 98 matching lines @@
 
 ExtensionService::NaClModuleInfoList::iterator
     ExtensionService::FindNaClModule(const GURL& url) {
   for (NaClModuleInfoList::iterator iter = nacl_module_list_.begin();
        iter != nacl_module_list_.end(); ++iter) {
     if (iter->url == url)
       return iter;
   }
   return nacl_module_list_.end();
 }