Get main frame and subframe AppCache loads to work.

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>
 #include <memory>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
 #include "content/browser/appcache/appcache_working_set.h"
 #include "content/common/content_export.h"
 #include "net/base/completion_callback.h"
 
 class GURL;
 
 namespace content {
 FORWARD_DECLARE_TEST(AppCacheStorageTest, DelegateReferences);
 FORWARD_DECLARE_TEST(AppCacheStorageTest, UsageMap);
 class AppCache;
@@ skipping 159 matching lines @@
   // 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.
   virtual void DeleteResponses(const GURL& manifest_url,
                                const std::vector<int64_t>& response_ids) = 0;
 
+  // Returns true if the AppCacheStorage instance is initialized.
+  virtual bool IsInitialized() = 0;
+
   // Generates unique storage ids for different object types.
   int64_t NewCacheId() { return ++last_cache_id_; }
   int64_t NewGroupId() { return ++last_group_id_; }
 
   // The working set of object instances currently in memory.
   AppCacheWorkingSet* working_set() { return &working_set_; }
 
   // A map of origins to usage.
   const UsageMap* usage_map() { return &usage_map_; }
 
   // Simple ptr back to the service object that owns us.
   AppCacheServiceImpl* service() { return service_; }
 
+  // Returns a weak pointer reference to the AppCacheStorage instance.
+  base::WeakPtr<AppCacheStorage> GetWeakPtr();
+
  protected:
   friend class content::AppCacheQuotaClientTest;
   friend class content::AppCacheResponseTest;
   friend class content::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) {                            \
@@ skipping 99 matching lines @@
 
   // Note that the ResponseInfoLoadTask items add themselves to this map.
   std::map<int64_t, std::unique_ptr<ResponseInfoLoadTask>> pending_info_loads_;
 
   // The set of last ids must be retrieved from storage prior to being used.
   static const int64_t kUnitializedId;
 
   FRIEND_TEST_ALL_PREFIXES(content::AppCacheStorageTest, DelegateReferences);
   FRIEND_TEST_ALL_PREFIXES(content::AppCacheStorageTest, UsageMap);
 
+  // The WeakPtrFactory below must occur last in the class definition so they
+  // get destroyed last.
+  base::WeakPtrFactory<AppCacheStorage> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(AppCacheStorage);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_APPCACHE_APPCACHE_STORAGE_H_