[CacheStorage] Sort QueryCache results by time entered into cache

content/browser/cache_storage/cache_storage_cache.h

 // 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.
 
 #ifndef CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_CACHE_H_
 #define CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_CACHE_H_
 
 #include <stdint.h>
 
 #include <vector>
@@ skipping 33 matching lines @@
 // asynchronous methods are executed serially. Callbacks to the public functions
 // will be called so long as the cache object lives.
 class CONTENT_EXPORT CacheStorageCache {
  public:
   using ErrorCallback = base::Callback<void(CacheStorageError)>;
   using ResponseCallback =
       base::Callback<void(CacheStorageError,
                           std::unique_ptr<ServiceWorkerResponse>,
                           std::unique_ptr<storage::BlobDataHandle>)>;
   using Responses = std::vector<ServiceWorkerResponse>;
-  using BlobDataHandles = std::vector<storage::BlobDataHandle>;
+  using BlobDataHandles = std::vector<std::unique_ptr<storage::BlobDataHandle>>;
   using ResponsesCallback =
       base::Callback<void(CacheStorageError,
                           std::unique_ptr<Responses>,
                           std::unique_ptr<BlobDataHandles>)>;
   using Requests = std::vector<ServiceWorkerFetchRequest>;
   using RequestsCallback =
       base::Callback<void(CacheStorageError, std::unique_ptr<Requests>)>;
   using SizeCallback = base::Callback<void(int64_t)>;
 
   enum EntryIndex { INDEX_HEADERS = 0, INDEX_RESPONSE_BODY, INDEX_SIDE_DATA };
@@ skipping 83 matching lines @@
   // Async operations in progress will cancel and not run their callbacks.
   virtual ~CacheStorageCache();
 
   base::FilePath path() const { return path_; }
 
   std::string cache_name() const { return cache_name_; }
 
   base::WeakPtr<CacheStorageCache> AsWeakPtr();
 
  private:
-  friend class base::RefCounted<CacheStorageCache>;
-  friend class TestCacheStorageCache;
-  friend class CacheStorageCacheTest;
-
-  struct OpenAllEntriesContext;
-  struct PutContext;
-  struct QueryCacheResults;
-
-  using QueryCacheResultsCallback =
-      base::Callback<void(CacheStorageError,
-                          std::unique_ptr<QueryCacheResults>)>;
-
   enum class QueryCacheType { REQUESTS, REQUESTS_AND_RESPONSES, CACHE_ENTRIES };
 
   // The backend progresses from uninitialized, to open, to closed, and cannot
   // reverse direction.  The open step may be skipped.
   enum BackendState {
     BACKEND_UNINITIALIZED,  // No backend, create backend on first operation.
     BACKEND_OPEN,           // Backend can be used.
     BACKEND_CLOSED          // Backend cannot be used.  All ops should fail.
   };
 
+  friend class base::RefCounted<CacheStorageCache>;
+  friend class TestCacheStorageCache;
+  friend class CacheStorageCacheTest;
+
+  struct OpenAllEntriesContext;
+  struct PutContext;
+  struct QueryCacheContext;
+  struct QueryCacheResult;
+
+  using QueryCacheResults = std::vector<QueryCacheResult>;
+  using QueryCacheCallback =
+      base::Callback<void(CacheStorageError,
+                          std::unique_ptr<QueryCacheResults>)>;
   using Entries = std::vector<disk_cache::Entry*>;
   using ScopedBackendPtr = std::unique_ptr<disk_cache::Backend>;
   using BlobToDiskCacheIDMap =
       IDMap<CacheStorageBlobToDiskCache, IDMapOwnPointer>;
   using OpenAllEntriesCallback =
       base::Callback<void(std::unique_ptr<OpenAllEntriesContext>,
                           CacheStorageError)>;
 
   CacheStorageCache(
       const GURL& origin,
@@ skipping 12 matching lines @@
 
   // Runs |callback| with matching requests/response data. The data provided
   // in the QueryCacheResults depends on the |query_type|. If |query_type| is
   // CACHE_ENTRIES then only out_entries is valid. If |query_type| is REQUESTS
   // then only out_requests is valid. If |query_type| is
   // REQUESTS_AND_RESPONSES then only out_requests, out_responses, and
   // out_blob_data_handles are valid.
   void QueryCache(std::unique_ptr<ServiceWorkerFetchRequest> request,
                   const CacheStorageCacheQueryParams& options,
                   QueryCacheType query_type,
-                  const QueryCacheResultsCallback& callback);
+                  const QueryCacheCallback& callback);
   void QueryCacheDidOpenFastPath(
-      std::unique_ptr<QueryCacheResults> query_cache_results,
+      std::unique_ptr<QueryCacheContext> query_cache_context,
       int rv);
   void QueryCacheOpenNextEntry(
-      std::unique_ptr<QueryCacheResults> query_cache_results);
+      std::unique_ptr<QueryCacheContext> query_cache_context);
   void QueryCacheFilterEntry(
-      std::unique_ptr<QueryCacheResults> query_cache_results,
+      std::unique_ptr<QueryCacheContext> query_cache_context,
       int rv);
   void QueryCacheDidReadMetadata(
-      std::unique_ptr<QueryCacheResults> query_cache_results,
+      std::unique_ptr<QueryCacheContext> query_cache_context,
       disk_cache::ScopedEntryPtr entry,
       std::unique_ptr<CacheMetadata> metadata);
+  static bool QueryCacheResultCompare(const QueryCacheResult& lhs,
+                                      const QueryCacheResult& rhs);
 
   // Match callbacks
   void MatchImpl(std::unique_ptr<ServiceWorkerFetchRequest> request,
                  const CacheStorageCacheQueryParams& match_params,
                  const ResponseCallback& callback);
   void MatchDidMatchAll(const ResponseCallback& callback,
                         CacheStorageError match_all_error,
                         std::unique_ptr<Responses> match_all_responses,
                         std::unique_ptr<BlobDataHandles> match_all_handles);
 
@@ skipping 154 matching lines @@
   bool memory_only_;
 
   base::WeakPtrFactory<CacheStorageCache> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CacheStorageCache);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_CACHE_H_