[CacheStorage] Make CacheStorage::MatchAllCaches return in order

content/browser/cache_storage/cache_storage.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_H_
 #define CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 68 matching lines @@
 
   // Calls the callback with a vector of cache names (keys) available.
   void EnumerateCaches(const StringsAndErrorCallback& callback);
 
   // Calls match on the cache with the given |cache_name|.
   void MatchCache(const std::string& cache_name,
                   scoped_ptr<ServiceWorkerFetchRequest> request,
                   const CacheStorageCache::ResponseCallback& callback);
 
   // Calls match on all of the caches in parallel, calling |callback| with the
-  // first response found. Note that if multiple caches have the same
-  // request/response then it is not defined which cache's response will be
-  // returned. If no response is found then |callback| is called with
+  // response from the first cache (in order of cache creation) to have the
+  // entry. If no response is found then |callback| is called with
   // CACHE_STORAGE_ERROR_NOT_FOUND.
   void MatchAllCaches(scoped_ptr<ServiceWorkerFetchRequest> request,
                       const CacheStorageCache::ResponseCallback& callback);
 
   // Sums the sizes of each cache and closes them. Runs |callback| with the
   // size.
   void GetSizeThenCloseAllCaches(const SizeCallback& callback);
 
   // The size of all of the origin's contents. This value should be used as an
   // estimate only since the cache may be modified at any time.
   void Size(const SizeCallback& callback);
 
   // The functions below are for tests to verify that the operations run
   // serially.
   void StartAsyncOperationForTesting();
   void CompleteAsyncOperationForTesting();
 
  private:
   friend class TestCacheStorage;
-
+  class CacheLoader;
   class MemoryLoader;
   class SimpleCacheLoader;
-  class CacheLoader;
+  struct CacheMatchResponse;
 
   typedef std::map<std::string, base::WeakPtr<CacheStorageCache>> CacheMap;
 
   // Return a CacheStorageCache for the given name if the name is known. If the
   // CacheStorageCache has been deleted, creates a new one.
   scoped_refptr<CacheStorageCache> GetLoadedCache(
       const std::string& cache_name);
 
   // Holds a reference to a cache for thirty seconds.
   void TemporarilyPreserveCache(scoped_refptr<CacheStorageCache> cache);
@@ skipping 46 matching lines @@
                       const CacheStorageCache::ResponseCallback& callback);
   void MatchCacheDidMatch(scoped_refptr<CacheStorageCache> cache,
                           const CacheStorageCache::ResponseCallback& callback,
                           CacheStorageError error,
                           scoped_ptr<ServiceWorkerResponse> response,
                           scoped_ptr<storage::BlobDataHandle> handle);
 
   // The MatchAllCaches callbacks are below.
   void MatchAllCachesImpl(scoped_ptr<ServiceWorkerFetchRequest> request,
                           const CacheStorageCache::ResponseCallback& callback);
-  void MatchAllCachesDidMatch(scoped_refptr<CacheStorageCache> cache,
-                              const base::Closure& barrier_closure,
-                              CacheStorageCache::ResponseCallback* callback,
-                              CacheStorageError error,
-                              scoped_ptr<ServiceWorkerResponse> response,
-                              scoped_ptr<storage::BlobDataHandle> handle);
+  void MatchAllCachesDidMatch(
+      scoped_refptr<CacheStorageCache> cache,
+      CacheMatchResponse* out_match_response,
+      const base::Closure& barrier_closure,
+      CacheStorageError error,
+      scoped_ptr<ServiceWorkerResponse> service_worker_response,
+      scoped_ptr<storage::BlobDataHandle> handle);
   void MatchAllCachesDidMatchAll(
-      scoped_ptr<CacheStorageCache::ResponseCallback> callback);
+      scoped_ptr<std::vector<CacheMatchResponse>> match_responses,
+      const CacheStorageCache::ResponseCallback& callback);
 
   void GetSizeThenCloseAllCachesImpl(const SizeCallback& callback);
 
   void SizeImpl(const SizeCallback& callback);
 
   void PendingClosure(const base::Closure& callback);
   void PendingBoolAndErrorCallback(const BoolAndErrorCallback& callback,
                                    bool found,
                                    CacheStorageError error);
   void PendingCacheAndErrorCallback(const CacheAndErrorCallback& callback,
@@ skipping 47 matching lines @@
   GURL origin_;
 
   base::WeakPtrFactory<CacheStorage> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CacheStorage);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_H_