Supplement should have a Member to the corresponding Supplementable object

third_party/WebKit/Source/platform/Supplementable.h

 /*
  * Copyright (C) 2012 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 77 matching lines @@
 //
 // Note that reattachThread() does nothing if assertion is not enabled.
 //
 
 template <typename T>
 class Supplementable;
 
 template <typename T>
 class Supplement : public GarbageCollectedMixin {
  public:
+  // TODO(haraken): Remove the default constructor.

[sof, 2017/01/19 07:38:39]

I'd argue that this isn't a natural goal for all supplements -- there are some
implementations where the extension/supplement effectively only wants to be
anonymously hosted somewhere once instantiated.

Which allows them to be a declared supplement of several potential hosts, but
only register with one (e.g., LocalFileSystem, ImageBitmapFactories). Recasting
their implementations to be single-hosted could be done, but the result feels
cumbersome.

(https://codereview.chromium.org/2645613004/ is a trial example how it comes out
for LocalFileSystem.)

+  // All Supplement objects should be instantiated with m_host.
+  Supplement() {}
+  explicit Supplement(T& host) : m_host(&host) {}
+  T* host() const { return m_host; }
+
   static void provideTo(Supplementable<T>& host,
                         const char* key,
                         Supplement<T>* supplement) {
     host.provideSupplement(key, supplement);
   }
 
   static Supplement<T>* from(Supplementable<T>& host, const char* key) {
     return host.requireSupplement(key);
   }
 
   static Supplement<T>* from(Supplementable<T>* host, const char* key) {
     return host ? host->requireSupplement(key) : 0;
   }
 
-  DEFINE_INLINE_VIRTUAL_TRACE() {}
+  DEFINE_INLINE_VIRTUAL_TRACE() { visitor->trace(m_host); }
+
+ private:
+  Member<T> m_host;
 };
 
 // Supplementable<T> inherits from GarbageCollectedMixin virtually
 // to allow ExecutionContext to derive from two GC mixin classes.
 template <typename T>
 class Supplementable : public virtual GarbageCollectedMixin {
   WTF_MAKE_NONCOPYABLE(Supplementable);
 
  public:
   void provideSupplement(const char* key, Supplement<T>* supplement) {
@@ skipping 51 matching lines @@
 };
 
 template <typename T>
 struct ThreadingTrait<Supplementable<T>> {
   static const ThreadAffinity Affinity = ThreadingTrait<T>::Affinity;
 };
 
 }  // namespace blink
 
 #endif  // Supplementable_h