Remove some uses of stl_util's STLDeleteContainerPointers.

ui/message_center/notification_list.h

 // 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.
 
 #ifndef UI_MESSAGE_CENTER_NOTIFICATION_LIST_H_
 #define UI_MESSAGE_CENTER_NOTIFICATION_LIST_H_
 
 #include <stddef.h>
 
 #include <list>
@@ skipping 19 matching lines @@
 
 namespace test {
 class NotificationListTest;
 }
 
 class Notification;
 class NotificationDelegate;
 struct NotifierId;
 
 // Comparers used to auto-sort the lists of Notifications.
-struct MESSAGE_CENTER_EXPORT ComparePriorityTimestampSerial {
-  bool operator()(Notification* n1, Notification* n2);
+template <typename T>
+struct CompareTimestampSerial {
+  bool operator()(const T& n1, const T& n2) {
+    if (n1->timestamp() > n2->timestamp())  // Newer come first.

[Nico, 2016/09/15 16:07:16]

I think making this a full template is confusing, since n1 is either a
Notification* or a unique_ptr<Notification>. I think this might be a better
approach:

template <typename T, bool PlainCompare(T*, T*)>
struct UniquePtrCompare {
  bool operator(const std::unique_ptr<T>& n1, const std::unique_ptr<T>& n2) {
    return PlainCompare(n1.get, n2.get());
  }
};

That will work for any situation where you have a comparator for the plain type
and want to compare unique_ptrs – and it'll also allow you to keep the
definition of ComparePriorityTimestampSerial and CompareTimestampSerial out of
line.

[Avi (use Gerrit), 2016/09/15 19:53:45]

That doesn't actually work.

error: template argument for non-type template parameter must be an expression
               UniquePtrCompare<Notification, ComparePriorityTimestampSerial>>;
                                              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
note: template parameter is declared here
template <typename T, bool PlainCompare(T*, T*)>
                           ^

I switched to using a type parameter.

+      return true;
+    if (n1->timestamp() < n2->timestamp())
+      return false;
+    if (n1->serial_number() > n2->serial_number())  // Newer come first.
+      return true;
+    if (n1->serial_number() < n2->serial_number())
+      return false;
+    return false;
+  }
 };
 
-struct MESSAGE_CENTER_EXPORT CompareTimestampSerial {
-  bool operator()(Notification* n1, Notification* n2);
+template <typename T>
+struct ComparePriorityTimestampSerial {
+  bool operator()(const T& n1, const T& n2) {
+    if (n1->priority() > n2->priority())  // Higher pri go first.
+      return true;
+    if (n1->priority() < n2->priority())
+      return false;
+    return CompareTimestampSerial<T>()(n1, n2);
+  }
 };
 
 // A helper class to manage the list of notifications.
 class MESSAGE_CENTER_EXPORT NotificationList {
  public:
   // Auto-sorted set. Matches the order in which Notifications are shown in
   // Notification Center.
-  typedef std::set<Notification*, ComparePriorityTimestampSerial> Notifications;
+  using Notifications =
+      std::set<Notification*, ComparePriorityTimestampSerial<Notification*>>;
+  using OwnedNotifications =
+      std::set<std::unique_ptr<Notification>,
+               ComparePriorityTimestampSerial<std::unique_ptr<Notification>>>;
 
   // Auto-sorted set used to return the Notifications to be shown as popup
   // toasts.
-  typedef std::set<Notification*, CompareTimestampSerial> PopupNotifications;
+  using PopupNotifications =
+      std::set<Notification*, CompareTimestampSerial<Notification*>>;
 
   explicit NotificationList(MessageCenter* message_center);
   virtual ~NotificationList();
 
   // Makes a message "read". Collects the set of ids whose state have changed
   // and set to |udpated_ids|. NULL if updated ids don't matter.
   void SetNotificationsShown(const NotificationBlockers& blockers,
                              std::set<std::string>* updated_ids);
 
   void AddNotification(std::unique_ptr<Notification> notification);
@@ skipping 67 matching lines @@
       const NotificationBlockers& blockers) const;
   size_t NotificationCount(const NotificationBlockers& blockers) const;
   size_t UnreadCount(const NotificationBlockers& blockers) const;
 
  private:
   friend class NotificationListTest;
   FRIEND_TEST_ALL_PREFIXES(NotificationListTest,
                            TestPushingShownNotification);
 
   // Iterates through the list and returns the first notification matching |id|.
-  Notifications::iterator GetNotification(const std::string& id);
+  OwnedNotifications::iterator GetNotification(const std::string& id);
 
-  void EraseNotification(Notifications::iterator iter);
+  void EraseNotification(OwnedNotifications::iterator iter);
 
   void PushNotification(std::unique_ptr<Notification> notification);
 
   MessageCenter* message_center_;  // owner
-  Notifications notifications_;
+  OwnedNotifications notifications_;
   bool quiet_mode_;
 
   DISALLOW_COPY_AND_ASSIGN(NotificationList);
 };
 
 }  // namespace message_center
 
 #endif // UI_MESSAGE_CENTER_NOTIFICATION_LIST_H_