Remove PageVisibilityObserver contextDestroyed() notifications.

third_party/WebKit/Source/platform/LifecycleNotifier.h

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  * Copyright (C) 2013 Google Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 24 matching lines @@
 
 template <typename T, typename Observer>
 class LifecycleNotifier : public virtual GarbageCollectedMixin {
  public:
   virtual ~LifecycleNotifier();
 
   void addObserver(Observer*);
   void removeObserver(Observer*);
 
   // notifyContextDestroyed() should be explicitly dispatched from an
-  // observed context to notify observers that contextDestroyed().
+  // observed context to detach its observers, and if the observer kind
+  // requires it, notify each observer by invoking contextDestroyed().
   //
-  // When contextDestroyed() is called, the observer's lifecycleContext()
-  // is still valid and safe to use during the notification.
+  // When contextDestroyed() is called, it is supplied the context as
+  // an argument, but the observer's lifecycleContext() is still valid
+  // and safe to use while handling the notification.
   virtual void notifyContextDestroyed();
 
   DEFINE_INLINE_VIRTUAL_TRACE() { visitor->trace(m_observers); }
 
   bool isIteratingOverObservers() const {
     return m_iterationState != NotIterating;
   }
 
  protected:
   LifecycleNotifier() : m_iterationState(NotIterating) {}
@@ skipping 16 matching lines @@
   ObserverSet m_observers;
 };
 
 template <typename T, typename Observer>
 inline LifecycleNotifier<T, Observer>::~LifecycleNotifier() {
   // FIXME: Enable the following ASSERT. Also see a FIXME in
   // Document::detachLayoutTree().
   // ASSERT(!m_observers.size());
 }
 
+// Determine if |contextDestroyed(Observer*) is a public method on
+// class type |Observer|, or any of the class types it derives from.
+template <typename Observer, typename T>
+class HasContextDestroyed {
+  using YesType = char;
+  using NoType = int;
+
+  template <typename V>
+  static YesType checkHasContextDestroyedMethod(
+      V* observer,
+      T* context = nullptr,
+      typename std::enable_if<
+          std::is_same<decltype(observer->contextDestroyed(context)),
+                       void>::value>::type* g = nullptr);
+  template <typename V>
+  static NoType checkHasContextDestroyedMethod(...);
+
+ public:
+  static_assert(sizeof(Observer), "Observer's class declaration not in scope");
+  static const bool value =
+      sizeof(YesType) ==
+      sizeof(checkHasContextDestroyedMethod<Observer>(nullptr));
+};
+
+// If |Observer::contextDestroyed()| is present, invoke it.
+template <typename Observer,
+          typename T,
+          bool = HasContextDestroyed<Observer, T>::value>
+class NotifyContextDestroyed {
+  STATIC_ONLY(NotifyContextDestroyed);
+
+ public:
+  static void call(Observer* observer, T* context) {
+    observer->contextDestroyed(context);
+  }
+};
+
+template <typename Observer, typename T>
+class NotifyContextDestroyed<Observer, T, false> {
+  STATIC_ONLY(NotifyContextDestroyed);
+
+ public:
+  static void call(Observer*, T*) {}
+};
+
 template <typename T, typename Observer>
 inline void LifecycleNotifier<T, Observer>::notifyContextDestroyed() {
   // Observer unregistration is allowed, but effectively a no-op.
   AutoReset<IterationState> scope(&m_iterationState, AllowingRemoval);
   ObserverSet observers;
   m_observers.swap(observers);
   for (Observer* observer : observers) {
     DCHECK(observer->lifecycleContext() == context());
-    observer->contextDestroyed(context());
+    NotifyContextDestroyed<Observer, T>::call(observer, context());
     observer->clearContext();
   }
 }
 
 template <typename T, typename Observer>
 inline void LifecycleNotifier<T, Observer>::addObserver(Observer* observer) {
   RELEASE_ASSERT(m_iterationState & AllowingAddition);
   m_observers.add(observer);
 }
 
 template <typename T, typename Observer>
 inline void LifecycleNotifier<T, Observer>::removeObserver(Observer* observer) {
   // If immediate removal isn't currently allowed,
   // |observer| is recorded for pending removal.
   if (m_iterationState & AllowPendingRemoval) {
     m_observers.add(observer);
     return;
   }
   RELEASE_ASSERT(m_iterationState & AllowingRemoval);
   m_observers.remove(observer);
 }
 
 }  // namespace blink
 
 #endif  // LifecycleNotifier_h