Pass implementation object to supplemental classes by reference

Source/web/ContextFeaturesClientImpl.cpp

 /*
  * 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 61 matching lines @@
         {
             return m_value == NeedsRefresh || m_defaultValue != defaultValue;
         }
 
     private:
         Value m_value;
         bool m_defaultValue; // Needs to be traked as a part of the signature since it can be changed dynamically.
     };
 
     static const char* supplementName();
-    static ContextFeaturesCache* from(Document*);
+    static ContextFeaturesCache& from(Document&);
 
     Entry& entryFor(ContextFeatures::FeatureType type)
     {
         size_t index = static_cast<size_t>(type);
         ASSERT_WITH_SECURITY_IMPLICATION(index < ContextFeatures::FeatureTypeSize);
         return m_entries[index];
     }
 
     void validateAgainst(Document*);
 
 private:
     String m_domain;
     Entry m_entries[ContextFeatures::FeatureTypeSize];
 };
 
 const char* ContextFeaturesCache::supplementName()
 {
     return "ContextFeaturesCache";
 }
 
-ContextFeaturesCache* ContextFeaturesCache::from(Document* document)
+ContextFeaturesCache& ContextFeaturesCache::from(Document& document)
 {
     ContextFeaturesCache* cache = static_cast<ContextFeaturesCache*>(DocumentSupplement::from(document, supplementName()));
     if (!cache) {
         cache = new ContextFeaturesCache();
         DocumentSupplement::provideTo(document, supplementName(), adoptPtr(cache));
     }
 
-    return cache;
+    return *cache;
 }
 
 void ContextFeaturesCache::validateAgainst(Document* document)
 {
     String currentDomain = document->securityOrigin()->domain();
     if (currentDomain == m_domain)
         return;
     m_domain = currentDomain;
     for (size_t i = 0; i < ContextFeatures::FeatureTypeSize; ++i)
         m_entries[i] = Entry();
 }
 
 bool ContextFeaturesClientImpl::isEnabled(Document* document, ContextFeatures::FeatureType type, bool defaultValue)
 {
-    ContextFeaturesCache::Entry& cache = ContextFeaturesCache::from(document)->entryFor(type);
+    ASSERT(document);
+    ContextFeaturesCache::Entry& cache = ContextFeaturesCache::from(*document).entryFor(type);
     if (cache.needsRefresh(defaultValue))
         cache.set(askIfIsEnabled(document, type, defaultValue), defaultValue);
     return cache.isEnabled();
 }
 
 void ContextFeaturesClientImpl::urlDidChange(Document* document)
 {
-    ContextFeaturesCache::from(document)->validateAgainst(document);
+    ASSERT(document);
+    ContextFeaturesCache::from(*document).validateAgainst(document);
 }
 
 bool ContextFeaturesClientImpl::askIfIsEnabled(Document* document, ContextFeatures::FeatureType type, bool defaultValue)
 {
     WebFrameImpl* frame = WebFrameImpl::fromFrame(document->frame());
     if (!frame || !frame->permissionClient())
         return defaultValue;
 
     switch (type) {
     case ContextFeatures::StyleScoped:
         return frame->permissionClient()->allowWebComponents(frame, defaultValue);
     case ContextFeatures::MutationEvents:
         return frame->permissionClient()->allowMutationEvents(frame, defaultValue);
     case ContextFeatures::PushState:
         return frame->permissionClient()->allowPushState(frame);
     default:
         return defaultValue;
     }
 }
 
 } // namespace blink