Clean up ObserverList Pointers to use nullptr instad of NULL or 0

base/observer_list.h

 // 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.
 
 #ifndef BASE_OBSERVER_LIST_H__
 #define BASE_OBSERVER_LIST_H__
 
 #include <algorithm>
 #include <limits>
 #include <vector>
@@ skipping 125 matching lines @@
 
 template <class ObserverType>
 ObserverListBase<ObserverType>::Iterator::~Iterator() {
   if (list_.get() && --list_->notify_depth_ == 0)
     list_->Compact();
 }
 
 template <class ObserverType>
 ObserverType* ObserverListBase<ObserverType>::Iterator::GetNext() {
   if (!list_.get())
-    return NULL;
+    return nullptr;
   ListType& observers = list_->observers_;
   // Advance if the current element is null
   size_t max_index = std::min(max_index_, observers.size());
   while (index_ < max_index && !observers[index_])
     ++index_;
-  return index_ < max_index ? observers[index_++] : NULL;
+  return index_ < max_index ? observers[index_++] : nullptr;
 }
 
 template <class ObserverType>
 void ObserverListBase<ObserverType>::AddObserver(ObserverType* obs) {
   DCHECK(obs);
   if (std::find(observers_.begin(), observers_.end(), obs)
       != observers_.end()) {
     NOTREACHED() << "Observers can only be added once!";
     return;
   }
   observers_.push_back(obs);
 }
 
 template <class ObserverType>
 void ObserverListBase<ObserverType>::RemoveObserver(ObserverType* obs) {
   DCHECK(obs);
   typename ListType::iterator it =
     std::find(observers_.begin(), observers_.end(), obs);
   if (it != observers_.end()) {
     if (notify_depth_) {
-      *it = 0;
+      *it = nullptr;
     } else {
       observers_.erase(it);
     }
   }
 }
 
 template <class ObserverType>
 bool ObserverListBase<ObserverType>::HasObserver(
     const ObserverType* observer) const {
   for (size_t i = 0; i < observers_.size(); ++i) {
     if (observers_[i] == observer)
       return true;
   }
   return false;
 }
 
 template <class ObserverType>
 void ObserverListBase<ObserverType>::Clear() {
   if (notify_depth_) {
     for (typename ListType::iterator it = observers_.begin();
       it != observers_.end(); ++it) {
-      *it = 0;
+      *it = nullptr;
     }
   } else {
     observers_.clear();
   }
 }
 
 template <class ObserverType>
 void ObserverListBase<ObserverType>::Compact() {
   observers_.erase(
       std::remove(observers_.begin(), observers_.end(),
-                  static_cast<ObserverType*>(NULL)), observers_.end());
+                  static_cast<ObserverType*>(nullptr)), observers_.end());

[Lei Zhang, 2015/04/23 21:07:33]

Can you check to see if you can get rid of the static_cast?

[robliao, 2015/04/23 21:27:28]

MSVC was cool with it, but MSVC tends to be more forgiving. I'll let the CQ find
out about the other compilers.

 }
 
 template <class ObserverType, bool check_empty = false>
 class ObserverList : public ObserverListBase<ObserverType> {
  public:
   typedef typename ObserverListBase<ObserverType>::NotificationType
       NotificationType;
 
   ObserverList() {}
   explicit ObserverList(NotificationType type)
@@ skipping 11 matching lines @@
     return ObserverListBase<ObserverType>::size() != 0;
   }
 };
 
 #define FOR_EACH_OBSERVER(ObserverType, observer_list, func)             \
   do {                                                                   \
     if ((observer_list).might_have_observers()) {                        \
       ObserverListBase<ObserverType>::Iterator it_inside_observer_macro( \
           &observer_list);                                               \
       ObserverType* obs;                                                 \
-      while ((obs = it_inside_observer_macro.GetNext()) != NULL)         \
+      while ((obs = it_inside_observer_macro.GetNext()) != nullptr)         \
         obs->func;                                                       \
     }                                                                    \
   } while (0)
 
 #endif  // BASE_OBSERVER_LIST_H__