Rename Supplement::host() to Supplement::supplementable()

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 81 matching lines @@
 template <typename T>
 class Supplementable;
 
 template <typename T>
 class Supplement : public GarbageCollectedMixin {
  public:
   // TODO(haraken): Remove the default constructor.
   // All Supplement objects should be instantiated with m_host.
   Supplement() {}
 
-  explicit Supplement(T& host) : m_host(&host) {}
+  explicit Supplement(T& supplementable) : m_supplementable(&supplementable) {}
 
   // Supplementable and its supplements live and die together.
-  // Thus host() should never return null (if the default constructor
+  // Thus supplementable() should never return null (if the default constructor
   // is completely removed).
-  T* host() const { return m_host; }
+  T* supplementable() const { return m_supplementable; }
 
-  static void provideTo(Supplementable<T>& host,
+  static void provideTo(Supplementable<T>& supplementable,
                         const char* key,
                         Supplement<T>* supplement) {
-    host.provideSupplement(key, supplement);
+    supplementable.provideSupplement(key, supplement);
   }
 
-  static Supplement<T>* from(Supplementable<T>& host, const char* key) {
-    return host.requireSupplement(key);
+  static Supplement<T>* from(Supplementable<T>& supplementable,
+                             const char* key) {
+    return supplementable.requireSupplement(key);
   }
 
-  static Supplement<T>* from(Supplementable<T>* host, const char* key) {
-    return host ? host->requireSupplement(key) : 0;
+  static Supplement<T>* from(Supplementable<T>* supplementable,
+                             const char* key) {
+    return supplementable ? supplementable->requireSupplement(key) : 0;
   }
 
-  DEFINE_INLINE_VIRTUAL_TRACE() { visitor->trace(m_host); }
+  DEFINE_INLINE_VIRTUAL_TRACE() { visitor->trace(m_supplementable); }
 
  private:
-  Member<T> m_host;
+  Member<T> m_supplementable;
 };
 
 // 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