More groundwork for flat file based response storage.

webkit/appcache/appcache_storage.cc

 // Copyright (c) 2009 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 "webkit/appcache/appcache_storage.h"
 
 #include "base/stl_util.h"
 #include "webkit/appcache/appcache_response.h"
 #include "webkit/appcache/appcache_service.h"
 #include "webkit/quota/quota_client.h"
@@ skipping 21 matching lines @@
       DelegateReferenceMap::value_type(delegate, this));
 }
 
 AppCacheStorage::DelegateReference::~DelegateReference() {
   if (delegate)
     storage->delegate_references_.erase(delegate);
 }
 
 AppCacheStorage::ResponseInfoLoadTask::ResponseInfoLoadTask(
     const GURL& manifest_url,
+    int64 group_id,
     int64 response_id,
     AppCacheStorage* storage)
     : storage_(storage),
       manifest_url_(manifest_url),
+      group_id_(group_id),
       response_id_(response_id),
       info_buffer_(new HttpResponseInfoIOBuffer),
       ALLOW_THIS_IN_INITIALIZER_LIST(read_callback_(
           this, &ResponseInfoLoadTask::OnReadComplete)) {
   storage_->pending_info_loads_.insert(
       PendingResponseInfoLoads::value_type(response_id, this));
 }
 
 AppCacheStorage::ResponseInfoLoadTask::~ResponseInfoLoadTask() {
 }
 
 void AppCacheStorage::ResponseInfoLoadTask::StartIfNeeded() {
   if (reader_.get())
     return;
   reader_.reset(
-      storage_->CreateResponseReader(manifest_url_, response_id_));
+      storage_->CreateResponseReader(manifest_url_, group_id_, response_id_));
   reader_->ReadInfo(info_buffer_, &read_callback_);
 }
 
 void AppCacheStorage::ResponseInfoLoadTask::OnReadComplete(int result) {
   storage_->pending_info_loads_.erase(response_id_);
   scoped_refptr<AppCacheResponseInfo> info;
   if (result >= 0) {
     info = new AppCacheResponseInfo(storage_->service(), manifest_url_,
                                     response_id_,
                                     info_buffer_->http_info.release(),
                                     info_buffer_->response_data_size);
   }
   FOR_EACH_DELEGATE(delegates_, OnResponseInfoLoaded(info.get(), response_id_));
   delete this;
 }
 
 void AppCacheStorage::LoadResponseInfo(
-    const GURL& manifest_url, int64 id, Delegate* delegate) {
+    const GURL& manifest_url, int64 group_id, int64 id, Delegate* delegate) {
   AppCacheResponseInfo* info = working_set_.GetResponseInfo(id);
   if (info) {
     delegate->OnResponseInfoLoaded(info, id);
     return;
   }
   ResponseInfoLoadTask* info_load =
-      GetOrCreateResponseInfoLoadTask(manifest_url, id);
+      GetOrCreateResponseInfoLoadTask(manifest_url, group_id, id);
   DCHECK(manifest_url == info_load->manifest_url());
+  DCHECK(group_id == info_load->group_id());
   DCHECK(id == info_load->response_id());
   info_load->AddDelegate(GetOrCreateDelegateReference(delegate));
   info_load->StartIfNeeded();
 }
 
 void AppCacheStorage::UpdateUsageMapAndNotify(
     const GURL& origin, int64 new_usage) {
   DCHECK_GE(new_usage, 0);
   int64 old_usage = usage_map_[origin];
   if (new_usage > 0)
@@ skipping 24 matching lines @@
 void AppCacheStorage::NotifyStorageAccessed(const GURL& origin) {
   if (service()->quota_manager_proxy() &&
       usage_map_.find(origin) != usage_map_.end())
     service()->quota_manager_proxy()->NotifyStorageAccessed(
         quota::QuotaClient::kAppcache,
         origin, quota::kStorageTypeTemporary);
 }
 
 }  // namespace appcache