1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
// 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_DATABASE_H_
#define WEBKIT_APPCACHE_APPCACHE_DATABASE_H_
#include <set>
#include <vector>
#include "base/basictypes.h"
#include "base/file_path.h"
#include "base/scoped_ptr.h"
#include "base/time.h"
#include "googleurl/src/gurl.h"
#include "testing/gtest/include/gtest/gtest_prod.h"
namespace sql {
class Connection;
class MetaTable;
class Statement;
class StatementID;
}
namespace appcache {
class AppCacheDatabase {
public:
struct GroupRecord {
int64 group_id;
GURL origin;
GURL manifest_url;
};
struct CacheRecord {
int64 cache_id;
int64 group_id;
bool online_wildcard;
base::TimeTicks update_time;
};
struct EntryRecord {
int64 cache_id;
GURL url;
int flags;
int64 response_id;
};
struct FallbackNameSpaceRecord {
int64 cache_id;
GURL origin; // intentionally not normalized
GURL namespace_url;
GURL fallback_entry_url;
};
struct OnlineWhiteListRecord {
int64 cache_id;
GURL namespace_url;
};
explicit AppCacheDatabase(const FilePath& path);
~AppCacheDatabase();
void CloseConnection();
bool FindOriginsWithGroups(std::set<GURL>* origins);
bool FindLastStorageIds(
int64* last_group_id, int64* last_cache_id, int64* last_response_id);
bool FindGroup(int64 group_id, GroupRecord* record);
bool FindGroupForManifestUrl(const GURL& manifest_url, GroupRecord* record);
bool FindGroupsForOrigin(
const GURL& origin, std::vector<GroupRecord>* records);
bool FindGroupForCache(int64 cache_id, GroupRecord* record);
bool InsertGroup(const GroupRecord* record);
bool DeleteGroup(int64 group_id);
bool FindCache(int64 cache_id, CacheRecord* record);
bool FindCacheForGroup(int64 group_id, CacheRecord* record);
bool InsertCache(const CacheRecord* record);
bool DeleteCache(int64 cache_id);
bool FindEntriesForCache(
int64 cache_id, std::vector<EntryRecord>* records);
bool FindEntriesForUrl(
const GURL& url, std::vector<EntryRecord>* records);
bool FindEntry(int64 cache_id, const GURL& url, EntryRecord* record);
bool InsertEntry(const EntryRecord* record);
bool InsertEntryRecords(
const std::vector<EntryRecord>& records);
bool DeleteEntriesForCache(int64 cache_id);
bool AddEntryFlags(const GURL& entry_url, int64 cache_id,
int additional_flags);
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 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);
// So our callers can wrap operations in transactions.
sql::Connection* db_connection() {
LazyOpen(true);
return db_.get();
}
private:
bool PrepareUniqueStatement(const char* sql, sql::Statement* statement);
bool PrepareCachedStatement(
const sql::StatementID& id, const char* sql, sql::Statement* statement);
// 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 ReadOnlineWhiteListRecord(
const sql::Statement& statement, OnlineWhiteListRecord* record);
// Database creation
bool LazyOpen(bool create_if_needed);
bool EnsureDatabaseVersion();
bool CreateSchema();
bool UpgradeSchema();
// 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 has_open_error_;
bool is_recreating_;
FRIEND_TEST(AppCacheDatabaseTest, CacheRecords);
FRIEND_TEST(AppCacheDatabaseTest, EntryRecords);
FRIEND_TEST(AppCacheDatabaseTest, FallbackNameSpaceRecords);
FRIEND_TEST(AppCacheDatabaseTest, GroupRecords);
FRIEND_TEST(AppCacheDatabaseTest, LazyOpen);
FRIEND_TEST(AppCacheDatabaseTest, OnlineWhiteListRecords);
FRIEND_TEST(AppCacheDatabaseTest, ReCreate);
DISALLOW_COPY_AND_ASSIGN(AppCacheDatabase);
};
} // namespace appcache
#endif // WEBKIT_APPCACHE_APPCACHE_DATABASE_H_
|
