Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(174)

Side by Side Diff: webkit/browser/appcache/appcache_database.cc

Issue 344493002: Move all remaining appcache-related code to content namespace (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: rebase Created 6 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
(Empty)
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "webkit/browser/appcache/appcache_database.h"
6
7 #include "base/auto_reset.h"
8 #include "base/bind.h"
9 #include "base/command_line.h"
10 #include "base/file_util.h"
11 #include "base/logging.h"
12 #include "base/strings/utf_string_conversions.h"
13 #include "sql/connection.h"
14 #include "sql/error_delegate_util.h"
15 #include "sql/meta_table.h"
16 #include "sql/statement.h"
17 #include "sql/transaction.h"
18 #include "webkit/browser/appcache/appcache_entry.h"
19 #include "webkit/browser/appcache/appcache_histograms.h"
20
21 namespace appcache {
22
23 // Schema -------------------------------------------------------------------
24 namespace {
25
26 #if defined(APPCACHE_USE_SIMPLE_CACHE)
27 const int kCurrentVersion = 6;
28 const int kCompatibleVersion = 6;
29 #else
30 const int kCurrentVersion = 5;
31 const int kCompatibleVersion = 5;
32 #endif
33
34 // A mechanism to run experiments that may affect in data being persisted
35 // in different ways such that when the experiment is toggled on/off via
36 // cmd line flags, the database gets reset. The active flags are stored at
37 // the time of database creation and compared when reopening. If different
38 // the database is reset.
39 const char kExperimentFlagsKey[] = "ExperimentFlags";
40
41 const char kGroupsTable[] = "Groups";
42 const char kCachesTable[] = "Caches";
43 const char kEntriesTable[] = "Entries";
44 const char kNamespacesTable[] = "Namespaces";
45 const char kOnlineWhiteListsTable[] = "OnlineWhiteLists";
46 const char kDeletableResponseIdsTable[] = "DeletableResponseIds";
47
48 struct TableInfo {
49 const char* table_name;
50 const char* columns;
51 };
52
53 struct IndexInfo {
54 const char* index_name;
55 const char* table_name;
56 const char* columns;
57 bool unique;
58 };
59
60 const TableInfo kTables[] = {
61 { kGroupsTable,
62 "(group_id INTEGER PRIMARY KEY,"
63 " origin TEXT,"
64 " manifest_url TEXT,"
65 " creation_time INTEGER,"
66 " last_access_time INTEGER)" },
67
68 { kCachesTable,
69 "(cache_id INTEGER PRIMARY KEY,"
70 " group_id INTEGER,"
71 " online_wildcard INTEGER CHECK(online_wildcard IN (0, 1)),"
72 " update_time INTEGER,"
73 " cache_size INTEGER)" }, // intentionally not normalized
74
75 { kEntriesTable,
76 "(cache_id INTEGER,"
77 " url TEXT,"
78 " flags INTEGER,"
79 " response_id INTEGER,"
80 " response_size INTEGER)" },
81
82 { kNamespacesTable,
83 "(cache_id INTEGER,"
84 " origin TEXT," // intentionally not normalized
85 " type INTEGER,"
86 " namespace_url TEXT,"
87 " target_url TEXT,"
88 " is_pattern INTEGER CHECK(is_pattern IN (0, 1)))" },
89
90 { kOnlineWhiteListsTable,
91 "(cache_id INTEGER,"
92 " namespace_url TEXT,"
93 " is_pattern INTEGER CHECK(is_pattern IN (0, 1)))" },
94
95 { kDeletableResponseIdsTable,
96 "(response_id INTEGER NOT NULL)" },
97 };
98
99 const IndexInfo kIndexes[] = {
100 { "GroupsOriginIndex",
101 kGroupsTable,
102 "(origin)",
103 false },
104
105 { "GroupsManifestIndex",
106 kGroupsTable,
107 "(manifest_url)",
108 true },
109
110 { "CachesGroupIndex",
111 kCachesTable,
112 "(group_id)",
113 false },
114
115 { "EntriesCacheIndex",
116 kEntriesTable,
117 "(cache_id)",
118 false },
119
120 { "EntriesCacheAndUrlIndex",
121 kEntriesTable,
122 "(cache_id, url)",
123 true },
124
125 { "EntriesResponseIdIndex",
126 kEntriesTable,
127 "(response_id)",
128 true },
129
130 { "NamespacesCacheIndex",
131 kNamespacesTable,
132 "(cache_id)",
133 false },
134
135 { "NamespacesOriginIndex",
136 kNamespacesTable,
137 "(origin)",
138 false },
139
140 { "NamespacesCacheAndUrlIndex",
141 kNamespacesTable,
142 "(cache_id, namespace_url)",
143 true },
144
145 { "OnlineWhiteListCacheIndex",
146 kOnlineWhiteListsTable,
147 "(cache_id)",
148 false },
149
150 { "DeletableResponsesIdIndex",
151 kDeletableResponseIdsTable,
152 "(response_id)",
153 true },
154 };
155
156 const int kTableCount = ARRAYSIZE_UNSAFE(kTables);
157 const int kIndexCount = ARRAYSIZE_UNSAFE(kIndexes);
158
159 bool CreateTable(sql::Connection* db, const TableInfo& info) {
160 std::string sql("CREATE TABLE ");
161 sql += info.table_name;
162 sql += info.columns;
163 return db->Execute(sql.c_str());
164 }
165
166 bool CreateIndex(sql::Connection* db, const IndexInfo& info) {
167 std::string sql;
168 if (info.unique)
169 sql += "CREATE UNIQUE INDEX ";
170 else
171 sql += "CREATE INDEX ";
172 sql += info.index_name;
173 sql += " ON ";
174 sql += info.table_name;
175 sql += info.columns;
176 return db->Execute(sql.c_str());
177 }
178
179 std::string GetActiveExperimentFlags() {
180 if (CommandLine::ForCurrentProcess()->HasSwitch(kEnableExecutableHandlers))
181 return std::string("executableHandlersEnabled");
182 return std::string();
183 }
184
185 } // anon namespace
186
187 // AppCacheDatabase ----------------------------------------------------------
188
189 AppCacheDatabase::GroupRecord::GroupRecord()
190 : group_id(0) {
191 }
192
193 AppCacheDatabase::GroupRecord::~GroupRecord() {
194 }
195
196 AppCacheDatabase::NamespaceRecord::NamespaceRecord()
197 : cache_id(0) {
198 }
199
200 AppCacheDatabase::NamespaceRecord::~NamespaceRecord() {
201 }
202
203
204 AppCacheDatabase::AppCacheDatabase(const base::FilePath& path)
205 : db_file_path_(path),
206 is_disabled_(false),
207 is_recreating_(false),
208 was_corruption_detected_(false) {
209 }
210
211 AppCacheDatabase::~AppCacheDatabase() {
212 }
213
214 void AppCacheDatabase::Disable() {
215 VLOG(1) << "Disabling appcache database.";
216 is_disabled_ = true;
217 ResetConnectionAndTables();
218 }
219
220 int64 AppCacheDatabase::GetOriginUsage(const GURL& origin) {
221 std::vector<CacheRecord> records;
222 if (!FindCachesForOrigin(origin, &records))
223 return 0;
224
225 int64 origin_usage = 0;
226 std::vector<CacheRecord>::const_iterator iter = records.begin();
227 while (iter != records.end()) {
228 origin_usage += iter->cache_size;
229 ++iter;
230 }
231 return origin_usage;
232 }
233
234 bool AppCacheDatabase::GetAllOriginUsage(std::map<GURL, int64>* usage_map) {
235 std::set<GURL> origins;
236 if (!FindOriginsWithGroups(&origins))
237 return false;
238 for (std::set<GURL>::const_iterator origin = origins.begin();
239 origin != origins.end(); ++origin) {
240 (*usage_map)[*origin] = GetOriginUsage(*origin);
241 }
242 return true;
243 }
244
245 bool AppCacheDatabase::FindOriginsWithGroups(std::set<GURL>* origins) {
246 DCHECK(origins && origins->empty());
247 if (!LazyOpen(false))
248 return false;
249
250 const char* kSql =
251 "SELECT DISTINCT(origin) FROM Groups";
252
253 sql::Statement statement(db_->GetUniqueStatement(kSql));
254
255 while (statement.Step())
256 origins->insert(GURL(statement.ColumnString(0)));
257
258 return statement.Succeeded();
259 }
260
261 bool AppCacheDatabase::FindLastStorageIds(
262 int64* last_group_id, int64* last_cache_id, int64* last_response_id,
263 int64* last_deletable_response_rowid) {
264 DCHECK(last_group_id && last_cache_id && last_response_id &&
265 last_deletable_response_rowid);
266
267 *last_group_id = 0;
268 *last_cache_id = 0;
269 *last_response_id = 0;
270 *last_deletable_response_rowid = 0;
271
272 if (!LazyOpen(false))
273 return false;
274
275 const char* kMaxGroupIdSql = "SELECT MAX(group_id) FROM Groups";
276 const char* kMaxCacheIdSql = "SELECT MAX(cache_id) FROM Caches";
277 const char* kMaxResponseIdFromEntriesSql =
278 "SELECT MAX(response_id) FROM Entries";
279 const char* kMaxResponseIdFromDeletablesSql =
280 "SELECT MAX(response_id) FROM DeletableResponseIds";
281 const char* kMaxDeletableResponseRowIdSql =
282 "SELECT MAX(rowid) FROM DeletableResponseIds";
283 int64 max_group_id;
284 int64 max_cache_id;
285 int64 max_response_id_from_entries;
286 int64 max_response_id_from_deletables;
287 int64 max_deletable_response_rowid;
288 if (!RunUniqueStatementWithInt64Result(kMaxGroupIdSql, &max_group_id) ||
289 !RunUniqueStatementWithInt64Result(kMaxCacheIdSql, &max_cache_id) ||
290 !RunUniqueStatementWithInt64Result(kMaxResponseIdFromEntriesSql,
291 &max_response_id_from_entries) ||
292 !RunUniqueStatementWithInt64Result(kMaxResponseIdFromDeletablesSql,
293 &max_response_id_from_deletables) ||
294 !RunUniqueStatementWithInt64Result(kMaxDeletableResponseRowIdSql,
295 &max_deletable_response_rowid)) {
296 return false;
297 }
298
299 *last_group_id = max_group_id;
300 *last_cache_id = max_cache_id;
301 *last_response_id = std::max(max_response_id_from_entries,
302 max_response_id_from_deletables);
303 *last_deletable_response_rowid = max_deletable_response_rowid;
304 return true;
305 }
306
307 bool AppCacheDatabase::FindGroup(int64 group_id, GroupRecord* record) {
308 DCHECK(record);
309 if (!LazyOpen(false))
310 return false;
311
312 const char* kSql =
313 "SELECT group_id, origin, manifest_url,"
314 " creation_time, last_access_time"
315 " FROM Groups WHERE group_id = ?";
316
317 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
318
319 statement.BindInt64(0, group_id);
320 if (!statement.Step())
321 return false;
322
323 ReadGroupRecord(statement, record);
324 DCHECK(record->group_id == group_id);
325 return true;
326 }
327
328 bool AppCacheDatabase::FindGroupForManifestUrl(
329 const GURL& manifest_url, GroupRecord* record) {
330 DCHECK(record);
331 if (!LazyOpen(false))
332 return false;
333
334 const char* kSql =
335 "SELECT group_id, origin, manifest_url,"
336 " creation_time, last_access_time"
337 " FROM Groups WHERE manifest_url = ?";
338
339 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
340 statement.BindString(0, manifest_url.spec());
341
342 if (!statement.Step())
343 return false;
344
345 ReadGroupRecord(statement, record);
346 DCHECK(record->manifest_url == manifest_url);
347 return true;
348 }
349
350 bool AppCacheDatabase::FindGroupsForOrigin(
351 const GURL& origin, std::vector<GroupRecord>* records) {
352 DCHECK(records && records->empty());
353 if (!LazyOpen(false))
354 return false;
355
356 const char* kSql =
357 "SELECT group_id, origin, manifest_url,"
358 " creation_time, last_access_time"
359 " FROM Groups WHERE origin = ?";
360
361 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
362 statement.BindString(0, origin.spec());
363
364 while (statement.Step()) {
365 records->push_back(GroupRecord());
366 ReadGroupRecord(statement, &records->back());
367 DCHECK(records->back().origin == origin);
368 }
369
370 return statement.Succeeded();
371 }
372
373 bool AppCacheDatabase::FindGroupForCache(int64 cache_id, GroupRecord* record) {
374 DCHECK(record);
375 if (!LazyOpen(false))
376 return false;
377
378 const char* kSql =
379 "SELECT g.group_id, g.origin, g.manifest_url,"
380 " g.creation_time, g.last_access_time"
381 " FROM Groups g, Caches c"
382 " WHERE c.cache_id = ? AND c.group_id = g.group_id";
383
384 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
385 statement.BindInt64(0, cache_id);
386
387 if (!statement.Step())
388 return false;
389
390 ReadGroupRecord(statement, record);
391 return true;
392 }
393
394 bool AppCacheDatabase::UpdateGroupLastAccessTime(
395 int64 group_id, base::Time time) {
396 if (!LazyOpen(true))
397 return false;
398
399 const char* kSql =
400 "UPDATE Groups SET last_access_time = ? WHERE group_id = ?";
401
402 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
403 statement.BindInt64(0, time.ToInternalValue());
404 statement.BindInt64(1, group_id);
405
406 return statement.Run() && db_->GetLastChangeCount();
407 }
408
409 bool AppCacheDatabase::InsertGroup(const GroupRecord* record) {
410 if (!LazyOpen(true))
411 return false;
412
413 const char* kSql =
414 "INSERT INTO Groups"
415 " (group_id, origin, manifest_url, creation_time, last_access_time)"
416 " VALUES(?, ?, ?, ?, ?)";
417
418 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
419 statement.BindInt64(0, record->group_id);
420 statement.BindString(1, record->origin.spec());
421 statement.BindString(2, record->manifest_url.spec());
422 statement.BindInt64(3, record->creation_time.ToInternalValue());
423 statement.BindInt64(4, record->last_access_time.ToInternalValue());
424
425 return statement.Run();
426 }
427
428 bool AppCacheDatabase::DeleteGroup(int64 group_id) {
429 if (!LazyOpen(false))
430 return false;
431
432 const char* kSql =
433 "DELETE FROM Groups WHERE group_id = ?";
434
435 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
436 statement.BindInt64(0, group_id);
437
438 return statement.Run();
439 }
440
441 bool AppCacheDatabase::FindCache(int64 cache_id, CacheRecord* record) {
442 DCHECK(record);
443 if (!LazyOpen(false))
444 return false;
445
446 const char* kSql =
447 "SELECT cache_id, group_id, online_wildcard, update_time, cache_size"
448 " FROM Caches WHERE cache_id = ?";
449
450 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
451 statement.BindInt64(0, cache_id);
452
453 if (!statement.Step())
454 return false;
455
456 ReadCacheRecord(statement, record);
457 return true;
458 }
459
460 bool AppCacheDatabase::FindCacheForGroup(int64 group_id, CacheRecord* record) {
461 DCHECK(record);
462 if (!LazyOpen(false))
463 return false;
464
465 const char* kSql =
466 "SELECT cache_id, group_id, online_wildcard, update_time, cache_size"
467 " FROM Caches WHERE group_id = ?";
468
469 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
470 statement.BindInt64(0, group_id);
471
472 if (!statement.Step())
473 return false;
474
475 ReadCacheRecord(statement, record);
476 return true;
477 }
478
479 bool AppCacheDatabase::FindCachesForOrigin(
480 const GURL& origin, std::vector<CacheRecord>* records) {
481 DCHECK(records);
482 std::vector<GroupRecord> group_records;
483 if (!FindGroupsForOrigin(origin, &group_records))
484 return false;
485
486 CacheRecord cache_record;
487 std::vector<GroupRecord>::const_iterator iter = group_records.begin();
488 while (iter != group_records.end()) {
489 if (FindCacheForGroup(iter->group_id, &cache_record))
490 records->push_back(cache_record);
491 ++iter;
492 }
493 return true;
494 }
495
496 bool AppCacheDatabase::InsertCache(const CacheRecord* record) {
497 if (!LazyOpen(true))
498 return false;
499
500 const char* kSql =
501 "INSERT INTO Caches (cache_id, group_id, online_wildcard,"
502 " update_time, cache_size)"
503 " VALUES(?, ?, ?, ?, ?)";
504
505 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
506 statement.BindInt64(0, record->cache_id);
507 statement.BindInt64(1, record->group_id);
508 statement.BindBool(2, record->online_wildcard);
509 statement.BindInt64(3, record->update_time.ToInternalValue());
510 statement.BindInt64(4, record->cache_size);
511
512 return statement.Run();
513 }
514
515 bool AppCacheDatabase::DeleteCache(int64 cache_id) {
516 if (!LazyOpen(false))
517 return false;
518
519 const char* kSql =
520 "DELETE FROM Caches WHERE cache_id = ?";
521
522 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
523 statement.BindInt64(0, cache_id);
524
525 return statement.Run();
526 }
527
528 bool AppCacheDatabase::FindEntriesForCache(
529 int64 cache_id, std::vector<EntryRecord>* records) {
530 DCHECK(records && records->empty());
531 if (!LazyOpen(false))
532 return false;
533
534 const char* kSql =
535 "SELECT cache_id, url, flags, response_id, response_size FROM Entries"
536 " WHERE cache_id = ?";
537
538 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
539 statement.BindInt64(0, cache_id);
540
541 while (statement.Step()) {
542 records->push_back(EntryRecord());
543 ReadEntryRecord(statement, &records->back());
544 DCHECK(records->back().cache_id == cache_id);
545 }
546
547 return statement.Succeeded();
548 }
549
550 bool AppCacheDatabase::FindEntriesForUrl(
551 const GURL& url, std::vector<EntryRecord>* records) {
552 DCHECK(records && records->empty());
553 if (!LazyOpen(false))
554 return false;
555
556 const char* kSql =
557 "SELECT cache_id, url, flags, response_id, response_size FROM Entries"
558 " WHERE url = ?";
559
560 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
561 statement.BindString(0, url.spec());
562
563 while (statement.Step()) {
564 records->push_back(EntryRecord());
565 ReadEntryRecord(statement, &records->back());
566 DCHECK(records->back().url == url);
567 }
568
569 return statement.Succeeded();
570 }
571
572 bool AppCacheDatabase::FindEntry(
573 int64 cache_id, const GURL& url, EntryRecord* record) {
574 DCHECK(record);
575 if (!LazyOpen(false))
576 return false;
577
578 const char* kSql =
579 "SELECT cache_id, url, flags, response_id, response_size FROM Entries"
580 " WHERE cache_id = ? AND url = ?";
581
582 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
583 statement.BindInt64(0, cache_id);
584 statement.BindString(1, url.spec());
585
586 if (!statement.Step())
587 return false;
588
589 ReadEntryRecord(statement, record);
590 DCHECK(record->cache_id == cache_id);
591 DCHECK(record->url == url);
592 return true;
593 }
594
595 bool AppCacheDatabase::InsertEntry(const EntryRecord* record) {
596 if (!LazyOpen(true))
597 return false;
598
599 const char* kSql =
600 "INSERT INTO Entries (cache_id, url, flags, response_id, response_size)"
601 " VALUES(?, ?, ?, ?, ?)";
602
603 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
604 statement.BindInt64(0, record->cache_id);
605 statement.BindString(1, record->url.spec());
606 statement.BindInt(2, record->flags);
607 statement.BindInt64(3, record->response_id);
608 statement.BindInt64(4, record->response_size);
609
610 return statement.Run();
611 }
612
613 bool AppCacheDatabase::InsertEntryRecords(
614 const std::vector<EntryRecord>& records) {
615 if (records.empty())
616 return true;
617 sql::Transaction transaction(db_.get());
618 if (!transaction.Begin())
619 return false;
620 std::vector<EntryRecord>::const_iterator iter = records.begin();
621 while (iter != records.end()) {
622 if (!InsertEntry(&(*iter)))
623 return false;
624 ++iter;
625 }
626 return transaction.Commit();
627 }
628
629 bool AppCacheDatabase::DeleteEntriesForCache(int64 cache_id) {
630 if (!LazyOpen(false))
631 return false;
632
633 const char* kSql =
634 "DELETE FROM Entries WHERE cache_id = ?";
635
636 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
637 statement.BindInt64(0, cache_id);
638
639 return statement.Run();
640 }
641
642 bool AppCacheDatabase::AddEntryFlags(
643 const GURL& entry_url, int64 cache_id, int additional_flags) {
644 if (!LazyOpen(false))
645 return false;
646
647 const char* kSql =
648 "UPDATE Entries SET flags = flags | ? WHERE cache_id = ? AND url = ?";
649
650 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
651 statement.BindInt(0, additional_flags);
652 statement.BindInt64(1, cache_id);
653 statement.BindString(2, entry_url.spec());
654
655 return statement.Run() && db_->GetLastChangeCount();
656 }
657
658 bool AppCacheDatabase::FindNamespacesForOrigin(
659 const GURL& origin,
660 std::vector<NamespaceRecord>* intercepts,
661 std::vector<NamespaceRecord>* fallbacks) {
662 DCHECK(intercepts && intercepts->empty());
663 DCHECK(fallbacks && fallbacks->empty());
664 if (!LazyOpen(false))
665 return false;
666
667 const char* kSql =
668 "SELECT cache_id, origin, type, namespace_url, target_url, is_pattern"
669 " FROM Namespaces WHERE origin = ?";
670
671 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
672 statement.BindString(0, origin.spec());
673
674 ReadNamespaceRecords(&statement, intercepts, fallbacks);
675
676 return statement.Succeeded();
677 }
678
679 bool AppCacheDatabase::FindNamespacesForCache(
680 int64 cache_id,
681 std::vector<NamespaceRecord>* intercepts,
682 std::vector<NamespaceRecord>* fallbacks) {
683 DCHECK(intercepts && intercepts->empty());
684 DCHECK(fallbacks && fallbacks->empty());
685 if (!LazyOpen(false))
686 return false;
687
688 const char* kSql =
689 "SELECT cache_id, origin, type, namespace_url, target_url, is_pattern"
690 " FROM Namespaces WHERE cache_id = ?";
691
692 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
693 statement.BindInt64(0, cache_id);
694
695 ReadNamespaceRecords(&statement, intercepts, fallbacks);
696
697 return statement.Succeeded();
698 }
699
700 bool AppCacheDatabase::InsertNamespace(
701 const NamespaceRecord* record) {
702 if (!LazyOpen(true))
703 return false;
704
705 const char* kSql =
706 "INSERT INTO Namespaces"
707 " (cache_id, origin, type, namespace_url, target_url, is_pattern)"
708 " VALUES (?, ?, ?, ?, ?, ?)";
709
710 // Note: quick and dirty storage for the 'executable' bit w/o changing
711 // schemas, we use the high bit of 'type' field.
712 int type_with_executable_bit = record->namespace_.type;
713 if (record->namespace_.is_executable) {
714 type_with_executable_bit |= 0x8000000;
715 DCHECK(CommandLine::ForCurrentProcess()->HasSwitch(
716 kEnableExecutableHandlers));
717 }
718
719 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
720 statement.BindInt64(0, record->cache_id);
721 statement.BindString(1, record->origin.spec());
722 statement.BindInt(2, type_with_executable_bit);
723 statement.BindString(3, record->namespace_.namespace_url.spec());
724 statement.BindString(4, record->namespace_.target_url.spec());
725 statement.BindBool(5, record->namespace_.is_pattern);
726 return statement.Run();
727 }
728
729 bool AppCacheDatabase::InsertNamespaceRecords(
730 const std::vector<NamespaceRecord>& records) {
731 if (records.empty())
732 return true;
733 sql::Transaction transaction(db_.get());
734 if (!transaction.Begin())
735 return false;
736 std::vector<NamespaceRecord>::const_iterator iter = records.begin();
737 while (iter != records.end()) {
738 if (!InsertNamespace(&(*iter)))
739 return false;
740 ++iter;
741 }
742 return transaction.Commit();
743 }
744
745 bool AppCacheDatabase::DeleteNamespacesForCache(int64 cache_id) {
746 if (!LazyOpen(false))
747 return false;
748
749 const char* kSql =
750 "DELETE FROM Namespaces WHERE cache_id = ?";
751
752 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
753 statement.BindInt64(0, cache_id);
754
755 return statement.Run();
756 }
757
758 bool AppCacheDatabase::FindOnlineWhiteListForCache(
759 int64 cache_id, std::vector<OnlineWhiteListRecord>* records) {
760 DCHECK(records && records->empty());
761 if (!LazyOpen(false))
762 return false;
763
764 const char* kSql =
765 "SELECT cache_id, namespace_url, is_pattern FROM OnlineWhiteLists"
766 " WHERE cache_id = ?";
767
768 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
769 statement.BindInt64(0, cache_id);
770
771 while (statement.Step()) {
772 records->push_back(OnlineWhiteListRecord());
773 this->ReadOnlineWhiteListRecord(statement, &records->back());
774 DCHECK(records->back().cache_id == cache_id);
775 }
776 return statement.Succeeded();
777 }
778
779 bool AppCacheDatabase::InsertOnlineWhiteList(
780 const OnlineWhiteListRecord* record) {
781 if (!LazyOpen(true))
782 return false;
783
784 const char* kSql =
785 "INSERT INTO OnlineWhiteLists (cache_id, namespace_url, is_pattern)"
786 " VALUES (?, ?, ?)";
787
788 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
789 statement.BindInt64(0, record->cache_id);
790 statement.BindString(1, record->namespace_url.spec());
791 statement.BindBool(2, record->is_pattern);
792
793 return statement.Run();
794 }
795
796 bool AppCacheDatabase::InsertOnlineWhiteListRecords(
797 const std::vector<OnlineWhiteListRecord>& records) {
798 if (records.empty())
799 return true;
800 sql::Transaction transaction(db_.get());
801 if (!transaction.Begin())
802 return false;
803 std::vector<OnlineWhiteListRecord>::const_iterator iter = records.begin();
804 while (iter != records.end()) {
805 if (!InsertOnlineWhiteList(&(*iter)))
806 return false;
807 ++iter;
808 }
809 return transaction.Commit();
810 }
811
812 bool AppCacheDatabase::DeleteOnlineWhiteListForCache(int64 cache_id) {
813 if (!LazyOpen(false))
814 return false;
815
816 const char* kSql =
817 "DELETE FROM OnlineWhiteLists WHERE cache_id = ?";
818
819 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
820 statement.BindInt64(0, cache_id);
821
822 return statement.Run();
823 }
824
825 bool AppCacheDatabase::GetDeletableResponseIds(
826 std::vector<int64>* response_ids, int64 max_rowid, int limit) {
827 if (!LazyOpen(false))
828 return false;
829
830 const char* kSql =
831 "SELECT response_id FROM DeletableResponseIds "
832 " WHERE rowid <= ?"
833 " LIMIT ?";
834
835 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
836 statement.BindInt64(0, max_rowid);
837 statement.BindInt64(1, limit);
838
839 while (statement.Step())
840 response_ids->push_back(statement.ColumnInt64(0));
841 return statement.Succeeded();
842 }
843
844 bool AppCacheDatabase::InsertDeletableResponseIds(
845 const std::vector<int64>& response_ids) {
846 const char* kSql =
847 "INSERT INTO DeletableResponseIds (response_id) VALUES (?)";
848 return RunCachedStatementWithIds(SQL_FROM_HERE, kSql, response_ids);
849 }
850
851 bool AppCacheDatabase::DeleteDeletableResponseIds(
852 const std::vector<int64>& response_ids) {
853 const char* kSql =
854 "DELETE FROM DeletableResponseIds WHERE response_id = ?";
855 return RunCachedStatementWithIds(SQL_FROM_HERE, kSql, response_ids);
856 }
857
858 bool AppCacheDatabase::RunCachedStatementWithIds(
859 const sql::StatementID& statement_id, const char* sql,
860 const std::vector<int64>& ids) {
861 DCHECK(sql);
862 if (!LazyOpen(true))
863 return false;
864
865 sql::Transaction transaction(db_.get());
866 if (!transaction.Begin())
867 return false;
868
869 sql::Statement statement(db_->GetCachedStatement(statement_id, sql));
870
871 std::vector<int64>::const_iterator iter = ids.begin();
872 while (iter != ids.end()) {
873 statement.BindInt64(0, *iter);
874 if (!statement.Run())
875 return false;
876 statement.Reset(true);
877 ++iter;
878 }
879
880 return transaction.Commit();
881 }
882
883 bool AppCacheDatabase::RunUniqueStatementWithInt64Result(
884 const char* sql, int64* result) {
885 DCHECK(sql);
886 sql::Statement statement(db_->GetUniqueStatement(sql));
887 if (!statement.Step()) {
888 return false;
889 }
890 *result = statement.ColumnInt64(0);
891 return true;
892 }
893
894 bool AppCacheDatabase::FindResponseIdsForCacheHelper(
895 int64 cache_id, std::vector<int64>* ids_vector,
896 std::set<int64>* ids_set) {
897 DCHECK(ids_vector || ids_set);
898 DCHECK(!(ids_vector && ids_set));
899 if (!LazyOpen(false))
900 return false;
901
902 const char* kSql =
903 "SELECT response_id FROM Entries WHERE cache_id = ?";
904
905 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
906
907 statement.BindInt64(0, cache_id);
908 while (statement.Step()) {
909 int64 id = statement.ColumnInt64(0);
910 if (ids_set)
911 ids_set->insert(id);
912 else
913 ids_vector->push_back(id);
914 }
915
916 return statement.Succeeded();
917 }
918
919 void AppCacheDatabase::ReadGroupRecord(
920 const sql::Statement& statement, GroupRecord* record) {
921 record->group_id = statement.ColumnInt64(0);
922 record->origin = GURL(statement.ColumnString(1));
923 record->manifest_url = GURL(statement.ColumnString(2));
924 record->creation_time =
925 base::Time::FromInternalValue(statement.ColumnInt64(3));
926 record->last_access_time =
927 base::Time::FromInternalValue(statement.ColumnInt64(4));
928 }
929
930 void AppCacheDatabase::ReadCacheRecord(
931 const sql::Statement& statement, CacheRecord* record) {
932 record->cache_id = statement.ColumnInt64(0);
933 record->group_id = statement.ColumnInt64(1);
934 record->online_wildcard = statement.ColumnBool(2);
935 record->update_time =
936 base::Time::FromInternalValue(statement.ColumnInt64(3));
937 record->cache_size = statement.ColumnInt64(4);
938 }
939
940 void AppCacheDatabase::ReadEntryRecord(
941 const sql::Statement& statement, EntryRecord* record) {
942 record->cache_id = statement.ColumnInt64(0);
943 record->url = GURL(statement.ColumnString(1));
944 record->flags = statement.ColumnInt(2);
945 record->response_id = statement.ColumnInt64(3);
946 record->response_size = statement.ColumnInt64(4);
947 }
948
949 void AppCacheDatabase::ReadNamespaceRecords(
950 sql::Statement* statement,
951 NamespaceRecordVector* intercepts,
952 NamespaceRecordVector* fallbacks) {
953 while (statement->Step()) {
954 AppCacheNamespaceType type = static_cast<AppCacheNamespaceType>(
955 statement->ColumnInt(2));
956 NamespaceRecordVector* records =
957 (type == APPCACHE_FALLBACK_NAMESPACE) ? fallbacks : intercepts;
958 records->push_back(NamespaceRecord());
959 ReadNamespaceRecord(statement, &records->back());
960 }
961 }
962
963 void AppCacheDatabase::ReadNamespaceRecord(
964 const sql::Statement* statement, NamespaceRecord* record) {
965 record->cache_id = statement->ColumnInt64(0);
966 record->origin = GURL(statement->ColumnString(1));
967 int type_with_executable_bit = statement->ColumnInt(2);
968 record->namespace_.namespace_url = GURL(statement->ColumnString(3));
969 record->namespace_.target_url = GURL(statement->ColumnString(4));
970 record->namespace_.is_pattern = statement->ColumnBool(5);
971
972 // Note: quick and dirty storage for the 'executable' bit w/o changing
973 // schemas, we use the high bit of 'type' field.
974 record->namespace_.type = static_cast<AppCacheNamespaceType>
975 (type_with_executable_bit & 0x7ffffff);
976 record->namespace_.is_executable =
977 (type_with_executable_bit & 0x80000000) != 0;
978 DCHECK(!record->namespace_.is_executable ||
979 CommandLine::ForCurrentProcess()->HasSwitch(kEnableExecutableHandlers));
980 }
981
982 void AppCacheDatabase::ReadOnlineWhiteListRecord(
983 const sql::Statement& statement, OnlineWhiteListRecord* record) {
984 record->cache_id = statement.ColumnInt64(0);
985 record->namespace_url = GURL(statement.ColumnString(1));
986 record->is_pattern = statement.ColumnBool(2);
987 }
988
989 bool AppCacheDatabase::LazyOpen(bool create_if_needed) {
990 if (db_)
991 return true;
992
993 // If we tried and failed once, don't try again in the same session
994 // to avoid creating an incoherent mess on disk.
995 if (is_disabled_)
996 return false;
997
998 // Avoid creating a database at all if we can.
999 bool use_in_memory_db = db_file_path_.empty();
1000 if (!create_if_needed &&
1001 (use_in_memory_db || !base::PathExists(db_file_path_))) {
1002 return false;
1003 }
1004
1005 db_.reset(new sql::Connection);
1006 meta_table_.reset(new sql::MetaTable);
1007
1008 db_->set_histogram_tag("AppCache");
1009
1010 bool opened = false;
1011 if (use_in_memory_db) {
1012 opened = db_->OpenInMemory();
1013 } else if (!base::CreateDirectory(db_file_path_.DirName())) {
1014 LOG(ERROR) << "Failed to create appcache directory.";
1015 } else {
1016 opened = db_->Open(db_file_path_);
1017 if (opened)
1018 db_->Preload();
1019 }
1020
1021 if (!opened || !db_->QuickIntegrityCheck() || !EnsureDatabaseVersion()) {
1022 LOG(ERROR) << "Failed to open the appcache database.";
1023 AppCacheHistograms::CountInitResult(
1024 AppCacheHistograms::SQL_DATABASE_ERROR);
1025
1026 // We're unable to open the database. This is a fatal error
1027 // which we can't recover from. We try to handle it by deleting
1028 // the existing appcache data and starting with a clean slate in
1029 // this browser session.
1030 if (!use_in_memory_db && DeleteExistingAndCreateNewDatabase())
1031 return true;
1032
1033 Disable();
1034 return false;
1035 }
1036
1037 AppCacheHistograms::CountInitResult(AppCacheHistograms::INIT_OK);
1038 was_corruption_detected_ = false;
1039 db_->set_error_callback(
1040 base::Bind(&AppCacheDatabase::OnDatabaseError, base::Unretained(this)));
1041 return true;
1042 }
1043
1044 bool AppCacheDatabase::EnsureDatabaseVersion() {
1045 if (!sql::MetaTable::DoesTableExist(db_.get()))
1046 return CreateSchema();
1047
1048 if (!meta_table_->Init(db_.get(), kCurrentVersion, kCompatibleVersion))
1049 return false;
1050
1051 if (meta_table_->GetCompatibleVersionNumber() > kCurrentVersion) {
1052 LOG(WARNING) << "AppCache database is too new.";
1053 return false;
1054 }
1055
1056 std::string stored_flags;
1057 meta_table_->GetValue(kExperimentFlagsKey, &stored_flags);
1058 if (stored_flags != GetActiveExperimentFlags())
1059 return false;
1060
1061 if (meta_table_->GetVersionNumber() < kCurrentVersion)
1062 return UpgradeSchema();
1063
1064 #ifndef NDEBUG
1065 DCHECK(sql::MetaTable::DoesTableExist(db_.get()));
1066 for (int i = 0; i < kTableCount; ++i) {
1067 DCHECK(db_->DoesTableExist(kTables[i].table_name));
1068 }
1069 for (int i = 0; i < kIndexCount; ++i) {
1070 DCHECK(db_->DoesIndexExist(kIndexes[i].index_name));
1071 }
1072 #endif
1073
1074 return true;
1075 }
1076
1077 bool AppCacheDatabase::CreateSchema() {
1078 sql::Transaction transaction(db_.get());
1079 if (!transaction.Begin())
1080 return false;
1081
1082 if (!meta_table_->Init(db_.get(), kCurrentVersion, kCompatibleVersion))
1083 return false;
1084
1085 if (!meta_table_->SetValue(kExperimentFlagsKey,
1086 GetActiveExperimentFlags())) {
1087 return false;
1088 }
1089
1090 for (int i = 0; i < kTableCount; ++i) {
1091 if (!CreateTable(db_.get(), kTables[i]))
1092 return false;
1093 }
1094
1095 for (int i = 0; i < kIndexCount; ++i) {
1096 if (!CreateIndex(db_.get(), kIndexes[i]))
1097 return false;
1098 }
1099
1100 return transaction.Commit();
1101 }
1102
1103 bool AppCacheDatabase::UpgradeSchema() {
1104 #if defined(APPCACHE_USE_SIMPLE_CACHE)
1105 return DeleteExistingAndCreateNewDatabase();
1106 #else
1107 if (meta_table_->GetVersionNumber() == 3) {
1108 // version 3 was pre 12/17/2011
1109 DCHECK_EQ(strcmp(kNamespacesTable, kTables[3].table_name), 0);
1110 DCHECK_EQ(strcmp(kNamespacesTable, kIndexes[6].table_name), 0);
1111 DCHECK_EQ(strcmp(kNamespacesTable, kIndexes[7].table_name), 0);
1112 DCHECK_EQ(strcmp(kNamespacesTable, kIndexes[8].table_name), 0);
1113
1114 const TableInfo kNamespaceTable_v4 = {
1115 kNamespacesTable,
1116 "(cache_id INTEGER,"
1117 " origin TEXT," // intentionally not normalized
1118 " type INTEGER,"
1119 " namespace_url TEXT,"
1120 " target_url TEXT)"
1121 };
1122
1123 // Migrate from the old FallbackNameSpaces to the newer Namespaces table,
1124 // but without the is_pattern column added in v5.
1125 sql::Transaction transaction(db_.get());
1126 if (!transaction.Begin() ||
1127 !CreateTable(db_.get(), kNamespaceTable_v4)) {
1128 return false;
1129 }
1130
1131 // Move data from the old table to the new table, setting the
1132 // 'type' for all current records to the value for
1133 // APPCACHE_FALLBACK_NAMESPACE.
1134 DCHECK_EQ(0, static_cast<int>(APPCACHE_FALLBACK_NAMESPACE));
1135 if (!db_->Execute(
1136 "INSERT INTO Namespaces"
1137 " SELECT cache_id, origin, 0, namespace_url, fallback_entry_url"
1138 " FROM FallbackNameSpaces")) {
1139 return false;
1140 }
1141
1142 // Drop the old table, indexes on that table are also removed by this.
1143 if (!db_->Execute("DROP TABLE FallbackNameSpaces"))
1144 return false;
1145
1146 // Create new indexes.
1147 if (!CreateIndex(db_.get(), kIndexes[6]) ||
1148 !CreateIndex(db_.get(), kIndexes[7]) ||
1149 !CreateIndex(db_.get(), kIndexes[8])) {
1150 return false;
1151 }
1152
1153 meta_table_->SetVersionNumber(4);
1154 meta_table_->SetCompatibleVersionNumber(4);
1155 if (!transaction.Commit())
1156 return false;
1157 }
1158
1159 if (meta_table_->GetVersionNumber() == 4) {
1160 // version 4 pre 3/30/2013
1161 // Add the is_pattern column to the Namespaces and OnlineWhitelists tables.
1162 DCHECK_EQ(strcmp(kNamespacesTable, "Namespaces"), 0);
1163 sql::Transaction transaction(db_.get());
1164 if (!transaction.Begin())
1165 return false;
1166 if (!db_->Execute(
1167 "ALTER TABLE Namespaces ADD COLUMN"
1168 " is_pattern INTEGER CHECK(is_pattern IN (0, 1))")) {
1169 return false;
1170 }
1171 if (!db_->Execute(
1172 "ALTER TABLE OnlineWhitelists ADD COLUMN"
1173 " is_pattern INTEGER CHECK(is_pattern IN (0, 1))")) {
1174 return false;
1175 }
1176 meta_table_->SetVersionNumber(5);
1177 meta_table_->SetCompatibleVersionNumber(5);
1178 return transaction.Commit();
1179 }
1180
1181 // If there is no upgrade path for the version on disk to the current
1182 // version, nuke everything and start over.
1183 return DeleteExistingAndCreateNewDatabase();
1184 #endif
1185 }
1186
1187 void AppCacheDatabase::ResetConnectionAndTables() {
1188 meta_table_.reset();
1189 db_.reset();
1190 }
1191
1192 bool AppCacheDatabase::DeleteExistingAndCreateNewDatabase() {
1193 DCHECK(!db_file_path_.empty());
1194 DCHECK(base::PathExists(db_file_path_));
1195 VLOG(1) << "Deleting existing appcache data and starting over.";
1196
1197 ResetConnectionAndTables();
1198
1199 // This also deletes the disk cache data.
1200 base::FilePath directory = db_file_path_.DirName();
1201 if (!base::DeleteFile(directory, true))
1202 return false;
1203
1204 // Make sure the steps above actually deleted things.
1205 if (base::PathExists(directory))
1206 return false;
1207
1208 if (!base::CreateDirectory(directory))
1209 return false;
1210
1211 // So we can't go recursive.
1212 if (is_recreating_)
1213 return false;
1214
1215 base::AutoReset<bool> auto_reset(&is_recreating_, true);
1216 return LazyOpen(true);
1217 }
1218
1219 void AppCacheDatabase::OnDatabaseError(int err, sql::Statement* stmt) {
1220 was_corruption_detected_ |= sql::IsErrorCatastrophic(err);
1221 if (!db_->ShouldIgnoreSqliteError(err))
1222 DLOG(ERROR) << db_->GetErrorMessage();
1223 // TODO: Maybe use non-catostrophic errors to trigger a full integrity check?
1224 }
1225
1226 } // namespace appcache
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698