Annotate ScriptWrappable-embedding singletons.

third_party/WebKit/Source/wtf/StdLibExtras.h

 /*
  * Copyright (C) 2008 Apple 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
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WTF_StdLibExtras_h
 #define WTF_StdLibExtras_h
 
+#include <cstddef>
 #include "base/numerics/safe_conversions.h"
+#include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
 #include "wtf/CPU.h"
 #include "wtf/LeakAnnotations.h"
 #include "wtf/TypeTraits.h"
-#include <cstddef>
 
 #if DCHECK_IS_ON()
 #include "wtf/Noncopyable.h"
 #include "wtf/Threading.h"
 
 class WTF_EXPORT StaticLocalVerifier {
   WTF_MAKE_NONCOPYABLE(StaticLocalVerifier);
 
  public:
   StaticLocalVerifier()
@@ skipping 60 matching lines @@
 // wrapped up by an off-heap Persistent<T> reference to the object, keeping
 // it alive across GCs.
 //
 // To cooperate with leak detection(LSan) for Blink garbage collected objects,
 // the objects owned by persistent local statics will in some cases have to be
 // finalized prior to leak checking. This only applies to static references to
 // Blink heap objects and what they transitively hold on to. Hence the
 // LEAK_SANITIZER_REGISTER_STATIC_LOCAL() use, it taking care of the grungy
 // details.
 //
-#define DEFINE_STATIC_LOCAL(Type, Name, Arguments)                   \
-  DEFINE_STATIC_LOCAL_CHECK_THREADSAFE_ACCESS(Name);                 \
-  using WrappedTypeFor##Name = StaticLocalWrapper<Type>::WrapType;   \
-  static WrappedTypeFor##Name* WrappedInstanceFor##Name =            \
-      LEAK_SANITIZER_REGISTER_STATIC_LOCAL(                          \
-          WrappedTypeFor##Name, new WrappedTypeFor##Name Arguments); \
-  Type& Name = StaticLocalWrapper<Type>::unwrap(WrappedInstanceFor##Name);
+
+#define DEFINE_STATIC_LOCAL(Type, Name, Arguments)                      \
+  STATIC_ALLOCATED_SINGLETON()                                          \
+  static StaticLocalWrapper<Type>::WrapType* WrappedInstanceFor##Name = \
+      LEAK_SANITIZER_REGISTER_STATIC_LOCAL(                             \
+          StaticLocalWrapper<Type>::WrapType,                           \
+          new StaticLocalWrapper<Type>::WrapType Arguments);            \
+  DEFINE_STATIC_LOCAL_CHECK_THREADSAFE_ACCESS(Name);                    \
+  Type& Name = StaticLocalWrapper<Type>::unwrap(WrappedInstanceFor##Name)
+
+// Static local singletons that embed ScriptWrappable-derived objects are
+// problematic (see issue 688569). The clang GC plugin issues warnings
+// when encountering such singletons. If you cannot avoid introducing
+// the static local and can prove that the ScriptWrappable reference is
+// safe, you may use ALLOW_UNSAFE_SINGLETON() to disable the clang GC
+// plugin check. See issue 688569 for more details.
+//
+#define ALLOW_UNSAFE_SINGLETON() GC_PLUGIN_IGNORE("crbug.com/688569")
 
 // Use this to declare and define a static local pointer to a ref-counted object
 // so that it is leaked so that the object's destructors are not called at
 // exit.  This macro should be used with ref-counted objects rather than
 // DEFINE_STATIC_LOCAL macro, as this macro does not lead to an extra memory
 // allocation.
 #define DEFINE_STATIC_REF(type, name, arguments) \
   static type* name = PassRefPtr<type>(arguments).leakRef();
 
 /*
@@ skipping 107 matching lines @@
 enum NotNullTag { NotNull };
 inline void* operator new(size_t, NotNullTag, void* location) {
   DCHECK(location);
   return location;
 }
 
 using WTF::bitwiseCast;
 using WTF::safeCast;
 
 #endif  // WTF_StdLibExtras_h