Make DocumentOrderedMap take a const reference for scope

third_party/WebKit/Source/core/dom/DocumentOrderedMap.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 100 matching lines @@
       entry->element =
           entry->ordered_list.size() > 1 ? entry->ordered_list[1] : nullptr;
     }
     entry->count--;
     entry->ordered_list.clear();
   }
 }
 
 template <bool keyMatches(const AtomicString&, const Element&)>
 inline Element* DocumentOrderedMap::Get(const AtomicString& key,
-                                        const TreeScope* scope) const {
+                                        const TreeScope& scope) const {
   DCHECK(key);
-  DCHECK(scope);
 
   MapEntry* entry = map_.at(key);
   if (!entry)
     return 0;
 
   DCHECK(entry->count);
   if (entry->element)
     return entry->element;
 
   // Iterate to find the node that matches. Nothing will match iff an element
   // with children having duplicate IDs is being removed -- the tree traversal
   // will be over an updated tree not having that subtree. In all other cases,
   // a match is expected.
-  for (Element& element : ElementTraversal::StartsAfter(scope->RootNode())) {
+  for (Element& element : ElementTraversal::StartsAfter(scope.RootNode())) {
     if (!keyMatches(key, element))
       continue;
     entry->element = &element;
     return &element;
   }
 // As get()/getElementById() can legitimately be called while handling element
 // removals, allow failure iff we're in the scope of node removals.
 #if DCHECK_IS_ON()
   DCHECK(g_remove_scope_level);
 #endif
   return 0;
 }
 
 Element* DocumentOrderedMap::GetElementById(const AtomicString& key,
-                                            const TreeScope* scope) const {
+                                            const TreeScope& scope) const {
   return Get<KeyMatchesId>(key, scope);
 }
 
 const HeapVector<Member<Element>>& DocumentOrderedMap::GetAllElementsById(
     const AtomicString& key,
-    const TreeScope* scope) const {
+    const TreeScope& scope) const {
   DCHECK(key);
-  DCHECK(scope);
   DEFINE_STATIC_LOCAL(HeapVector<Member<Element>>, empty_vector,
                       (new HeapVector<Member<Element>>));
 
   Map::iterator it = map_.find(key);
   if (it == map_.end())
     return empty_vector;
 
   Member<MapEntry>& entry = it->value;
   DCHECK(entry->count);
 
   if (entry->ordered_list.IsEmpty()) {
     entry->ordered_list.ReserveCapacity(entry->count);
     for (Element* element =
              entry->element ? entry->element.Get()
-                            : ElementTraversal::FirstWithin(scope->RootNode());
+                            : ElementTraversal::FirstWithin(scope.RootNode());
          entry->ordered_list.size() < entry->count;
          element = ElementTraversal::Next(*element)) {
       DCHECK(element);
       if (!KeyMatchesId(key, *element))
         continue;
       entry->ordered_list.UncheckedAppend(element);
     }
     if (!entry->element)
       entry->element = entry->ordered_list.front();
   }
 
   return entry->ordered_list;
 }
 
 Element* DocumentOrderedMap::GetElementByMapName(const AtomicString& key,
-                                                 const TreeScope* scope) const {
+                                                 const TreeScope& scope) const {
   return Get<KeyMatchesMapName>(key, scope);
 }
 
 // TODO(hayato): Template get<> by return type.
 HTMLSlotElement* DocumentOrderedMap::GetSlotByName(
     const AtomicString& key,
-    const TreeScope* scope) const {
+    const TreeScope& scope) const {
   if (Element* slot = Get<KeyMatchesSlotName>(key, scope)) {
     DCHECK(isHTMLSlotElement(slot));
     return toHTMLSlotElement(slot);
   }
   return nullptr;
 }
 
 DEFINE_TRACE(DocumentOrderedMap) {
   visitor->Trace(map_);
 }
 
 DEFINE_TRACE(DocumentOrderedMap::MapEntry) {
   visitor->Trace(element);
   visitor->Trace(ordered_list);
 }
 
 }  // namespace blink