[CacheStorage] Sort QueryCache results by time entered into cache

content/browser/cache_storage/cache_storage_cache_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/cache_storage/cache_storage_cache.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 628 matching lines @@
 
   void SizeCallback(base::RunLoop* run_loop,
                     bool* callback_called,
                     int64_t size) {
     *callback_called = true;
     callback_size_ = size;
     if (run_loop)
       run_loop->Quit();
   }
 
-  bool VerifyKeys(const std::vector<std::string>& expected_keys) {
-    if (expected_keys.size() != callback_strings_.size())
-      return false;
-
-    std::set<std::string> found_set;
-    for (int i = 0, max = callback_strings_.size(); i < max; ++i)
-      found_set.insert(callback_strings_[i]);
-
-    for (int i = 0, max = expected_keys.size(); i < max; ++i) {
-      if (found_set.find(expected_keys[i]) == found_set.end())
-        return false;
-    }
-    return true;
-  }
-
   bool TestResponseType(blink::WebServiceWorkerResponseType response_type) {
     body_response_.response_type = response_type;
     EXPECT_TRUE(Put(body_request_, body_response_));
     EXPECT_TRUE(Match(body_request_));
     EXPECT_TRUE(Delete(body_request_));
     return response_type == callback_response_->response_type;
   }
 
   void VerifyAllOpsFail() {
     EXPECT_FALSE(Put(no_body_request_, no_body_response_));
@@ skipping 258 matching lines @@
 TEST_P(CacheStorageCacheTestP, MatchAll_NoBody) {
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
 
   std::unique_ptr<CacheStorageCache::Responses> responses;
   std::unique_ptr<CacheStorageCache::BlobDataHandles> body_handles;
   EXPECT_TRUE(MatchAll(&responses, &body_handles));
 
   ASSERT_EQ(1u, responses->size());
   EXPECT_TRUE(
       ResponseMetadataEqual(SetCacheName(no_body_response_), responses->at(0)));
-  EXPECT_TRUE(body_handles->empty());
+  EXPECT_FALSE(body_handles->at(0));
 }
 
 TEST_P(CacheStorageCacheTestP, MatchAll_Body) {
   EXPECT_TRUE(Put(body_request_, body_response_));
 
   std::unique_ptr<CacheStorageCache::Responses> responses;
   std::unique_ptr<CacheStorageCache::BlobDataHandles> body_handles;
   EXPECT_TRUE(MatchAll(&responses, &body_handles));
 
   ASSERT_EQ(1u, responses->size());
   ASSERT_EQ(1u, body_handles->size());
   EXPECT_TRUE(
       ResponseMetadataEqual(SetCacheName(body_response_), responses->at(0)));
-  EXPECT_TRUE(ResponseBodiesEqual(expected_blob_data_, body_handles->at(0)));
+  EXPECT_TRUE(ResponseBodiesEqual(expected_blob_data_, *body_handles->at(0)));
 }
 
 TEST_P(CacheStorageCacheTestP, MatchAll_TwoResponsesThenOne) {
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
   EXPECT_TRUE(Put(body_request_, body_response_));
 
   std::unique_ptr<CacheStorageCache::Responses> responses;
   std::unique_ptr<CacheStorageCache::BlobDataHandles> body_handles;
   EXPECT_TRUE(MatchAll(&responses, &body_handles));
-  ASSERT_EQ(2u, responses->size());
-  ASSERT_EQ(1u, body_handles->size());
+  ASSERT_TRUE(body_handles->at(1));
 
-  // Order of returned responses is not guaranteed.
-  std::set<std::string> matched_set;
-  for (const ServiceWorkerResponse& response : *responses) {
-    if (response.url.spec() == "http://example.com/no_body.html") {
-      EXPECT_TRUE(
-          ResponseMetadataEqual(SetCacheName(no_body_response_), response));
-      matched_set.insert(response.url.spec());
-    } else if (response.url.spec() == "http://example.com/body.html") {
-      EXPECT_TRUE(
-          ResponseMetadataEqual(SetCacheName(body_response_), response));
-      EXPECT_TRUE(
-          ResponseBodiesEqual(expected_blob_data_, body_handles->at(0)));
-      matched_set.insert(response.url.spec());
-    }
-  }
-  EXPECT_EQ(2u, matched_set.size());
+  EXPECT_TRUE(
+      ResponseMetadataEqual(SetCacheName(no_body_response_), responses->at(0)));
+  EXPECT_FALSE(body_handles->at(0));
+  EXPECT_TRUE(
+      ResponseMetadataEqual(SetCacheName(body_response_), responses->at(1)));
+  EXPECT_TRUE(ResponseBodiesEqual(expected_blob_data_, *body_handles->at(1)));
 
   responses->clear();
   body_handles->clear();
 
   EXPECT_TRUE(Delete(body_request_));
   EXPECT_TRUE(MatchAll(&responses, &body_handles));
 
   ASSERT_EQ(1u, responses->size());
   EXPECT_TRUE(
       ResponseMetadataEqual(SetCacheName(no_body_response_), responses->at(0)));
-  EXPECT_TRUE(body_handles->empty());
+  ASSERT_EQ(1u, body_handles->size());
+  EXPECT_FALSE(body_handles->at(0));
 }
 
 TEST_P(CacheStorageCacheTestP, Match_IgnoreSearch) {
   EXPECT_TRUE(Put(body_request_with_query_, body_response_with_query_));
 
   EXPECT_FALSE(Match(body_request_));
   CacheStorageCacheQueryParams match_params;
   match_params.ignore_search = true;
   EXPECT_TRUE(Match(body_request_, match_params));
 }
@@ skipping 180 matching lines @@
   EXPECT_TRUE(responses->empty());
   EXPECT_TRUE(body_handles->empty());
 
   match_params.ignore_method = true;
   EXPECT_TRUE(
       MatchAll(body_head_request_, match_params, &responses, &body_handles));
   ASSERT_EQ(1u, responses->size());
   ASSERT_EQ(1u, body_handles->size());
   EXPECT_TRUE(
       ResponseMetadataEqual(SetCacheName(body_response_), responses->at(0)));
-  EXPECT_TRUE(ResponseBodiesEqual(expected_blob_data_, body_handles->at(0)));
+  EXPECT_TRUE(ResponseBodiesEqual(expected_blob_data_, *body_handles->at(0)));
 }
 
 TEST_P(CacheStorageCacheTestP, Vary) {
   body_request_.headers["vary_foo"] = "foo";
   body_response_.headers["vary"] = "vary_foo";
   EXPECT_TRUE(Put(body_request_, body_response_));
   EXPECT_TRUE(Match(body_request_));
 
   body_request_.headers["vary_foo"] = "bar";
   EXPECT_FALSE(Match(body_request_));
@@ skipping 51 matching lines @@
 
 TEST_P(CacheStorageCacheTestP, EmptyKeys) {
   EXPECT_TRUE(Keys());
   EXPECT_EQ(0u, callback_strings_.size());
 }
 
 TEST_P(CacheStorageCacheTestP, TwoKeys) {
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
   EXPECT_TRUE(Put(body_request_, body_response_));
   EXPECT_TRUE(Keys());
-  EXPECT_EQ(2u, callback_strings_.size());
-  std::vector<std::string> expected_keys;
-  expected_keys.push_back(no_body_request_.url.spec());
-  expected_keys.push_back(body_request_.url.spec());
-  EXPECT_TRUE(VerifyKeys(expected_keys));
+  std::vector<std::string> expected_keys{no_body_request_.url.spec(),
+                                         body_request_.url.spec()};
+  EXPECT_EQ(expected_keys, callback_strings_);
 }
 
 TEST_P(CacheStorageCacheTestP, TwoKeysThenOne) {
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
   EXPECT_TRUE(Put(body_request_, body_response_));
   EXPECT_TRUE(Keys());
-  EXPECT_EQ(2u, callback_strings_.size());
-  std::vector<std::string> expected_keys;
-  expected_keys.push_back(no_body_request_.url.spec());
-  expected_keys.push_back(body_request_.url.spec());
-  EXPECT_TRUE(VerifyKeys(expected_keys));
+  std::vector<std::string> expected_keys{no_body_request_.url.spec(),
+                                         body_request_.url.spec()};
+  EXPECT_EQ(expected_keys, callback_strings_);
 
   EXPECT_TRUE(Delete(body_request_));
   EXPECT_TRUE(Keys());
-  EXPECT_EQ(1u, callback_strings_.size());
-  std::vector<std::string> expected_key;
-  expected_key.push_back(no_body_request_.url.spec());
-  EXPECT_TRUE(VerifyKeys(expected_key));
+  std::vector<std::string> expected_keys2{no_body_request_.url.spec()};
+  EXPECT_EQ(expected_keys2, callback_strings_);
 }
 
 TEST_P(CacheStorageCacheTestP, KeysWithIgnoreSearchTrue) {
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
   EXPECT_TRUE(Put(body_request_, body_response_));
   EXPECT_TRUE(Put(body_request_with_query_, body_response_with_query_));
 
   CacheStorageCacheQueryParams match_params;
   match_params.ignore_search = true;
 
   EXPECT_TRUE(Keys(body_request_with_query_, match_params));
-  EXPECT_EQ(2u, callback_strings_.size());
   std::vector<std::string> expected_keys = {
       body_request_.url.spec(), body_request_with_query_.url.spec()};
-  EXPECT_TRUE(VerifyKeys(expected_keys));
+  EXPECT_EQ(expected_keys, callback_strings_);
 }
 
 TEST_P(CacheStorageCacheTestP, KeysWithIgnoreSearchFalse) {
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
   EXPECT_TRUE(Put(body_request_, body_response_));
   EXPECT_TRUE(Put(body_request_with_query_, body_response_with_query_));
 
   // Default value of ignore_search is false.
   CacheStorageCacheQueryParams match_params;
   match_params.ignore_search = false;
   EXPECT_EQ(match_params.ignore_search,
             CacheStorageCacheQueryParams().ignore_search);
 
   EXPECT_TRUE(Keys(body_request_with_query_, match_params));
-  EXPECT_EQ(1u, callback_strings_.size());
   std::vector<std::string> expected_keys = {
       body_request_with_query_.url.spec()};
-  EXPECT_TRUE(VerifyKeys(expected_keys));
+  EXPECT_EQ(expected_keys, callback_strings_);
 }
 
 TEST_P(CacheStorageCacheTestP, DeleteNoBody) {
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
   EXPECT_TRUE(Match(no_body_request_));
   EXPECT_TRUE(Delete(no_body_request_));
   EXPECT_FALSE(Match(no_body_request_));
   EXPECT_FALSE(Delete(no_body_request_));
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
   EXPECT_TRUE(Match(no_body_request_));
@@ skipping 10 matching lines @@
   EXPECT_TRUE(Match(body_request_));
   EXPECT_TRUE(Delete(body_request_));
 }
 
 TEST_P(CacheStorageCacheTestP, DeleteWithIgnoreSearchTrue) {
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
   EXPECT_TRUE(Put(body_request_, body_response_));
   EXPECT_TRUE(Put(body_request_with_query_, body_response_with_query_));
 
   EXPECT_TRUE(Keys());
-  EXPECT_EQ(3u, callback_strings_.size());
-  std::vector<std::string> expected_keys;
-  expected_keys.push_back(no_body_request_.url.spec());
-  expected_keys.push_back(body_request_.url.spec());
-  expected_keys.push_back(body_request_with_query_.url.spec());
-  EXPECT_TRUE(VerifyKeys(expected_keys));
+  std::vector<std::string> expected_keys{no_body_request_.url.spec(),
+                                         body_request_.url.spec(),
+                                         body_request_with_query_.url.spec()};
+  EXPECT_EQ(expected_keys, callback_strings_);
 
   // The following delete operation will remove both of body_request_ and
   // body_request_with_query_ from cache storage.
   CacheStorageCacheQueryParams match_params;
   match_params.ignore_search = true;
   EXPECT_TRUE(Delete(body_request_with_query_, match_params));
 
   EXPECT_TRUE(Keys());
-  EXPECT_EQ(1u, callback_strings_.size());
   expected_keys.clear();
-  expected_keys.push_back(no_body_request_.url.spec());
-  EXPECT_TRUE(VerifyKeys(expected_keys));
+  std::vector<std::string> expected_keys2{no_body_request_.url.spec()};
+  EXPECT_EQ(expected_keys2, callback_strings_);
 }
 
 TEST_P(CacheStorageCacheTestP, DeleteWithIgnoreSearchFalse) {
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
   EXPECT_TRUE(Put(body_request_, body_response_));
   EXPECT_TRUE(Put(body_request_with_query_, body_response_with_query_));
 
   EXPECT_TRUE(Keys());
-  EXPECT_EQ(3u, callback_strings_.size());
-  std::vector<std::string> expected_keys;
-  expected_keys.push_back(no_body_request_.url.spec());
-  expected_keys.push_back(body_request_.url.spec());
-  expected_keys.push_back(body_request_with_query_.url.spec());
-  EXPECT_TRUE(VerifyKeys(expected_keys));
+  std::vector<std::string> expected_keys{no_body_request_.url.spec(),
+                                         body_request_.url.spec(),
+                                         body_request_with_query_.url.spec()};
+  EXPECT_EQ(expected_keys, callback_strings_);
 
   // Default value of ignore_search is false.
   CacheStorageCacheQueryParams match_params;
   match_params.ignore_search = false;
   EXPECT_EQ(match_params.ignore_search,
             CacheStorageCacheQueryParams().ignore_search);
 
   EXPECT_TRUE(Delete(body_request_with_query_, match_params));
 
   EXPECT_TRUE(Keys());
-  EXPECT_EQ(2u, callback_strings_.size());
-  expected_keys.clear();
-  expected_keys.push_back(no_body_request_.url.spec());
-  expected_keys.push_back(body_request_.url.spec());
-  EXPECT_TRUE(VerifyKeys(expected_keys));
+  std::vector<std::string> expected_keys2{no_body_request_.url.spec(),
+                                          body_request_.url.spec()};
+  EXPECT_EQ(expected_keys2, callback_strings_);
 }
 
 TEST_P(CacheStorageCacheTestP, QuickStressNoBody) {
   for (int i = 0; i < 100; ++i) {
     EXPECT_FALSE(Match(no_body_request_));
     EXPECT_TRUE(Put(no_body_request_, no_body_response_));
     EXPECT_TRUE(Match(no_body_request_));
     EXPECT_TRUE(Delete(no_body_request_));
   }
 }
@@ skipping 249 matching lines @@
   EXPECT_EQ(1, sequence_out);
   close_loop2->Run();
   EXPECT_EQ(2, sequence_out);
 }
 
 INSTANTIATE_TEST_CASE_P(CacheStorageCacheTest,
                         CacheStorageCacheTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content