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
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef mozilla_net_CookiePersistentStorage_h
#define mozilla_net_CookiePersistentStorage_h
#include "CookieStorage.h"
#include "mozilla/Atomics.h"
#include "mozilla/Monitor.h"
#include "mozilla/net/NeckoChannelParams.h"
#include "mozIStorageBindingParamsArray.h"
#include "mozIStorageCompletionCallback.h"
#include "mozIStorageStatement.h"
#include "mozIStorageStatementCallback.h"
class mozIStorageAsyncStatement;
class mozIStorageService;
class nsICookieTransactionCallback;
class nsIEffectiveTLDService;
namespace mozilla {
namespace net {
class CookiePersistentStorage final : public CookieStorage {
public:
// Result codes for TryInitDB() and Read().
enum OpenDBResult { RESULT_OK, RESULT_RETRY, RESULT_FAILURE };
static already_AddRefed<CookiePersistentStorage> Create();
void HandleCorruptDB();
void RemoveCookiesWithOriginAttributes(
const OriginAttributesPattern& aPattern,
const nsACString& aBaseDomain) override;
void RemoveCookiesFromExactHost(
const nsACString& aHost, const nsACString& aBaseDomain,
const OriginAttributesPattern& aPattern) override;
void StaleCookies(const nsTArray<RefPtr<Cookie>>& aCookieList,
int64_t aCurrentTimeInUsec) override;
void Close() override;
void EnsureInitialized() override;
void CleanupCachedStatements();
void CleanupDBConnection();
void Activate();
void RebuildCorruptDB();
void HandleDBClosed();
nsresult RunInTransaction(nsICookieTransactionCallback* aCallback) override;
// State of the database connection.
enum CorruptFlag {
OK, // normal
CLOSING_FOR_REBUILD, // corruption detected, connection closing
REBUILDING // close complete, rebuilding database from memory
};
CorruptFlag GetCorruptFlag() const { return mCorruptFlag; }
void SetCorruptFlag(CorruptFlag aFlag) { mCorruptFlag = aFlag; }
protected:
const char* NotificationTopic() const override { return "cookie-changed"; }
void NotifyChangedInternal(nsICookieNotification* aNotification,
bool aOldCookieIsSession) override;
void RemoveAllInternal() override;
void RemoveCookieFromDB(const Cookie& aCookie) override;
void StoreCookie(const nsACString& aBaseDomain,
const OriginAttributes& aOriginAttributes,
Cookie* aCookie) override;
private:
CookiePersistentStorage();
static void UpdateCookieInList(Cookie* aCookie, int64_t aLastAccessed,
mozIStorageBindingParamsArray* aParamsArray);
void PrepareCookieRemoval(const Cookie& aCookie,
mozIStorageBindingParamsArray* aParamsArray);
void InitDBConn();
nsresult InitDBConnInternal();
OpenDBResult TryInitDB(bool aRecreateDB);
OpenDBResult Read();
void MoveUnpartitionedChipsCookies();
void RecordValidationTelemetry();
nsresult CreateTableWorker(const char* aName);
nsresult CreateTable();
nsresult CreateTableForSchemaVersion6();
nsresult CreateTableForSchemaVersion5();
static UniquePtr<CookieStruct> GetCookieFromRow(mozIStorageStatement* aRow);
already_AddRefed<nsIArray> PurgeCookies(int64_t aCurrentTimeInUsec,
uint16_t aMaxNumberOfCookies,
int64_t aCookiePurgeAge) override;
void CollectCookieJarSizeData() override;
void DeleteFromDB(mozIStorageBindingParamsArray* aParamsArray);
void MaybeStoreCookiesToDB(mozIStorageBindingParamsArray* aParamsArray);
nsCOMPtr<nsIThread> mThread;
nsCOMPtr<mozIStorageService> mStorageService;
nsCOMPtr<nsIEffectiveTLDService> mTLDService;
// encapsulates a (key, Cookie) tuple for temporary storage purposes.
struct CookieDomainTuple {
CookieKey key;
OriginAttributes originAttributes;
UniquePtr<CookieStruct> cookie;
};
// thread
TimeStamp mEndInitDBConn;
nsTArray<CookieDomainTuple> mReadArray;
Monitor mMonitor MOZ_UNANNOTATED;
Atomic<bool> mInitialized;
Atomic<bool> mInitializedDBConn;
nsCOMPtr<nsIFile> mCookieFile;
nsCOMPtr<mozIStorageConnection> mDBConn;
nsCOMPtr<mozIStorageAsyncStatement> mStmtInsert;
nsCOMPtr<mozIStorageAsyncStatement> mStmtDelete;
nsCOMPtr<mozIStorageAsyncStatement> mStmtUpdate;
CorruptFlag mCorruptFlag;
// Various parts representing asynchronous read state. These are useful
// while the background read is taking place.
nsCOMPtr<mozIStorageConnection> mSyncConn;
// DB completion handlers.
nsCOMPtr<mozIStorageStatementCallback> mInsertListener;
nsCOMPtr<mozIStorageStatementCallback> mUpdateListener;
nsCOMPtr<mozIStorageStatementCallback> mRemoveListener;
nsCOMPtr<mozIStorageCompletionCallback> mCloseListener;
};
} // namespace net
} // namespace mozilla
#endif // mozilla_net_CookiePersistentStorage_h
|
