content/browser/notification_service_impl.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/notification_service_impl.h"
   6
   7 #include "base/lazy_instance.h"
   8 #include "base/threading/thread_local.h"
   9 #include "content/public/browser/notification_observer.h"
  10 #include "content/public/browser/notification_types.h"
  11
  12 namespace  content {
  13
  14 namespace {
  15
  16 base::LazyInstance<base::ThreadLocalPointer<NotificationServiceImpl> >
  17     lazy_tls_ptr = LAZY_INSTANCE_INITIALIZER;
  18
  19 }  // namespace
  20
  21 // static
  22 NotificationServiceImpl* NotificationServiceImpl::current() {
  23   return lazy_tls_ptr.Pointer()->Get();
  24 }
  25
  26 // static
  27 NotificationService* NotificationService::current() {
  28   return NotificationServiceImpl::current();
  29 }
  30
  31 // static
  32 NotificationService* NotificationService::Create() {
  33   return new NotificationServiceImpl;
  34 }
  35
  36 // static
  37 bool NotificationServiceImpl::HasKey(const NotificationSourceMap& map,
  38                                      const NotificationSource& source) {
  39   return map.find(source.map_key()) != map.end();
  40 }
  41
  42 NotificationServiceImpl::NotificationServiceImpl() {
  43   DCHECK(current() == NULL);
  44   lazy_tls_ptr.Pointer()->Set(this);
  45 }
  46
  47 void NotificationServiceImpl::AddObserver(NotificationObserver* observer,
  48                                           int type,
  49                                           const NotificationSource& source) {
  50   // We have gotten some crashes where the observer pointer is NULL. The problem
  51   // is that this happens when we actually execute a notification, so have no
  52   // way of knowing who the bad observer was. We want to know when this happens
  53   // in release mode so we know what code to blame the crash on (since this is
  54   // guaranteed to crash later).
  55   CHECK(observer);
  56
  57   NotificationObserverList* observer_list;
  58   if (HasKey(observers_[type], source)) {
  59     observer_list = observers_[type][source.map_key()];
  60   } else {
  61     observer_list = new NotificationObserverList;
  62     observers_[type][source.map_key()] = observer_list;
  63   }
  64
  65   observer_list->AddObserver(observer);
  66 #ifndef NDEBUG
  67   ++observer_counts_[type];
  68 #endif
  69 }
  70
  71 void NotificationServiceImpl::RemoveObserver(NotificationObserver* observer,
  72                                              int type,
  73                                              const NotificationSource& source) {
  74   // This is a very serious bug.  An object is most likely being deleted on
  75   // the wrong thread, and as a result another thread's NotificationServiceImpl
  76   // has its deleted pointer in its map.  A garbge object will be called in the
  77   // future.
  78   // NOTE: when this check shows crashes, use BrowserThread::DeleteOnIOThread or
  79   // other variants as the trait on the object.
  80   CHECK(HasKey(observers_[type], source));
  81
  82   NotificationObserverList* observer_list =
  83       observers_[type][source.map_key()];
  84   if (observer_list) {
  85     observer_list->RemoveObserver(observer);
  86     if (!observer_list->might_have_observers()) {
  87       observers_[type].erase(source.map_key());
  88       delete observer_list;
  89     }
  90 #ifndef NDEBUG
  91     --observer_counts_[type];
  92 #endif
  93   }
  94 }
  95
  96 void NotificationServiceImpl::Notify(int type,
  97                                      const NotificationSource& source,
  98                                      const NotificationDetails& details) {
  99   DCHECK_GT(type, NOTIFICATION_ALL) <<
 100       "Allowed for observing, but not posting.";
 101
 102   // There's no particular reason for the order in which the different
 103   // classes of observers get notified here.
 104
 105   // Notify observers of all types and all sources
 106   if (HasKey(observers_[NOTIFICATION_ALL], AllSources()) &&
 107       source != AllSources()) {
 108     FOR_EACH_OBSERVER(NotificationObserver,
 109                       *observers_[NOTIFICATION_ALL][AllSources().map_key()],
 110                       Observe(type, source, details));
 111   }
 112
 113   // Notify observers of all types and the given source
 114   if (HasKey(observers_[NOTIFICATION_ALL], source)) {
 115     FOR_EACH_OBSERVER(NotificationObserver,
 116                       *observers_[NOTIFICATION_ALL][source.map_key()],
 117                       Observe(type, source, details));
 118   }
 119
 120   // Notify observers of the given type and all sources
 121   if (HasKey(observers_[type], AllSources()) &&
 122       source != AllSources()) {
 123     FOR_EACH_OBSERVER(NotificationObserver,
 124                       *observers_[type][AllSources().map_key()],
 125                       Observe(type, source, details));
 126   }
 127
 128   // Notify observers of the given type and the given source
 129   if (HasKey(observers_[type], source)) {
 130     FOR_EACH_OBSERVER(NotificationObserver,
 131                       *observers_[type][source.map_key()],
 132                       Observe(type, source, details));
 133   }
 134 }
 135
 136
 137 NotificationServiceImpl::~NotificationServiceImpl() {
 138   lazy_tls_ptr.Pointer()->Set(NULL);
 139
 140 #ifndef NDEBUG
 141   for (int i = 0; i < static_cast<int>(observer_counts_.size()); i++) {
 142     if (observer_counts_[i] > 0) {
 143       // This may not be completely fixable -- see
 144       // http://code.google.com/p/chromium/issues/detail?id=11010 .
 145       VLOG(1) << observer_counts_[i] << " notification observer(s) leaked "
 146                  "of notification type " << i;
 147     }
 148   }
 149 #endif
 150
 151   for (int i = 0; i < static_cast<int>(observers_.size()); i++) {
 152     NotificationSourceMap omap = observers_[i];
 153     for (NotificationSourceMap::iterator it = omap.begin();
 154          it != omap.end(); ++it)
 155       delete it->second;
 156   }
 157 }
 158
 159 }  // namespace content