[CacheStorage] Sort QueryCache results by time entered into cache

third_party/WebKit/LayoutTests/http/tests/cachestorage/script-tests/cache-keys.js

 if (self.importScripts) {
     importScripts('/resources/testharness.js');
     importScripts('../resources/test-helpers.js');
 }
 
 cache_test(cache => {
     return cache.keys()
       .then(requests => {
           assert_equals(
             requests.length, 0,
@@ skipping 32 matching lines @@
       .then(function(result) {
           assert_request_array_equals(
             result, [entries.a.request],
             'Cache.keys should match by Request.');
         });
   }, 'Cache.keys with new Request');
 
 prepopulated_cache_test(simple_entries, function(cache, entries) {
     return cache.keys(entries.a.request, {ignoreSearch: true})
       .then(function(result) {
-          // TODO(zino): Should use assert_request_array_equals() instead of
-          // assert_request_array_equivalent() once keys() returns request
-          // keys in key insertion order. Please see http://crbug.com/627821.
-          assert_request_array_equivalent(
+          assert_request_array_equals(
             result,
             [
               entries.a.request,
               entries.a_with_query.request
             ],
             'Cache.keys with ignoreSearch should ignore the ' +
             'search parameters of cached request.');
         });
   },
   'Cache.keys with ignoreSearch option (request with no search ' +
   'parameters)');
 
 prepopulated_cache_test(simple_entries, function(cache, entries) {
     return cache.keys(entries.a_with_query.request, {ignoreSearch: true})
       .then(function(result) {
-          // TODO(zino): Should use assert_request_array_equals() instead of
-          // assert_request_array_equivalent() if once keys() returns request
-          // keys in key insertion order. Please see http://crbug.com/627821.
-          assert_request_array_equivalent(
+          assert_request_array_equals(
             result,
             [
               entries.a.request,
               entries.a_with_query.request
             ],
             'Cache.keys with ignoreSearch should ignore the ' +
             'search parameters of request.');
         });
   },
   'Cache.keys with ignoreSearch option (request with search parameters)');
 
 cache_test(function(cache) {
     var request = new Request('http://example.com/');
     var head_request = new Request('http://example.com/', {method: 'HEAD'});
     var response = new Response('foo');
     return cache.put(request.clone(), response.clone())
       .then(function() {
           return cache.keys(head_request.clone());
         })
       .then(function(result) {
           assert_request_array_equals(
             result, [],
             'Cache.keys should resolve with an empty array with a ' +
             'mismatched method.');
           return cache.keys(head_request.clone(),
                             {ignoreMethod: true});
         })
       .then(function(result) {
-          assert_request_array_equivalent(
+          assert_request_array_equals(
             result,
             [
               request,
             ],
             'Cache.keys with ignoreMethod should ignore the ' +
             'method of request.');
         });
   }, 'Cache.keys supports ignoreMethod');
 
 cache_test(function(cache) {
     var vary_request = new Request('http://example.com/c',
                                    {headers: {'Cookies': 'is-for-cookie'}});
     var vary_response = new Response('', {headers: {'Vary': 'Cookies'}});
     var mismatched_vary_request = new Request('http://example.com/c');
 
     return cache.put(vary_request.clone(), vary_response.clone())
       .then(function() {
           return cache.keys(mismatched_vary_request.clone());
         })
       .then(function(result) {
           assert_request_array_equals(
             result, [],
             'Cache.keys should resolve with an empty array with a ' +
             'mismatched vary.');
           return cache.keys(mismatched_vary_request.clone(),
                               {ignoreVary: true});
         })
       .then(function(result) {
-          assert_request_array_equivalent(
+          assert_request_array_equals(
             result,
             [
               vary_request,
             ],
             'Cache.keys with ignoreVary should ignore the ' +
             'vary of request.');
         });
   }, 'Cache.keys supports ignoreVary');
 
 prepopulated_cache_test(simple_entries, function(cache, entries) {
@@ skipping 14 matching lines @@
           assert_request_array_equals(
             result, [],
             'Cache.keys should treat query as a URL and not ' +
             'just a string fragment.');
         });
   }, 'Cache.keys with string fragment "http" as query');
 
 prepopulated_cache_test(simple_entries, function(cache, entries) {
     return cache.keys()
       .then(function(result) {
-          // TODO(zino): Should use assert_request_array_equals() instead of
-          // assert_request_array_equivalent() once keys() returns request
-          // keys in key insertion order. Please see http://crbug.com/627821.
-          assert_request_array_equivalent(
+          assert_request_array_equals(
             result,
             [
               entries.a.request,
               entries.b.request,
               entries.a_with_query.request,
               entries.A.request,
               entries.a_https.request,
               entries.a_org.request,
               entries.cat.request,
               entries.catmandu.request,
@@ skipping 10 matching lines @@
     return cache.keys(new Request(entries.cat.request.url, {method: 'HEAD'}))
       .then(function(result) {
           assert_request_array_equals(
             result, [],
             'Cache.keys should not match HEAD request unless ignoreMethod ' +
             'option is set.');
         });
   }, 'Cache.keys with a HEAD Request');
 
 done();