Remove use of linked_ptr from ExtensionWarningSet

chrome/browser/extensions/extension_warning_set.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_warning_set.h"
 
+#include "base/stl_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_global_error_badge.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/global_error/global_error_service.h"
 #include "chrome/browser/ui/global_error/global_error_service_factory.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 177 matching lines @@
           final_parameters[1], final_parameters[2]);
     case 4:
       return l10n_util::GetStringFUTF8(message_id_, final_parameters[0],
           final_parameters[1], final_parameters[2], final_parameters[3]);
     default:
       NOTREACHED();
       return std::string();
   }
 }
 
-bool operator<(const linked_ptr<ExtensionWarning>& a,
-               const linked_ptr<ExtensionWarning>& b) {
+bool ExtensionWarningComparator::operator()(ExtensionWarning* a,
+                                            ExtensionWarning* b) const {
   if (a->extension_id() != b->extension_id())
     return a->extension_id() < b->extension_id();
   return a->warning_type() < b->warning_type();
 }
 
 //
 // ExtensionWarningSet
 //
 
 ExtensionWarningSet::ExtensionWarningSet() {}
 
-ExtensionWarningSet::~ExtensionWarningSet() {}
+ExtensionWarningSet::~ExtensionWarningSet() {
+  // We cannot delete elements that are still in the set because operator<
+  // cannot be executed on freed pointers that are still in the set.
+  std::vector<ExtensionWarning*> tmp(warnings_.begin(), warnings_.end());
+  STLDeleteContainerPointers(tmp.begin(), tmp.end());
+}
 
 void ExtensionWarningSet::Insert(scoped_ptr<ExtensionWarning> warning) {
-  warnings_.insert(make_linked_ptr(warning.release()));
+  warnings_.insert(warning.release());
 }
 
-std::set<linked_ptr<ExtensionWarning> > ExtensionWarningSet::Release() {
-  std::set<linked_ptr<ExtensionWarning> > other;
+ExtensionWarningSet::Set ExtensionWarningSet::Release() {
+  ExtensionWarningSet::Set other;
   warnings_.swap(other);
   return other;
 }
 
 bool ExtensionWarningSet::IsEmpty() const {
   return warnings_.empty();
 }
 
 ExtensionWarningService::ExtensionWarningService(Profile* profile)
     : profile_(profile) {
   DCHECK(CalledOnValidThread());
 }
 
 //
 // ExtensionWarningService
 //
 
-ExtensionWarningService::~ExtensionWarningService() {}
+ExtensionWarningService::~ExtensionWarningService() {
+  // We cannot delete elements that are still in the set because operator<
+  // cannot be executed on freed pointers that are still in the set.
+  std::vector<ExtensionWarning*> tmp(warnings_.begin(), warnings_.end());
+  STLDeleteContainerPointers(tmp.begin(), tmp.end());
+}
 
 void ExtensionWarningService::ClearWarnings(
     const std::set<ExtensionWarning::WarningType>& types) {
   DCHECK(CalledOnValidThread());
   bool deleted_anything = false;
   for (iterator i = warnings_.begin(); i != warnings_.end();) {
     if (types.find((*i)->warning_type()) != types.end()) {
       deleted_anything = true;
+      ExtensionWarning* warning = *i;
       warnings_.erase(i++);
+      delete warning;
     } else {
       ++i;
     }
   }
 
   if (deleted_anything) {
     NotifyWarningsChanged();
     UpdateWarningBadge();
   }
 }
@@ skipping 22 matching lines @@
     if ((*i)->extension_id() == extension_id)
       result->push_back((*i)->GetMessage(extension_service));
   }
 }
 
 void ExtensionWarningService::AddWarnings(
     scoped_ptr<ExtensionWarningSet> warnings) {
   DCHECK(CalledOnValidThread());
   size_t old_size = warnings_.size();
 
-  std::set<linked_ptr<ExtensionWarning> > warning_set = warnings->Release();
+  ExtensionWarningSet::Set warning_set = warnings->Release();
   warnings_.insert(warning_set.begin(), warning_set.end());
 
   if (old_size != warnings_.size()) {
     NotifyWarningsChanged();
     UpdateWarningBadge();
   }
 }
 
 // static
 void ExtensionWarningService::NotifyWarningsOnUI(
@@ skipping 46 matching lines @@
   // Activate or hide the warning badge in case the current state is incorrect.
   if (error && !need_warning_badge) {
     service->RemoveGlobalError(error);
     delete error;
   } else if (!error && need_warning_badge) {
     service->AddGlobalError(new ExtensionGlobalErrorBadge);
   }
 }
 
 }  // namespace extensions