More groundwork for flat file based response storage.

webkit/appcache/appcache_storage.h

 // Copyright (c) 2011 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 WEBKIT_APPCACHE_APPCACHE_STORAGE_H_
 #define WEBKIT_APPCACHE_APPCACHE_STORAGE_H_
 
 #include <map>
 #include <vector>
 
@@ skipping 48 matching lines @@
     // If a load fails the 'response_info' will be NULL.
     virtual void OnResponseInfoLoaded(
         AppCacheResponseInfo* response_info, int64 response_id) {}
 
     // If no response is found, entry.response_id() will be kNoResponseId.
     // If a response is found, the cache id and manifest url of the
     // containing cache and group are also returned.
     virtual void OnMainResponseFound(
         const GURL& url, const AppCacheEntry& entry,
         const GURL& fallback_url, const AppCacheEntry& fallback_entry,
-        int64 cache_id, const GURL& mainfest_url) {}
+        int64 cache_id, int64 group_id, const GURL& mainfest_url) {}
   };
 
   explicit AppCacheStorage(AppCacheService* service);
   virtual ~AppCacheStorage();
 
   // Schedules a task to retrieve basic info about all groups and caches
   // stored in the system. Upon completion the delegate will be called
   // with the results.
   virtual void GetAllInfo(Delegate* delegate) = 0;
 
@@ skipping 11 matching lines @@
   // the delegate will be called back with a NULL group pointer.
   virtual void LoadOrCreateGroup(
       const GURL& manifest_url, Delegate* delegate) = 0;
 
   // Schedules response info to be loaded from storage.
   // Upon load completion the delegate will be called back. If the data
   // already resides in memory, the delegate will be called back
   // immediately without returning to the message loop. If the load fails,
   // the delegate will be called back with a NULL pointer.
   virtual void LoadResponseInfo(
-      const GURL& manifest_url, int64 response_id, Delegate* delegate);
+      const GURL& manifest_url, int64 group_id, int64 response_id,
+      Delegate* delegate);
 
   // Schedules a group and its newest complete cache to be initially stored or
   // incrementally updated with new changes. Upon completion the delegate
   // will be called back. A group without a newest cache cannot be stored.
   // It's a programming error to call this method without a newest cache. A
   // side effect of storing a new newest cache is the removal of the group's
   // old caches and responses from persistent storage (although they may still
   // linger in the in-memory working set until no longer needed). The new
   // cache will be added as the group's newest complete cache only if storage
   // succeeds.
@@ skipping 31 matching lines @@
   // take place. The callbacks for subsequently scheduled operations are
   // unaffected.
   void CancelDelegateCallbacks(Delegate* delegate) {
     DelegateReference* delegate_reference = GetDelegateReference(delegate);
     if (delegate_reference)
       delegate_reference->CancelReference();
   }
 
   // Creates a reader to read a response from storage.
   virtual AppCacheResponseReader* CreateResponseReader(
-      const GURL& manifest_url, int64 response_id) = 0;
+      const GURL& manifest_url, int64 group_id, int64 response_id) = 0;
 
   // Creates a writer to write a new response to storage. This call
   // establishes a new response id.
   virtual AppCacheResponseWriter* CreateResponseWriter(
-      const GURL& manifest_url) = 0;
+      const GURL& manifest_url, int64 group_id) = 0;
 
   // Schedules the lazy deletion of responses and saves the ids
   // persistently such that the responses will be deleted upon restart
   // if they aren't deleted prior to shutdown.
   virtual void DoomResponses(
       const GURL& manifest_url, const std::vector<int64>& response_ids) = 0;
 
   // Schedules the lazy deletion of responses without persistently saving
   // the response ids.
   virtual void DeleteResponses(
@@ skipping 53 matching lines @@
     virtual ~DelegateReference();
   };
   typedef std::map<Delegate*, DelegateReference*> DelegateReferenceMap;
   typedef std::vector<scoped_refptr<DelegateReference> >
       DelegateReferenceVector;
 
   // Helper used to manage an async LoadResponseInfo calls on behalf of
   // multiple callers.
   class ResponseInfoLoadTask {
    public:
-    ResponseInfoLoadTask(const GURL& manifest_url, int64 response_id,
-                         AppCacheStorage* storage);
+    ResponseInfoLoadTask(const GURL& manifest_url, int64 group_id,
+                         int64 response_id, AppCacheStorage* storage);
     ~ResponseInfoLoadTask();
 
     int64 response_id() const { return response_id_; }
     const GURL& manifest_url() const { return manifest_url_; }
+    int64 group_id() const { return group_id_; }
 
     void AddDelegate(DelegateReference* delegate_reference) {
       delegates_.push_back(delegate_reference);
     }
 
     void StartIfNeeded();
 
    private:
     void OnReadComplete(int result);
 
     AppCacheStorage* storage_;
     GURL manifest_url_;
+    int64 group_id_;
     int64 response_id_;
     scoped_ptr<AppCacheResponseReader> reader_;
     DelegateReferenceVector delegates_;
     scoped_refptr<HttpResponseInfoIOBuffer> info_buffer_;
     net::OldCompletionCallbackImpl<ResponseInfoLoadTask> read_callback_;
   };
 
   typedef std::map<int64, ResponseInfoLoadTask*> PendingResponseInfoLoads;
 
   DelegateReference* GetDelegateReference(Delegate* delegate) {
     DelegateReferenceMap::iterator iter =
         delegate_references_.find(delegate);
     if (iter != delegate_references_.end())
       return iter->second;
     return NULL;
   }
 
   DelegateReference* GetOrCreateDelegateReference(Delegate* delegate) {
     DelegateReference* reference = GetDelegateReference(delegate);
     if (reference)
       return reference;
     return new DelegateReference(delegate, this);
   }
 
   ResponseInfoLoadTask* GetOrCreateResponseInfoLoadTask(
-      const GURL& manifest_url, int64 response_id) {
+      const GURL& manifest_url, int64 group_id, int64 response_id) {
     PendingResponseInfoLoads::iterator iter =
         pending_info_loads_.find(response_id);
     if (iter != pending_info_loads_.end())
       return iter->second;
-    return new ResponseInfoLoadTask(manifest_url, response_id, this);
+    return new ResponseInfoLoadTask(manifest_url, group_id, response_id, this);
   }
 
   // Should only be called when creating a new response writer.
   int64 NewResponseId() {
     return ++last_response_id_;
   }
 
   // Helpers to query and notify the QuotaManager.
   void UpdateUsageMapAndNotify(const GURL& origin, int64 new_usage);
   void ClearUsageMapAndNotify();
@@ skipping 16 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(AppCacheStorageTest, DelegateReferences);
   FRIEND_TEST_ALL_PREFIXES(AppCacheStorageTest, UsageMap);
 
   DISALLOW_COPY_AND_ASSIGN(AppCacheStorage);
 };
 
 }  // namespace appcache
 
 #endif  // WEBKIT_APPCACHE_APPCACHE_STORAGE_H_