dom/storage/StorageActivityService.cpp

   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 "nsITimer.h"
  23 #include "nsSupportsPrimitives.h"
  24 #include "nsXPCOM.h"
  25
  26 // This const is used to know when origin activities should be purged because
  27 // too old. This value should be in sync with what the UI needs.
  28 #define TIME_MAX_SECS 86400 /* 24 hours */
  29
  30 namespace mozilla::dom {
  31
  32 static StaticRefPtr<StorageActivityService> gStorageActivityService;
  33 static bool gStorageActivityShutdown = false;
  34
  35 /* static */
  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 */
  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 */
  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 */
 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
 133 StorageActivityService::StorageActivityService() {
 134   MOZ_ASSERT(NS_IsMainThread());
 135 }
 136
 137 StorageActivityService::~StorageActivityService() {
 138   MOZ_ASSERT(NS_IsMainThread());
 139   MOZ_ASSERT(!mTimer);
 140 }
 141
 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
 162 void StorageActivityService::SendActivityInternal(const nsACString& aOrigin) {
 163   MOZ_ASSERT(XRE_IsParentProcess());
 164
 165   mActivities.InsertOrUpdate(aOrigin, PR_Now());
 166   MaybeStartTimer();
 167 }
 168
 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
 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
 207 void StorageActivityService::MaybeStartTimer() {
 208   MOZ_ASSERT(NS_IsMainThread());
 209
 210   if (!mTimer) {
 211     nsresult rv = NS_NewTimerWithCallback(
 212         getter_AddRefs(mTimer), this, 1000 * 5 * 60 /* any 5 minutes */,
 213         nsITimer::TYPE_REPEATING_SLACK, nullptr);
 214     if (NS_FAILED(rv)) {
 215       NS_WARNING("Could not start StorageActivityService timer");
 216     }
 217   }
 218 }
 219
 220 void StorageActivityService::MaybeStopTimer() {
 221   MOZ_ASSERT(NS_IsMainThread());
 222
 223   if (mTimer) {
 224     mTimer->Cancel();
 225     mTimer = nullptr;
 226   }
 227 }
 228
 229 NS_IMETHODIMP
 230 StorageActivityService::Notify(nsITimer* aTimer) {
 231   MOZ_ASSERT(NS_IsMainThread());
 232   MOZ_ASSERT(mTimer == aTimer);
 233
 234   uint64_t now = PR_Now();
 235
 236   for (auto iter = mActivities.Iter(); !iter.Done(); iter.Next()) {
 237     if ((now - iter.UserData()) / PR_USEC_PER_SEC > TIME_MAX_SECS) {
 238       iter.Remove();
 239     }
 240   }
 241
 242   // If no activities, let's stop the timer.
 243   if (mActivities.Count() == 0) {
 244     MaybeStopTimer();
 245   }
 246
 247   return NS_OK;
 248 }
 249
 250 NS_IMETHODIMP
 251 StorageActivityService::GetName(nsACString& aName) {
 252   aName.AssignLiteral("StorageActivityService");
 253   return NS_OK;
 254 }
 255
 256 NS_IMETHODIMP
 257 StorageActivityService::GetActiveOrigins(PRTime aFrom, PRTime aTo,
 258                                          nsIArray** aRetval) {
 259   uint64_t now = PR_Now();
 260   if (((now - aFrom) / PR_USEC_PER_SEC) > TIME_MAX_SECS || aFrom >= aTo) {
 261     return NS_ERROR_INVALID_ARG;
 262   }
 263
 264   nsresult rv = NS_OK;
 265   nsCOMPtr<nsIMutableArray> devices =
 266       do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
 267   if (NS_WARN_IF(NS_FAILED(rv))) {
 268     return rv;
 269   }
 270
 271   for (const auto& activityEntry : mActivities) {
 272     if (activityEntry.GetData() >= aFrom && activityEntry.GetData() <= aTo) {
 273       RefPtr<BasePrincipal> principal =
 274           BasePrincipal::CreateContentPrincipal(activityEntry.GetKey());
 275       MOZ_ASSERT(principal);
 276
 277       rv = devices->AppendElement(principal);
 278       if (NS_WARN_IF(NS_FAILED(rv))) {
 279         return rv;
 280       }
 281     }
 282   }
 283
 284   devices.forget(aRetval);
 285   return NS_OK;
 286 }
 287
 288 NS_IMETHODIMP
 289 StorageActivityService::MoveOriginInTime(nsIPrincipal* aPrincipal,
 290                                          PRTime aWhen) {
 291   if (!XRE_IsParentProcess()) {
 292     return NS_ERROR_FAILURE;
 293   }
 294
 295   nsAutoCString origin;
 296   nsresult rv = aPrincipal->GetOrigin(origin);
 297   if (NS_WARN_IF(NS_FAILED(rv))) {
 298     return rv;
 299   }
 300
 301   mActivities.InsertOrUpdate(origin, aWhen / PR_USEC_PER_SEC);
 302   return NS_OK;
 303 }
 304
 305 NS_IMETHODIMP
 306 StorageActivityService::TestOnlyReset() {
 307   mActivities.Clear();
 308   return NS_OK;
 309 }
 310
 311 NS_INTERFACE_MAP_BEGIN(StorageActivityService)
 312   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIStorageActivityService)
 313   NS_INTERFACE_MAP_ENTRY(nsIStorageActivityService)
 314   NS_INTERFACE_MAP_ENTRY(nsIObserver)
 315   NS_INTERFACE_MAP_ENTRY(nsITimerCallback)
 316   NS_INTERFACE_MAP_ENTRY(nsINamed)
 317   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
 318 NS_INTERFACE_MAP_END
 319
 320 NS_IMPL_ADDREF(StorageActivityService)
 321 NS_IMPL_RELEASE(StorageActivityService)
 322
 323 }  // namespace mozilla::dom