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
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
|
// 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 COMPONENTS_HISTORY_CORE_BROWSER_HISTORY_DATABASE_H_
#define COMPONENTS_HISTORY_CORE_BROWSER_HISTORY_DATABASE_H_
#include "base/compiler_specific.h"
#include "base/gtest_prod_util.h"
#include "base/macros.h"
#include "build/build_config.h"
#include "components/history/core/browser/download_database.h"
#include "components/history/core/browser/history_types.h"
#include "components/history/core/browser/sync/typed_url_sync_metadata_database.h"
#include "components/history/core/browser/url_database.h"
#include "components/history/core/browser/visit_annotations_database.h"
#include "components/history/core/browser/visit_database.h"
#include "components/history/core/browser/visitsegment_database.h"
#include "sql/database.h"
#include "sql/init_status.h"
#include "sql/meta_table.h"
#if defined(OS_ANDROID)
#include "components/history/core/browser/android/android_cache_database.h"
#include "components/history/core/browser/android/android_urls_database.h"
#endif
namespace base {
class FilePath;
}
class InMemoryURLIndexTest;
namespace history {
// Encapsulates the SQL connection for the history database. This class holds
// the database connection and has methods the history system (including full
// text search) uses for writing and retrieving information.
//
// We try to keep most logic out of the history database; this should be seen
// as the storage interface. Logic for manipulating this storage layer should
// be in HistoryBackend.cc.
class HistoryDatabase : public DownloadDatabase,
#if defined(OS_ANDROID)
public AndroidURLsDatabase,
public AndroidCacheDatabase,
#endif
public TypedURLSyncMetadataDatabase,
public URLDatabase,
public VisitDatabase,
public VisitAnnotationsDatabase,
public VisitSegmentDatabase {
public:
// A simple class for scoping a history database transaction. This does not
// support rollback since the history database doesn't, either.
class TransactionScoper {
public:
explicit TransactionScoper(HistoryDatabase* db) : db_(db) {
db_->BeginTransaction();
}
~TransactionScoper() { db_->CommitTransaction(); }
private:
HistoryDatabase* db_;
};
// Must call Init() to complete construction. Although it can be created on
// any thread, it must be destructed on the history thread for proper
// database cleanup.
HistoryDatabase(DownloadInterruptReason download_interrupt_reason_none,
DownloadInterruptReason download_interrupt_reason_crash);
~HistoryDatabase() override;
// Call before Init() to set the error callback to be used for the
// underlying database connection.
void set_error_callback(const sql::Database::ErrorCallback& error_callback) {
db_.set_error_callback(error_callback);
}
// Must call this function to complete initialization. Will return
// sql::INIT_OK on success. Otherwise, no other function should be called. You
// may want to call BeginExclusiveMode after this when you are ready.
sql::InitStatus Init(const base::FilePath& history_name);
// Computes and records various metrics for the database. Should only be
// called once and only upon successful Init.
void ComputeDatabaseMetrics(const base::FilePath& filename);
// Counts the number of unique Hosts visited in the last month.
int CountUniqueHostsVisitedLastMonth();
// Counts the number of unique domains (eLTD+1) visited within
// [`begin_time`, `end_time`).
int CountUniqueDomainsVisited(base::Time begin_time, base::Time end_time);
// Call to set the mode on the database to exclusive. The default locking mode
// is "normal" but we want to run in exclusive mode for slightly better
// performance since we know nobody else is using the database. This is
// separate from Init() since the in-memory database attaches to slurp the
// data out, and this can't happen in exclusive mode.
void BeginExclusiveMode();
// Returns the current version that we will generate history databases with.
static int GetCurrentVersion();
// Transactions on the history database. Use the Transaction object above
// for most work instead of these directly. We support nested transactions
// and only commit when the outermost transaction is committed. This means
// that it is impossible to rollback a specific transaction. We could roll
// back the outermost transaction if any inner one is rolled back, but it
// turns out we don't really need this type of integrity for the history
// database, so we just don't support it.
void BeginTransaction();
void CommitTransaction();
int transaction_nesting() const { // for debugging and assertion purposes
return db_.transaction_nesting();
}
void RollbackTransaction();
// Drops all tables except the URL, and download tables, and recreates them
// from scratch. This is done to rapidly clean up stuff when deleting all
// history. It is faster and less likely to have problems that deleting all
// rows in the tables.
//
// We don't delete the downloads table, since there may be in progress
// downloads. We handle the download history clean up separately in:
// content::DownloadManager::RemoveDownloadsFromHistoryBetween.
//
// Returns true on success. On failure, the caller should assume that the
// database is invalid. There could have been an error recreating a table.
// This should be treated the same as an init failure, and the database
// should not be used any more.
//
// This will also recreate the supplementary URL indices, since these
// indices won't be created automatically when using the temporary URL
// table (what the caller does right before calling this).
bool RecreateAllTablesButURL();
// Vacuums the database. This will cause sqlite to defragment and collect
// unused space in the file. It can be VERY SLOW.
void Vacuum();
// Release all non-essential memory associated with this database connection.
void TrimMemory();
// Razes the database. Returns true if successful.
bool Raze();
std::string GetDiagnosticInfo(int extended_error, sql::Statement* statement);
// Visit table functions ----------------------------------------------------
// Update the segment id of a visit. Return true on success.
bool SetSegmentID(VisitID visit_id, SegmentID segment_id);
// Query the segment ID for the provided visit. Return 0 on failure or if the
// visit id wasn't found.
SegmentID GetSegmentID(VisitID visit_id);
// TODO(https://crbug.com/1141501): this is for an experiment, and will be
// removed once data is collected from experiment.
bool GetVisitsForUrl2(URLID url_id, VisitVector* visits) override;
// Retrieves/Updates early expiration threshold, which specifies the earliest
// known point in history that may possibly to contain visits suitable for
// early expiration (AUTO_SUBFRAMES).
virtual base::Time GetEarlyExpirationThreshold();
virtual void UpdateEarlyExpirationThreshold(base::Time threshold);
private:
#if defined(OS_ANDROID)
// AndroidProviderBackend uses the `db_`.
friend class AndroidProviderBackend;
FRIEND_TEST_ALL_PREFIXES(AndroidURLsMigrationTest, MigrateToVersion22);
#endif
friend class ::InMemoryURLIndexTest;
// Overridden from URLDatabase, DownloadDatabase, VisitDatabase,
// VisitSegmentDatabase and TypedURLSyncMetadataDatabase.
sql::Database& GetDB() override;
// Overridden from TypedURLSyncMetadataDatabase.
sql::MetaTable& GetMetaTable() override;
// Migration -----------------------------------------------------------------
// Makes sure the version is up to date, updating if necessary. If the
// database is too old to migrate, the user will be notified. Returns
// sql::INIT_OK iff the DB is up to date and ready for use.
//
// This assumes it is called from the init function inside a transaction. It
// may commit the transaction and start a new one if migration requires it.
sql::InitStatus EnsureCurrentVersion();
#if !defined(OS_WIN)
// Converts the time epoch in the database from being 1970-based to being
// 1601-based which corresponds to the change in Time.internal_value_.
void MigrateTimeEpoch();
#endif
// ---------------------------------------------------------------------------
sql::Database db_;
sql::MetaTable meta_table_;
base::Time cached_early_expiration_threshold_;
DISALLOW_COPY_AND_ASSIGN(HistoryDatabase);
};
} // namespace history
#endif // COMPONENTS_HISTORY_CORE_BROWSER_HISTORY_DATABASE_H_
|
