Removing unused field - AppCacheResponseIO::group_id_.

content/browser/appcache/appcache_storage.h

 // Copyright (c) 2012 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_APPCACHE_APPCACHE_STORAGE_H_
 #define CONTENT_BROWSER_APPCACHE_APPCACHE_STORAGE_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 96 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_t group_id,
                                 int64_t 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
@@ skipping 38 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_t group_id,
                                                        int64_t 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,
-                                                       int64_t group_id) = 0;
+  virtual AppCacheResponseWriter* CreateResponseWriter(
+      const GURL& manifest_url) = 0;
 
   // Creates a metadata writer to write metadata of response to storage.
   virtual AppCacheResponseMetadataWriter* CreateResponseMetadataWriter(
-      int64_t group_id,
       int64_t response_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_t>& response_ids) = 0;
 
   // Schedules the lazy deletion of responses without persistently saving
   // the response ids.
@@ skipping 50 matching lines @@
   };
   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_t group_id,
                          int64_t response_id,
                          AppCacheStorage* storage);
     ~ResponseInfoLoadTask();
 
     int64_t response_id() const { return response_id_; }
     const GURL& manifest_url() const { return manifest_url_; }
-    int64_t 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_t group_id_;
     int64_t response_id_;
     std::unique_ptr<AppCacheResponseReader> reader_;
     DelegateReferenceVector delegates_;
     scoped_refptr<HttpResponseInfoIOBuffer> info_buffer_;
   };
 
   typedef std::map<int64_t, 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_t group_id,
       int64_t 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, group_id, response_id, this);
+    return new ResponseInfoLoadTask(manifest_url, response_id, this);
   }
 
   // Should only be called when creating a new response writer.
   int64_t NewResponseId() { return ++last_response_id_; }
 
   // Helpers to query and notify the QuotaManager.
   void UpdateUsageMapAndNotify(const GURL& origin, int64_t new_usage);
   void ClearUsageMapAndNotify();
   void NotifyStorageAccessed(const GURL& origin);
 
@@ skipping 13 matching lines @@
 
   FRIEND_TEST_ALL_PREFIXES(content::AppCacheStorageTest, DelegateReferences);
   FRIEND_TEST_ALL_PREFIXES(content::AppCacheStorageTest, UsageMap);
 
   DISALLOW_COPY_AND_ASSIGN(AppCacheStorage);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_APPCACHE_APPCACHE_STORAGE_H_