MockAppCacheStorage implemenation

webkit/appcache/appcache_storage.h

 // 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.
 
 #ifndef WEBKIT_APPCACHE_APPCACHE_STORAGE_H_
 #define WEBKIT_APPCACHE_APPCACHE_STORAGE_H_
 
 #include <map>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/basictypes.h"
 #include "base/ref_counted.h"
 #include "net/base/net_errors.h"
+#include "testing/gtest/include/gtest/gtest_prod.h"
 #include "webkit/appcache/appcache_response.h"
 #include "webkit/appcache/appcache_working_set.h"
 
 class GURL;
 
 namespace appcache {
 
 class AppCache;
+class AppCacheEntry;
 class AppCacheGroup;
 class AppCacheService;
 
 class AppCacheStorage {
  public:
 
   class Delegate {
    public:
     virtual ~Delegate() {}
 
     // If a load fails the 'cache' will be NULL.
     virtual void OnCacheLoaded(AppCache* cache, int64 cache_id) {}
 
     // If a load fails the 'group' will be NULL.
     virtual void OnGroupLoaded(
         AppCacheGroup* group, const GURL& manifest_url) {}
 
     // If successfully stored 'success' will be true.
     virtual void OnGroupAndNewestCacheStored(
         AppCacheGroup* group, bool success) {}
 
-    // If the update fails, success will be false.
-    virtual void OnGroupMarkedAsObsolete(GURL& manifest_url, bool success) {}
+    // If the operation fails, success will be false.
+    virtual void OnGroupMadeObsolete(AppCacheGroup* group, bool success) {}
 
     // If a load fails the 'response_info' will be NULL.
     virtual void OnResponseInfoLoaded(
         AppCacheResponseInfo* response_info, int64 response_id) {}
 
     // If no response is found, 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, int64 response_id, bool is_fallback,
+        const GURL& url, const AppCacheEntry& entry,
         int64 cache_id, const GURL& mainfest_url) {}
   };
 
   explicit AppCacheStorage(AppCacheService* service);
   virtual ~AppCacheStorage();
 
   // Schedules a cache to be loaded from storage. Upon load completion
   // the delegate will be called back. If the cache 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
@@ skipping 33 matching lines @@
 
   // Immediately updates in-memory storage, if the cache is in memory,
   // and schedules a task to update persistent storage. If the cache is
   // already scheduled to be loaded, upon loading completion the entry
   // will be marked. There is no delegate completion callback.
   virtual void MarkEntryAsForeign(const GURL& entry_url, int64 cache_id) = 0;
 
   // Schedules a task to update persistent storage and doom the group and all
   // related caches and responses for deletion. Upon completion the in-memory
   // instance is marked as obsolete and the delegate callback is called.
-  virtual void MarkGroupAsObsolete(
+  virtual void MakeGroupObsolete(
       AppCacheGroup* group, Delegate* delegate) = 0;
 
   // Cancels all pending callbacks for the delegate. The delegate callbacks
   // will not be invoked after, however any scheduled operations will still
   // 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();
@@ skipping 24 matching lines @@
   }
 
   // The working set of object instances currently in memory.
   AppCacheWorkingSet* working_set() { return &working_set_; }
 
   // Simple ptr back to the service object that owns us.
   AppCacheService* service() { return service_; }
 
  protected:
   friend class AppCacheResponseTest;
+  friend class AppCacheStorageTest;
 
   // Helper to call a collection of delegates.
   #define FOR_EACH_DELEGATE(delegates, func_and_args)                \
     do {                                                             \
       for (DelegateReferenceVector::iterator it = delegates.begin(); \
            it != delegates.end(); ++it) {                            \
         if (it->get()->delegate)                                     \
           it->get()->delegate->func_and_args;                        \
       }                                                              \
     } while (0)
@@ skipping 118 matching lines @@
   int64 last_response_id_;
 
   AppCacheWorkingSet working_set_;
   AppCacheService* service_;
   DelegateReferenceMap delegate_references_;
   PendingResponseInfoLoads pending_info_loads_;
 
   // The set of last ids must be retrieved from storage prior to being used.
   static const int64 kUnitializedId = -1;
 
+  FRIEND_TEST(AppCacheStorageTest, DelegateReferences);
   DISALLOW_COPY_AND_ASSIGN(AppCacheStorage);
 };
 
-// TODO(michaeln): Maybe?
-class AppCacheStoredItem {
- public:
-  bool is_doomed() const { return is_doomed_; }
-  bool is_stored() const { return is_stored_; }
-
- protected:
-  AppCacheStoredItem() : is_doomed_(false), is_stored_(false) {}
-
- private:
-  friend class AppCacheStorage;
-  friend class MockAppCacheStorage;
-
-  void set_is_doomed(bool b) { is_doomed_ = b; }
-  void set_is_stored(bool b) { is_stored_ = b; }
-
-  bool is_doomed_;
-  bool is_stored_;
-};
-
 }  // namespace appcache
 
 #endif  // WEBKIT_APPCACHE_APPCACHE_STORAGE_H_