1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7 #include "StorageActivityService.h"
8
9 #include "mozilla/ipc/BackgroundChild.h"
10 #include "mozilla/ipc/BackgroundUtils.h"
11 #include "mozilla/ipc/PBackgroundChild.h"
12 #include "mozilla/ipc/PBackgroundSharedTypes.h"
13 #include "mozilla/BasePrincipal.h"
14 #include "mozilla/SchedulerGroup.h"
15 #include "mozilla/Services.h"
16 #include "mozilla/StaticPtr.h"
17 #include "nsCOMPtr.h"
18 #include "nsComponentManagerUtils.h"
19 #include "nsIMutableArray.h"
20 #include "nsIObserverService.h"
21 #include "nsIPrincipal.h"
22 #include "nsSupportsPrimitives.h"
23 #include "nsXPCOM.h"
24
25 // This const is used to know when origin activities should be purged because
26 // too old. This value should be in sync with what the UI needs.
27 #define TIME_MAX_SECS 86400 /* 24 hours */
28
29 namespace mozilla {
30 namespace dom {
31
32 static StaticRefPtr<StorageActivityService> gStorageActivityService;
33 static bool gStorageActivityShutdown = false;
34
35 /* static */
SendActivity(nsIPrincipal * aPrincipal)36 void StorageActivityService::SendActivity(nsIPrincipal* aPrincipal) {
37 MOZ_ASSERT(NS_IsMainThread());
38
39 if (!aPrincipal || BasePrincipal::Cast(aPrincipal)->Kind() !=
40 BasePrincipal::eContentPrincipal) {
41 // Only content principals.
42 return;
43 }
44
45 RefPtr<StorageActivityService> service = GetOrCreate();
46 if (NS_WARN_IF(!service)) {
47 return;
48 }
49
50 service->SendActivityInternal(aPrincipal);
51 }
52
53 /* static */
SendActivity(const mozilla::ipc::PrincipalInfo & aPrincipalInfo)54 void StorageActivityService::SendActivity(
55 const mozilla::ipc::PrincipalInfo& aPrincipalInfo) {
56 if (aPrincipalInfo.type() !=
57 mozilla::ipc::PrincipalInfo::TContentPrincipalInfo) {
58 // only content principal.
59 return;
60 }
61
62 RefPtr<Runnable> r = NS_NewRunnableFunction(
63 "StorageActivityService::SendActivity", [aPrincipalInfo]() {
64 MOZ_ASSERT(NS_IsMainThread());
65
66 auto principalOrErr =
67 mozilla::ipc::PrincipalInfoToPrincipal(aPrincipalInfo);
68
69 if (principalOrErr.isOk()) {
70 nsCOMPtr<nsIPrincipal> principal = principalOrErr.unwrap();
71 StorageActivityService::SendActivity(principal);
72 } else {
73 NS_WARNING(
74 "Could not obtain principal from "
75 "mozilla::ipc::PrincipalInfoToPrincipal");
76 }
77 });
78
79 SchedulerGroup::Dispatch(TaskCategory::Other, r.forget());
80 }
81
82 /* static */
SendActivity(const nsACString & aOrigin)83 void StorageActivityService::SendActivity(const nsACString& aOrigin) {
84 MOZ_ASSERT(XRE_IsParentProcess());
85
86 nsCString origin;
87 origin.Assign(aOrigin);
88
89 RefPtr<Runnable> r = NS_NewRunnableFunction(
90 "StorageActivityService::SendActivity", [origin]() {
91 MOZ_ASSERT(NS_IsMainThread());
92
93 RefPtr<StorageActivityService> service = GetOrCreate();
94 if (NS_WARN_IF(!service)) {
95 return;
96 }
97
98 service->SendActivityInternal(origin);
99 });
100
101 if (NS_IsMainThread()) {
102 Unused << r->Run();
103 } else {
104 SchedulerGroup::Dispatch(TaskCategory::Other, r.forget());
105 }
106 }
107
108 /* static */
GetOrCreate()109 already_AddRefed<StorageActivityService> StorageActivityService::GetOrCreate() {
110 MOZ_ASSERT(NS_IsMainThread());
111
112 if (!gStorageActivityService && !gStorageActivityShutdown) {
113 RefPtr<StorageActivityService> service = new StorageActivityService();
114
115 nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
116 if (NS_WARN_IF(!obs)) {
117 return nullptr;
118 }
119
120 nsresult rv =
121 obs->AddObserver(service, NS_XPCOM_SHUTDOWN_OBSERVER_ID, true);
122 if (NS_WARN_IF(NS_FAILED(rv))) {
123 return nullptr;
124 }
125
126 gStorageActivityService = service;
127 }
128
129 RefPtr<StorageActivityService> service = gStorageActivityService;
130 return service.forget();
131 }
132
StorageActivityService()133 StorageActivityService::StorageActivityService() {
134 MOZ_ASSERT(NS_IsMainThread());
135 }
136
~StorageActivityService()137 StorageActivityService::~StorageActivityService() {
138 MOZ_ASSERT(NS_IsMainThread());
139 MOZ_ASSERT(!mTimer);
140 }
141
SendActivityInternal(nsIPrincipal * aPrincipal)142 void StorageActivityService::SendActivityInternal(nsIPrincipal* aPrincipal) {
143 MOZ_ASSERT(NS_IsMainThread());
144 MOZ_ASSERT(aPrincipal);
145 MOZ_ASSERT(BasePrincipal::Cast(aPrincipal)->Kind() ==
146 BasePrincipal::eContentPrincipal);
147
148 if (!XRE_IsParentProcess()) {
149 SendActivityToParent(aPrincipal);
150 return;
151 }
152
153 nsAutoCString origin;
154 nsresult rv = aPrincipal->GetOrigin(origin);
155 if (NS_WARN_IF(NS_FAILED(rv))) {
156 return;
157 }
158
159 SendActivityInternal(origin);
160 }
161
SendActivityInternal(const nsACString & aOrigin)162 void StorageActivityService::SendActivityInternal(const nsACString& aOrigin) {
163 MOZ_ASSERT(XRE_IsParentProcess());
164
165 mActivities.InsertOrUpdate(aOrigin, PR_Now());
166 MaybeStartTimer();
167 }
168
SendActivityToParent(nsIPrincipal * aPrincipal)169 void StorageActivityService::SendActivityToParent(nsIPrincipal* aPrincipal) {
170 MOZ_ASSERT(NS_IsMainThread());
171 MOZ_ASSERT(!XRE_IsParentProcess());
172
173 ::mozilla::ipc::PBackgroundChild* actor =
174 ::mozilla::ipc::BackgroundChild::GetOrCreateForCurrentThread();
175 if (NS_WARN_IF(!actor)) {
176 return;
177 }
178
179 mozilla::ipc::PrincipalInfo principalInfo;
180 nsresult rv =
181 mozilla::ipc::PrincipalToPrincipalInfo(aPrincipal, &principalInfo);
182 if (NS_WARN_IF(NS_FAILED(rv))) {
183 return;
184 }
185
186 actor->SendStorageActivity(principalInfo);
187 }
188
189 NS_IMETHODIMP
Observe(nsISupports * aSubject,const char * aTopic,const char16_t * aData)190 StorageActivityService::Observe(nsISupports* aSubject, const char* aTopic,
191 const char16_t* aData) {
192 MOZ_ASSERT(NS_IsMainThread());
193 MOZ_ASSERT(!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID));
194
195 MaybeStopTimer();
196
197 nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
198 if (obs) {
199 obs->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
200 }
201
202 gStorageActivityShutdown = true;
203 gStorageActivityService = nullptr;
204 return NS_OK;
205 }
206
MaybeStartTimer()207 void StorageActivityService::MaybeStartTimer() {
208 MOZ_ASSERT(NS_IsMainThread());
209
210 if (!mTimer) {
211 mTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
212 mTimer->InitWithCallback(this, 1000 * 5 * 60 /* any 5 minutes */,
213 nsITimer::TYPE_REPEATING_SLACK);
214 }
215 }
216
MaybeStopTimer()217 void StorageActivityService::MaybeStopTimer() {
218 MOZ_ASSERT(NS_IsMainThread());
219
220 if (mTimer) {
221 mTimer->Cancel();
222 mTimer = nullptr;
223 }
224 }
225
226 NS_IMETHODIMP
Notify(nsITimer * aTimer)227 StorageActivityService::Notify(nsITimer* aTimer) {
228 MOZ_ASSERT(NS_IsMainThread());
229 MOZ_ASSERT(mTimer == aTimer);
230
231 uint64_t now = PR_Now();
232
233 for (auto iter = mActivities.Iter(); !iter.Done(); iter.Next()) {
234 if ((now - iter.UserData()) / PR_USEC_PER_SEC > TIME_MAX_SECS) {
235 iter.Remove();
236 }
237 }
238
239 // If no activities, let's stop the timer.
240 if (mActivities.Count() == 0) {
241 MaybeStopTimer();
242 }
243
244 return NS_OK;
245 }
246
247 NS_IMETHODIMP
GetName(nsACString & aName)248 StorageActivityService::GetName(nsACString& aName) {
249 aName.AssignLiteral("StorageActivityService");
250 return NS_OK;
251 }
252
253 NS_IMETHODIMP
GetActiveOrigins(PRTime aFrom,PRTime aTo,nsIArray ** aRetval)254 StorageActivityService::GetActiveOrigins(PRTime aFrom, PRTime aTo,
255 nsIArray** aRetval) {
256 uint64_t now = PR_Now();
257 if (((now - aFrom) / PR_USEC_PER_SEC) > TIME_MAX_SECS || aFrom >= aTo) {
258 return NS_ERROR_INVALID_ARG;
259 }
260
261 nsresult rv = NS_OK;
262 nsCOMPtr<nsIMutableArray> devices =
263 do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
264 if (NS_WARN_IF(NS_FAILED(rv))) {
265 return rv;
266 }
267
268 for (const auto& activityEntry : mActivities) {
269 if (activityEntry.GetData() >= aFrom && activityEntry.GetData() <= aTo) {
270 RefPtr<BasePrincipal> principal =
271 BasePrincipal::CreateContentPrincipal(activityEntry.GetKey());
272 MOZ_ASSERT(principal);
273
274 rv = devices->AppendElement(principal);
275 if (NS_WARN_IF(NS_FAILED(rv))) {
276 return rv;
277 }
278 }
279 }
280
281 devices.forget(aRetval);
282 return NS_OK;
283 }
284
285 NS_IMETHODIMP
MoveOriginInTime(nsIPrincipal * aPrincipal,PRTime aWhen)286 StorageActivityService::MoveOriginInTime(nsIPrincipal* aPrincipal,
287 PRTime aWhen) {
288 if (!XRE_IsParentProcess()) {
289 return NS_ERROR_FAILURE;
290 }
291
292 nsAutoCString origin;
293 nsresult rv = aPrincipal->GetOrigin(origin);
294 if (NS_WARN_IF(NS_FAILED(rv))) {
295 return rv;
296 }
297
298 mActivities.InsertOrUpdate(origin, aWhen / PR_USEC_PER_SEC);
299 return NS_OK;
300 }
301
302 NS_IMETHODIMP
TestOnlyReset()303 StorageActivityService::TestOnlyReset() {
304 mActivities.Clear();
305 return NS_OK;
306 }
307
308 NS_INTERFACE_MAP_BEGIN(StorageActivityService)
309 NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIStorageActivityService)
310 NS_INTERFACE_MAP_ENTRY(nsIStorageActivityService)
311 NS_INTERFACE_MAP_ENTRY(nsIObserver)
312 NS_INTERFACE_MAP_ENTRY(nsITimerCallback)
313 NS_INTERFACE_MAP_ENTRY(nsINamed)
314 NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
315 NS_INTERFACE_MAP_END
316
317 NS_IMPL_ADDREF(StorageActivityService)
318 NS_IMPL_RELEASE(StorageActivityService)
319
320 } // namespace dom
321 } // namespace mozilla
322