AppCache + Quota integration

webkit/appcache/mock_appcache_storage.cc

 // 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.
 
 #include "webkit/appcache/mock_appcache_storage.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_entry.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_response.h"
+#include "webkit/appcache/appcache_service.h"
 
 // This is a quick and easy 'mock' implementation of the storage interface
 // that doesn't put anything to disk.
 //
 // We simply add an extra reference to objects when they're put in storage,
 // and remove the extra reference when they are removed from storage.
 // Responses are never really removed from the in-memory disk cache.
 // Delegate callbacks are made asyncly to appropiately mimic what will
 // happen with a real disk-backed storage impl that involves IO on a
 // background thread.
@@ skipping 11 matching lines @@
       simulated_found_network_namespace_(false) {
   last_cache_id_ = 0;
   last_group_id_ = 0;
   last_response_id_ = 0;
 }
 
 MockAppCacheStorage::~MockAppCacheStorage() {
   STLDeleteElements(&pending_tasks_);
 }
 
+void MockAppCacheStorage::GetAllInfo(Delegate* delegate) {
+  ScheduleTask(method_factory_.NewRunnableMethod(
+      &MockAppCacheStorage::ProcessGetAllInfo,
+      make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
+}
+
 void MockAppCacheStorage::LoadCache(int64 id, Delegate* delegate) {
   DCHECK(delegate);
   AppCache* cache = working_set_.GetCache(id);
   if (ShouldCacheLoadAppearAsync(cache)) {
     ScheduleTask(method_factory_.NewRunnableMethod(
         &MockAppCacheStorage::ProcessLoadCache,
         id, make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
     return;
   }
   ProcessLoadCache(id, GetOrCreateDelegateReference(delegate));
@@ skipping 101 matching lines @@
     const GURL& manifest_url, const std::vector<int64>& response_ids) {
   // We don't bother with actually removing responses from the disk-cache,
   // just keep track of which ids have been doomed or deleted
   std::vector<int64>::const_iterator it = response_ids.begin();
   while (it != response_ids.end()) {
     doomed_response_ids_.insert(*it);
     ++it;
   }
 }
 
+void MockAppCacheStorage::ProcessGetAllInfo(
+    scoped_refptr<DelegateReference> delegate_ref) {
+  if (delegate_ref->delegate)
+    delegate_ref->delegate->OnAllInfo(simulated_appcache_info_);
+}
+
 void MockAppCacheStorage::ProcessLoadCache(
     int64 id, scoped_refptr<DelegateReference> delegate_ref) {
   AppCache* cache = working_set_.GetCache(id);
   if (delegate_ref->delegate)
     delegate_ref->delegate->OnCacheLoaded(cache, id);
 }
 
 void MockAppCacheStorage::ProcessLoadOrCreateGroup(
     const GURL& manifest_url, scoped_refptr<DelegateReference> delegate_ref) {
   scoped_refptr<AppCacheGroup> group(working_set_.GetGroup(manifest_url));
@@ skipping 291 matching lines @@
 bool MockAppCacheStorage::ShouldCacheLoadAppearAsync(const AppCache* cache) {
   if (!cache)
     return true;
 
   // If the 'stored' ref is the only ref, real storage will have to load from
   // the database.
   return IsCacheStored(cache) && cache->HasOneRef();
 }
 
 }  // namespace appcache