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 "nsIUserIdleService.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(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     NS_DispatchToMainThread(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 }
 140
 141 void StorageActivityService::SendActivityInternal(nsIPrincipal* aPrincipal) {
 142   MOZ_ASSERT(NS_IsMainThread());
 143   MOZ_ASSERT(aPrincipal);
 144   MOZ_ASSERT(BasePrincipal::Cast(aPrincipal)->Kind() ==
 145              BasePrincipal::eContentPrincipal);
 146
 147   if (!XRE_IsParentProcess()) {
 148     SendActivityToParent(aPrincipal);
 149     return;
 150   }
 151
 152   nsAutoCString origin;
 153   nsresult rv = aPrincipal->GetOrigin(origin);
 154   if (NS_WARN_IF(NS_FAILED(rv))) {
 155     return;
 156   }
 157
 158   SendActivityInternal(origin);
 159 }
 160
 161 void StorageActivityService::SendActivityInternal(const nsACString& aOrigin) {
 162   MOZ_ASSERT(XRE_IsParentProcess());
 163
 164   bool shouldAddObserver = mActivities.Count() == 0;
 165   mActivities.InsertOrUpdate(aOrigin, PR_Now());
 166
 167   if (shouldAddObserver) {
 168     nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
 169     if (NS_WARN_IF(!obs)) {
 170       return;
 171     }
 172
 173     obs->AddObserver(this, OBSERVER_TOPIC_IDLE_DAILY, true);
 174   }
 175 }
 176
 177 void StorageActivityService::SendActivityToParent(nsIPrincipal* aPrincipal) {
 178   MOZ_ASSERT(NS_IsMainThread());
 179   MOZ_ASSERT(!XRE_IsParentProcess());
 180
 181   ::mozilla::ipc::PBackgroundChild* actor =
 182       ::mozilla::ipc::BackgroundChild::GetOrCreateForCurrentThread();
 183   if (NS_WARN_IF(!actor)) {
 184     return;
 185   }
 186
 187   mozilla::ipc::PrincipalInfo principalInfo;
 188   nsresult rv =
 189       mozilla::ipc::PrincipalToPrincipalInfo(aPrincipal, &principalInfo);
 190   if (NS_WARN_IF(NS_FAILED(rv))) {
 191     return;
 192   }
 193
 194   actor->SendStorageActivity(principalInfo);
 195 }
 196
 197 NS_IMETHODIMP
 198 StorageActivityService::Observe(nsISupports* aSubject, const char* aTopic,
 199                                 const char16_t* aData) {
 200   MOZ_ASSERT(NS_IsMainThread());
 201
 202   if (!strcmp(aTopic, OBSERVER_TOPIC_IDLE_DAILY)) {
 203     CleanUp();
 204     return NS_OK;
 205   }
 206
 207   MOZ_ASSERT(!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID));
 208
 209   gStorageActivityShutdown = true;
 210   gStorageActivityService = nullptr;
 211   return NS_OK;
 212 }
 213
 214 void StorageActivityService::CleanUp() {
 215   MOZ_ASSERT(NS_IsMainThread());
 216
 217   uint64_t now = PR_Now();
 218
 219   for (auto iter = mActivities.Iter(); !iter.Done(); iter.Next()) {
 220     if ((now - iter.UserData()) / PR_USEC_PER_SEC > TIME_MAX_SECS) {
 221       iter.Remove();
 222     }
 223   }
 224
 225   // If no activities, remove the observer.
 226   if (mActivities.Count() == 0) {
 227     nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
 228     if (obs) {
 229       obs->RemoveObserver(this, OBSERVER_TOPIC_IDLE_DAILY);
 230     }
 231   }
 232 }
 233
 234 NS_IMETHODIMP
 235 StorageActivityService::GetActiveOrigins(PRTime aFrom, PRTime aTo,
 236                                          nsIArray** aRetval) {
 237   uint64_t now = PR_Now();
 238   if (((now - aFrom) / PR_USEC_PER_SEC) > TIME_MAX_SECS || aFrom >= aTo) {
 239     return NS_ERROR_INVALID_ARG;
 240   }
 241
 242   // Remove expired entries first.
 243   CleanUp();
 244
 245   nsresult rv = NS_OK;
 246   nsCOMPtr<nsIMutableArray> devices =
 247       do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
 248   if (NS_WARN_IF(NS_FAILED(rv))) {
 249     return rv;
 250   }
 251
 252   for (const auto& activityEntry : mActivities) {
 253     if (activityEntry.GetData() >= aFrom && activityEntry.GetData() <= aTo) {
 254       RefPtr<BasePrincipal> principal =
 255           BasePrincipal::CreateContentPrincipal(activityEntry.GetKey());
 256       MOZ_ASSERT(principal);
 257
 258       rv = devices->AppendElement(principal);
 259       if (NS_WARN_IF(NS_FAILED(rv))) {
 260         return rv;
 261       }
 262     }
 263   }
 264
 265   devices.forget(aRetval);
 266   return NS_OK;
 267 }
 268
 269 NS_IMETHODIMP
 270 StorageActivityService::MoveOriginInTime(nsIPrincipal* aPrincipal,
 271                                          PRTime aWhen) {
 272   if (!XRE_IsParentProcess()) {
 273     return NS_ERROR_FAILURE;
 274   }
 275
 276   nsAutoCString origin;
 277   nsresult rv = aPrincipal->GetOrigin(origin);
 278   if (NS_WARN_IF(NS_FAILED(rv))) {
 279     return rv;
 280   }
 281
 282   mActivities.InsertOrUpdate(origin, aWhen / PR_USEC_PER_SEC);
 283   return NS_OK;
 284 }
 285
 286 NS_IMETHODIMP
 287 StorageActivityService::TestOnlyReset() {
 288   mActivities.Clear();
 289   return NS_OK;
 290 }
 291
 292 NS_INTERFACE_MAP_BEGIN(StorageActivityService)
 293   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIStorageActivityService)
 294   NS_INTERFACE_MAP_ENTRY(nsIStorageActivityService)
 295   NS_INTERFACE_MAP_ENTRY(nsIObserver)
 296   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
 297 NS_INTERFACE_MAP_END
 298
 299 NS_IMPL_ADDREF(StorageActivityService)
 300 NS_IMPL_RELEASE(StorageActivityService)
 301
 302 }  // namespace mozilla::dom