Make HTMLCollection / NodeList backward traversal consistent with forward one

Source/core/html/CollectionIndexCache.h

 /*
  * Copyright (C) 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Samsung Electronics. 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 143 matching lines @@
     // Determine if we should traverse from the beginning of the collection instead of the cached node.
     bool firstIsCloser = index < currentIndex - index;
     if (firstIsCloser || !collection.canTraverseBackward()) {
         NodeType* firstNode = collection.traverseToFirstElement();
         ASSERT(firstNode);
         setCachedNode(firstNode, 0);
         return index ? nodeAfterCachedNode(collection, index) : firstNode;
     }
 
     // Backward traversal from the cached node to the requested index.
-    NodeType* currentNode = cachedNode();
     ASSERT(collection.canTraverseBackward());
-    while ((currentNode = collection.itemBefore(currentNode))) {
-        ASSERT(currentIndex);
-        --currentIndex;
-        if (currentIndex == index) {
-            setCachedNode(currentNode, currentIndex);
-            return currentNode;
-        }
-    }
-    ASSERT_NOT_REACHED();
-    return 0;
+    NodeType* currentNode = collection.traverseBackwardToOffset(index, *cachedNode(), currentIndex);

[Inactive, 2014/04/09 23:08:58]

We now pass a reference instead of a pointer to the implementation since there
is now a separate traverseToLastElement() method.

+    ASSERT(currentNode);
+    setCachedNode(currentNode, currentIndex);
+    return currentNode;
 }
 
 template <typename Collection, typename NodeType>
 inline NodeType* CollectionIndexCache<Collection, NodeType>::nodeAfterCachedNode(const Collection& collection, unsigned index)
 {
     ASSERT(cachedNode()); // Cache should be valid.
     unsigned currentIndex = cachedNodeIndex();
     ASSERT(currentIndex < index);
 
     // Determine if we should traverse from the end of the collection instead of the cached node.
     bool lastIsCloser = isCachedNodeCountValid() && cachedNodeCount() - index < index - currentIndex;
     if (lastIsCloser && collection.canTraverseBackward()) {
-        NodeType* lastItem = collection.itemBefore(0);

[Inactive, 2014/04/09 23:08:58]

We now call traverseToLastElement() here instead of the generic itemBefore()
which means the implementation no longer need to do a null check on the argument
to know what to do.

+        NodeType* lastItem = collection.traverseToLastElement();
         ASSERT(lastItem);
         setCachedNode(lastItem, cachedNodeCount() - 1);
         if (index < cachedNodeCount() - 1)
             return nodeBeforeCachedNode(collection, index);
         return lastItem;
     }
 
     // Forward traversal from the cached node to the requested index.
     NodeType* currentNode = collection.traverseForwardToOffset(index, *cachedNode(), currentIndex);
     if (!currentNode) {
         // Did not find the node. On plus side, we now know the length.
         setCachedNodeCount(currentIndex + 1);
         return 0;
     }
     setCachedNode(currentNode, currentIndex);
     return currentNode;
 }
 
 } // namespace WebCore
 
 #endif // CollectionIndexCache_h