AppCache INTERCEPT namespace.

webkit/appcache/appcache_database.h

 // 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.
 
 #ifndef WEBKIT_APPCACHE_APPCACHE_DATABASE_H_
 #define WEBKIT_APPCACHE_APPCACHE_DATABASE_H_
 
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time.h"
 #include "googleurl/src/gurl.h"
 #include "webkit/appcache/appcache_export.h"
+#include "webkit/appcache/appcache_interfaces.h"
 
 namespace sql {
 class Connection;
 class MetaTable;
 class Statement;
 class StatementID;
 }
 
 namespace appcache {
 
@@ skipping 24 matching lines @@
   struct EntryRecord {
     EntryRecord() : cache_id(0), flags(0), response_id(0), response_size(0) {}
 
     int64 cache_id;
     GURL url;
     int flags;
     int64 response_id;
     int64 response_size;
   };
 
-  struct APPCACHE_EXPORT FallbackNameSpaceRecord {
-    FallbackNameSpaceRecord();
-    ~FallbackNameSpaceRecord();
+  struct APPCACHE_EXPORT NamespaceRecord {
+    NamespaceRecord();
+    ~NamespaceRecord();
 
     int64 cache_id;
-    GURL origin;  // intentionally not normalized
+    GURL origin;
+    NamespaceType type;
     GURL namespace_url;
-    GURL fallback_entry_url;
+    GURL target_url;
   };
 
+  typedef std::vector<NamespaceRecord> NamespaceRecordVector;
+
   struct OnlineWhiteListRecord {
     OnlineWhiteListRecord() : cache_id(0) {}
 
     int64 cache_id;
     GURL namespace_url;
   };
 
   explicit AppCacheDatabase(const FilePath& path);
   ~AppCacheDatabase();
 
@@ skipping 39 matching lines @@
                      int additional_flags);
   bool FindResponseIdsForCacheAsVector(
       int64 cache_id, std::vector<int64>* response_ids) {
     return FindResponseIdsForCacheHelper(cache_id, response_ids, NULL);
   }
   bool FindResponseIdsForCacheAsSet(
       int64 cache_id, std::set<int64>* response_ids) {
     return FindResponseIdsForCacheHelper(cache_id, NULL, response_ids);
   }
 
-  bool FindFallbackNameSpacesForOrigin(
-      const GURL& origin, std::vector<FallbackNameSpaceRecord>* records);
-  bool FindFallbackNameSpacesForCache(
-      int64 cache_id, std::vector<FallbackNameSpaceRecord>* records);
-  bool InsertFallbackNameSpace(const FallbackNameSpaceRecord* record);
-  bool InsertFallbackNameSpaceRecords(
-      const std::vector<FallbackNameSpaceRecord>& records);
-  bool DeleteFallbackNameSpacesForCache(int64 cache_id);
+  bool FindNamespacesForOrigin(
+      const GURL& origin,
+      NamespaceRecordVector* intercepts,
+      NamespaceRecordVector* fallbacks);
+  bool FindNamespacesForCache(
+      int64 cache_id,
+      NamespaceRecordVector* intercepts,
+      std::vector<NamespaceRecord>* fallbacks);
+  bool InsertNamespaceRecords(
+      const NamespaceRecordVector& records);
+  bool InsertNamespace(const NamespaceRecord* record);
+  bool DeleteNamespacesForCache(int64 cache_id);
 
   bool FindOnlineWhiteListForCache(
       int64 cache_id, std::vector<OnlineWhiteListRecord>* records);
   bool InsertOnlineWhiteList(const OnlineWhiteListRecord* record);
   bool InsertOnlineWhiteListRecords(
       const std::vector<OnlineWhiteListRecord>& records);
   bool DeleteOnlineWhiteListForCache(int64 cache_id);
 
   bool GetDeletableResponseIds(std::vector<int64>* response_ids,
                                int64 max_rowid, int limit);
@@ skipping 17 matching lines @@
       const sql::StatementID& id, const char* sql, sql::Statement* statement);
 
   bool FindResponseIdsForCacheHelper(
       int64 cache_id, std::vector<int64>* ids_vector,
       std::set<int64>* ids_set);
 
   // Record retrieval helpers
   void ReadGroupRecord(const sql::Statement& statement, GroupRecord* record);
   void ReadCacheRecord(const sql::Statement& statement, CacheRecord* record);
   void ReadEntryRecord(const sql::Statement& statement, EntryRecord* record);
-  void ReadFallbackNameSpaceRecord(
-      const sql::Statement& statement, FallbackNameSpaceRecord* record);
+  void ReadNamespaceRecords(
+      sql::Statement* statement,
+      NamespaceRecordVector* intercepts,
+      NamespaceRecordVector* fallbacks);
+  void ReadNamespaceRecord(
+      const sql::Statement* statement, NamespaceRecord* record);
   void ReadOnlineWhiteListRecord(
       const sql::Statement& statement, OnlineWhiteListRecord* record);
 
   // Database creation
   bool LazyOpen(bool create_if_needed);
   bool EnsureDatabaseVersion();
   bool CreateSchema();
   bool UpgradeSchema();
 
   void ResetConnectionAndTables();
 
   // Deletes the existing database file and the entire directory containing
   // the database file including the disk cache in which response headers
   // and bodies are stored, and then creates a new database file.
   bool DeleteExistingAndCreateNewDatabase();
 
   FilePath db_file_path_;
   scoped_ptr<sql::Connection> db_;
   scoped_ptr<sql::MetaTable> meta_table_;
   bool is_disabled_;
   bool is_recreating_;
 
   FRIEND_TEST_ALL_PREFIXES(AppCacheDatabaseTest, CacheRecords);
   FRIEND_TEST_ALL_PREFIXES(AppCacheDatabaseTest, EntryRecords);
-  FRIEND_TEST_ALL_PREFIXES(AppCacheDatabaseTest, FallbackNameSpaceRecords);
+  FRIEND_TEST_ALL_PREFIXES(AppCacheDatabaseTest, NamespaceRecords);
   FRIEND_TEST_ALL_PREFIXES(AppCacheDatabaseTest, GroupRecords);
   FRIEND_TEST_ALL_PREFIXES(AppCacheDatabaseTest, LazyOpen);
   FRIEND_TEST_ALL_PREFIXES(AppCacheDatabaseTest, OnlineWhiteListRecords);
   FRIEND_TEST_ALL_PREFIXES(AppCacheDatabaseTest, ReCreate);
   FRIEND_TEST_ALL_PREFIXES(AppCacheDatabaseTest, DeletableResponseIds);
   FRIEND_TEST_ALL_PREFIXES(AppCacheDatabaseTest, OriginUsage);
+  FRIEND_TEST_ALL_PREFIXES(AppCacheDatabaseTest, UpgradeSchema3to4);
 
   DISALLOW_COPY_AND_ASSIGN(AppCacheDatabase);
 };
 
 }  // namespace appcache
 
 #endif  // WEBKIT_APPCACHE_APPCACHE_DATABASE_H_