Use a new Supplement constructor for Supplement<Document> (Part 1)

third_party/WebKit/Source/core/xml/DocumentXPathEvaluator.cpp

 /*
  * Copyright (C) 2013 Google, Inc.
  *
  * 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 13 matching lines @@
  */
 
 #include "core/xml/DocumentXPathEvaluator.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/xml/XPathExpression.h"
 #include "core/xml/XPathResult.h"
 
 namespace blink {
 
-DocumentXPathEvaluator::DocumentXPathEvaluator() {}
+DocumentXPathEvaluator::DocumentXPathEvaluator(Document& document)
+    : Supplement<Document>(document) {}
 
-DocumentXPathEvaluator& DocumentXPathEvaluator::from(
-    Supplementable<Document>& document) {
+DocumentXPathEvaluator& DocumentXPathEvaluator::from(Document& document) {
   DocumentXPathEvaluator* cache = static_cast<DocumentXPathEvaluator*>(
       Supplement<Document>::from(document, supplementName()));
   if (!cache) {
-    cache = new DocumentXPathEvaluator;
+    cache = new DocumentXPathEvaluator(document);
     Supplement<Document>::provideTo(document, supplementName(), cache);
   }
   return *cache;
 }
 
 XPathExpression* DocumentXPathEvaluator::createExpression(
-    Supplementable<Document>& document,
+    Document& document,
     const String& expression,
     XPathNSResolver* resolver,
     ExceptionState& exceptionState) {
   DocumentXPathEvaluator& suplement = from(document);
   if (!suplement.m_xpathEvaluator)
     suplement.m_xpathEvaluator = XPathEvaluator::create();
   return suplement.m_xpathEvaluator->createExpression(expression, resolver,
                                                       exceptionState);
 }
 
-XPathNSResolver* DocumentXPathEvaluator::createNSResolver(
-    Supplementable<Document>& document,
-    Node* nodeResolver) {
+XPathNSResolver* DocumentXPathEvaluator::createNSResolver(Document& document,
+                                                          Node* nodeResolver) {
   DocumentXPathEvaluator& suplement = from(document);
   if (!suplement.m_xpathEvaluator)
     suplement.m_xpathEvaluator = XPathEvaluator::create();
   return suplement.m_xpathEvaluator->createNSResolver(nodeResolver);
 }
 
-XPathResult* DocumentXPathEvaluator::evaluate(
-    Supplementable<Document>& document,
-    const String& expression,
-    Node* contextNode,
-    XPathNSResolver* resolver,
-    unsigned short type,
-    const ScriptValue&,
-    ExceptionState& exceptionState) {
+XPathResult* DocumentXPathEvaluator::evaluate(Document& document,
+                                              const String& expression,
+                                              Node* contextNode,
+                                              XPathNSResolver* resolver,
+                                              unsigned short type,
+                                              const ScriptValue&,
+                                              ExceptionState& exceptionState) {
   DocumentXPathEvaluator& suplement = from(document);
   if (!suplement.m_xpathEvaluator)
     suplement.m_xpathEvaluator = XPathEvaluator::create();
   return suplement.m_xpathEvaluator->evaluate(
       expression, contextNode, resolver, type, ScriptValue(), exceptionState);
 }
 
 DEFINE_TRACE(DocumentXPathEvaluator) {
   visitor->trace(m_xpathEvaluator);
   Supplement<Document>::trace(visitor);
 }
 
 }  // namespace blink