docshell/base/BrowsingContextGroup.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 "mozilla/dom/BrowsingContextGroup.h"
   8
   9 #include "mozilla/ClearOnShutdown.h"
  10 #include "mozilla/InputTaskManager.h"
  11 #include "mozilla/Preferences.h"
  12 #include "mozilla/dom/BrowsingContextBinding.h"
  13 #include "mozilla/dom/BindingUtils.h"
  14 #include "mozilla/dom/ContentChild.h"
  15 #include "mozilla/dom/ContentParent.h"
  16 #include "mozilla/dom/DocGroup.h"
  17 #include "mozilla/StaticPrefs_dom.h"
  18 #include "mozilla/ThrottledEventQueue.h"
  19 #include "nsFocusManager.h"
  20 #include "nsTHashMap.h"
  21
  22 namespace mozilla {
  23 namespace dom {
  24
  25 // Maximum number of successive dialogs before we prompt users to disable
  26 // dialogs for this window.
  27 #define MAX_SUCCESSIVE_DIALOG_COUNT 5
  28
  29 static StaticRefPtr<BrowsingContextGroup> sChromeGroup;
  30
  31 static StaticAutoPtr<nsTHashMap<uint64_t, RefPtr<BrowsingContextGroup>>>
  32     sBrowsingContextGroups;
  33
  34 already_AddRefed<BrowsingContextGroup> BrowsingContextGroup::GetOrCreate(
  35     uint64_t aId) {
  36   if (!sBrowsingContextGroups) {
  37     sBrowsingContextGroups =
  38         new nsTHashMap<nsUint64HashKey, RefPtr<BrowsingContextGroup>>();
  39     ClearOnShutdown(&sBrowsingContextGroups);
  40   }
  41
  42   return do_AddRef(sBrowsingContextGroups->LookupOrInsertWith(
  43       aId, [&aId] { return do_AddRef(new BrowsingContextGroup(aId)); }));
  44 }
  45
  46 already_AddRefed<BrowsingContextGroup> BrowsingContextGroup::GetExisting(
  47     uint64_t aId) {
  48   if (sBrowsingContextGroups) {
  49     return do_AddRef(sBrowsingContextGroups->Get(aId));
  50   }
  51   return nullptr;
  52 }
  53
  54 // Only use 53 bits for the BrowsingContextGroup ID.
  55 static constexpr uint64_t kBrowsingContextGroupIdTotalBits = 53;
  56 static constexpr uint64_t kBrowsingContextGroupIdProcessBits = 22;
  57 static constexpr uint64_t kBrowsingContextGroupIdFlagBits = 1;
  58 static constexpr uint64_t kBrowsingContextGroupIdBits =
  59     kBrowsingContextGroupIdTotalBits - kBrowsingContextGroupIdProcessBits -
  60     kBrowsingContextGroupIdFlagBits;
  61
  62 // IDs for the relevant flags
  63 static constexpr uint64_t kPotentiallyCrossOriginIsolatedFlag = 0x1;
  64
  65 // The next ID value which will be used.
  66 static uint64_t sNextBrowsingContextGroupId = 1;
  67
  68 // Generate the next ID with the given flags.
  69 static uint64_t GenerateBrowsingContextGroupId(uint64_t aFlags) {
  70   MOZ_RELEASE_ASSERT(aFlags < (uint64_t(1) << kBrowsingContextGroupIdFlagBits));
  71   uint64_t childId = XRE_IsContentProcess()
  72                          ? ContentChild::GetSingleton()->GetID()
  73                          : uint64_t(0);
  74   MOZ_RELEASE_ASSERT(childId <
  75                      (uint64_t(1) << kBrowsingContextGroupIdProcessBits));
  76   uint64_t id = sNextBrowsingContextGroupId++;
  77   MOZ_RELEASE_ASSERT(id < (uint64_t(1) << kBrowsingContextGroupIdBits));
  78
  79   return (childId << (kBrowsingContextGroupIdBits +
  80                       kBrowsingContextGroupIdFlagBits)) |
  81          (id << kBrowsingContextGroupIdFlagBits) | aFlags;
  82 }
  83
  84 // Extract flags from the given ID.
  85 static uint64_t GetBrowsingContextGroupIdFlags(uint64_t aId) {
  86   return aId & ((uint64_t(1) << kBrowsingContextGroupIdFlagBits) - 1);
  87 }
  88
  89 uint64_t BrowsingContextGroup::CreateId(bool aPotentiallyCrossOriginIsolated) {
  90   // We encode the potentially cross-origin isolated bit within the ID so that
  91   // the information can be recovered whenever the group needs to be re-created
  92   // due to e.g. being garbage-collected.
  93   //
  94   // In the future if we end up needing more complex information stored within
  95   // the ID, we can consider converting it to a more complex type, like a
  96   // string.
  97   uint64_t flags =
  98       aPotentiallyCrossOriginIsolated ? kPotentiallyCrossOriginIsolatedFlag : 0;
  99   uint64_t id = GenerateBrowsingContextGroupId(flags);
 100   MOZ_ASSERT(GetBrowsingContextGroupIdFlags(id) == flags);
 101   return id;
 102 }
 103
 104 already_AddRefed<BrowsingContextGroup> BrowsingContextGroup::Create(
 105     bool aPotentiallyCrossOriginIsolated) {
 106   return GetOrCreate(CreateId(aPotentiallyCrossOriginIsolated));
 107 }
 108
 109 BrowsingContextGroup::BrowsingContextGroup(uint64_t aId) : mId(aId) {
 110   mTimerEventQueue = ThrottledEventQueue::Create(
 111       GetMainThreadSerialEventTarget(), "BrowsingContextGroup timer queue");
 112
 113   mWorkerEventQueue = ThrottledEventQueue::Create(
 114       GetMainThreadSerialEventTarget(), "BrowsingContextGroup worker queue");
 115 }
 116
 117 void BrowsingContextGroup::Register(nsISupports* aContext) {
 118   MOZ_DIAGNOSTIC_ASSERT(!mDestroyed);
 119   MOZ_DIAGNOSTIC_ASSERT(aContext);
 120   mContexts.Insert(aContext);
 121 }
 122
 123 void BrowsingContextGroup::Unregister(nsISupports* aContext) {
 124   MOZ_DIAGNOSTIC_ASSERT(!mDestroyed);
 125   MOZ_DIAGNOSTIC_ASSERT(aContext);
 126   mContexts.Remove(aContext);
 127
 128   MaybeDestroy();
 129 }
 130
 131 void BrowsingContextGroup::EnsureHostProcess(ContentParent* aProcess) {
 132   MOZ_DIAGNOSTIC_ASSERT(!mDestroyed);
 133   MOZ_DIAGNOSTIC_ASSERT(this != sChromeGroup,
 134                         "cannot have content host for chrome group");
 135   MOZ_DIAGNOSTIC_ASSERT(aProcess->GetRemoteType() != PREALLOC_REMOTE_TYPE,
 136                         "cannot use preallocated process as host");
 137   MOZ_DIAGNOSTIC_ASSERT(!aProcess->GetRemoteType().IsEmpty(),
 138                         "host process must have remote type");
 139
 140   // XXX: The diagnostic crashes in bug 1816025 seemed to come through caller
 141   // ContentParent::GetNewOrUsedLaunchingBrowserProcess where we already
 142   // did AssertAlive, so IsDead should be irrelevant here. Still it reads
 143   // wrong that we ever might do AddBrowsingContextGroup if aProcess->IsDead().
 144   if (aProcess->IsDead() ||
 145       mHosts.WithEntryHandle(aProcess->GetRemoteType(), [&](auto&& entry) {
 146         if (entry) {
 147           // We know from bug 1816025 that this happens quite often and we have
 148           // bug 1815480 on file that should harden the entire flow. But in the
 149           // meantime we can just live with NOT replacing the found host
 150           // process with a new one here if it is still alive.
 151           MOZ_ASSERT(
 152               entry.Data() == aProcess,
 153               "There's already another host process for this remote type");
 154           if (!entry.Data()->IsShuttingDown()) {
 155             return false;
 156           }
 157         }
 158
 159         // This process wasn't already marked as our host, so insert it (or
 160         // update if the old process is shutting down), and begin subscribing,
 161         // unless the process is still launching.
 162         entry.InsertOrUpdate(do_AddRef(aProcess));
 163
 164         return true;
 165       })) {
 166     aProcess->AddBrowsingContextGroup(this);
 167   }
 168 }
 169
 170 void BrowsingContextGroup::RemoveHostProcess(ContentParent* aProcess) {
 171   MOZ_DIAGNOSTIC_ASSERT(aProcess);
 172   MOZ_DIAGNOSTIC_ASSERT(aProcess->GetRemoteType() != PREALLOC_REMOTE_TYPE);
 173   auto entry = mHosts.Lookup(aProcess->GetRemoteType());
 174   if (entry && entry.Data() == aProcess) {
 175     entry.Remove();
 176   }
 177 }
 178
 179 static void CollectContextInitializers(
 180     Span<RefPtr<BrowsingContext>> aContexts,
 181     nsTArray<SyncedContextInitializer>& aInits) {
 182   // The order that we record these initializers is important, as it will keep
 183   // the order that children are attached to their parent in the newly connected
 184   // content process consistent.
 185   for (auto& context : aContexts) {
 186     aInits.AppendElement(context->GetIPCInitializer());
 187     for (const auto& window : context->GetWindowContexts()) {
 188       aInits.AppendElement(window->GetIPCInitializer());
 189       CollectContextInitializers(window->Children(), aInits);
 190     }
 191   }
 192 }
 193
 194 void BrowsingContextGroup::Subscribe(ContentParent* aProcess) {
 195   MOZ_DIAGNOSTIC_ASSERT(!mDestroyed);
 196   MOZ_DIAGNOSTIC_ASSERT(aProcess && !aProcess->IsLaunching());
 197   MOZ_DIAGNOSTIC_ASSERT(aProcess->GetRemoteType() != PREALLOC_REMOTE_TYPE);
 198
 199   // Check if we're already subscribed to this process.
 200   if (!mSubscribers.EnsureInserted(aProcess)) {
 201     return;
 202   }
 203
 204 #ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
 205   // If the process is already marked as dead, we won't be the host, but may
 206   // still need to subscribe to the process due to creating a popup while
 207   // shutting down.
 208   if (!aProcess->IsDead()) {
 209     auto hostEntry = mHosts.Lookup(aProcess->GetRemoteType());
 210     MOZ_DIAGNOSTIC_ASSERT(hostEntry && hostEntry.Data() == aProcess,
 211                           "Cannot subscribe a non-host process");
 212   }
 213 #endif
 214
 215   // FIXME: This won't send non-discarded children of discarded BCs, but those
 216   // BCs will be in the process of being destroyed anyway.
 217   // FIXME: Prevent that situation from occuring.
 218   nsTArray<SyncedContextInitializer> inits(mContexts.Count());
 219   CollectContextInitializers(mToplevels, inits);
 220
 221   // Send all of our contexts to the target content process.
 222   Unused << aProcess->SendRegisterBrowsingContextGroup(Id(), inits);
 223
 224   // If the focused or active BrowsingContexts belong in this group, tell the
 225   // newly subscribed process.
 226   if (nsFocusManager* fm = nsFocusManager::GetFocusManager()) {
 227     BrowsingContext* focused = fm->GetFocusedBrowsingContextInChrome();
 228     if (focused && focused->Group() != this) {
 229       focused = nullptr;
 230     }
 231     BrowsingContext* active = fm->GetActiveBrowsingContextInChrome();
 232     if (active && active->Group() != this) {
 233       active = nullptr;
 234     }
 235
 236     if (focused || active) {
 237       Unused << aProcess->SendSetupFocusedAndActive(
 238           focused, fm->GetActionIdForFocusedBrowsingContextInChrome(), active,
 239           fm->GetActionIdForActiveBrowsingContextInChrome());
 240     }
 241   }
 242 }
 243
 244 void BrowsingContextGroup::Unsubscribe(ContentParent* aProcess) {
 245   MOZ_DIAGNOSTIC_ASSERT(aProcess);
 246   MOZ_DIAGNOSTIC_ASSERT(aProcess->GetRemoteType() != PREALLOC_REMOTE_TYPE);
 247   mSubscribers.Remove(aProcess);
 248   aProcess->RemoveBrowsingContextGroup(this);
 249
 250 #ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
 251   auto hostEntry = mHosts.Lookup(aProcess->GetRemoteType());
 252   MOZ_DIAGNOSTIC_ASSERT(!hostEntry || hostEntry.Data() != aProcess,
 253                         "Unsubscribing existing host entry");
 254 #endif
 255 }
 256
 257 ContentParent* BrowsingContextGroup::GetHostProcess(
 258     const nsACString& aRemoteType) {
 259   return mHosts.GetWeak(aRemoteType);
 260 }
 261
 262 void BrowsingContextGroup::UpdateToplevelsSuspendedIfNeeded() {
 263   if (!StaticPrefs::dom_suspend_inactive_enabled()) {
 264     return;
 265   }
 266
 267   mToplevelsSuspended = ShouldSuspendAllTopLevelContexts();
 268   for (const auto& context : mToplevels) {
 269     nsPIDOMWindowOuter* outer = context->GetDOMWindow();
 270     if (!outer) {
 271       continue;
 272     }
 273     nsCOMPtr<nsPIDOMWindowInner> inner = outer->GetCurrentInnerWindow();
 274     if (!inner) {
 275       continue;
 276     }
 277     if (mToplevelsSuspended && !inner->GetWasSuspendedByGroup()) {
 278       inner->Suspend();
 279       inner->SetWasSuspendedByGroup(true);
 280     } else if (!mToplevelsSuspended && inner->GetWasSuspendedByGroup()) {
 281       inner->Resume();
 282       inner->SetWasSuspendedByGroup(false);
 283     }
 284   }
 285 }
 286
 287 bool BrowsingContextGroup::ShouldSuspendAllTopLevelContexts() const {
 288   for (const auto& context : mToplevels) {
 289     if (!context->InactiveForSuspend()) {
 290       return false;
 291     }
 292   }
 293   return true;
 294 }
 295
 296 BrowsingContextGroup::~BrowsingContextGroup() { Destroy(); }
 297
 298 void BrowsingContextGroup::Destroy() {
 299 #ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
 300   if (mDestroyed) {
 301     MOZ_DIAGNOSTIC_ASSERT(mHosts.Count() == 0);
 302     MOZ_DIAGNOSTIC_ASSERT(mSubscribers.Count() == 0);
 303     MOZ_DIAGNOSTIC_ASSERT_IF(sBrowsingContextGroups,
 304                              !sBrowsingContextGroups->Contains(Id()) ||
 305                                  *sBrowsingContextGroups->Lookup(Id()) != this);
 306   }
 307   mDestroyed = true;
 308 #endif
 309
 310   // Make sure to call `RemoveBrowsingContextGroup` for every entry in both
 311   // `mHosts` and `mSubscribers`. This will visit most entries twice, but
 312   // `RemoveBrowsingContextGroup` is safe to call multiple times.
 313   for (const auto& entry : mHosts.Values()) {
 314     entry->RemoveBrowsingContextGroup(this);
 315   }
 316   for (const auto& key : mSubscribers) {
 317     key->RemoveBrowsingContextGroup(this);
 318   }
 319   mHosts.Clear();
 320   mSubscribers.Clear();
 321
 322   if (sBrowsingContextGroups) {
 323     sBrowsingContextGroups->Remove(Id());
 324   }
 325 }
 326
 327 void BrowsingContextGroup::AddKeepAlive() {
 328   MOZ_DIAGNOSTIC_ASSERT(!mDestroyed);
 329   MOZ_DIAGNOSTIC_ASSERT(XRE_IsParentProcess());
 330   mKeepAliveCount++;
 331 }
 332
 333 void BrowsingContextGroup::RemoveKeepAlive() {
 334   MOZ_DIAGNOSTIC_ASSERT(!mDestroyed);
 335   MOZ_DIAGNOSTIC_ASSERT(mKeepAliveCount > 0);
 336   MOZ_DIAGNOSTIC_ASSERT(XRE_IsParentProcess());
 337   mKeepAliveCount--;
 338
 339   MaybeDestroy();
 340 }
 341
 342 auto BrowsingContextGroup::MakeKeepAlivePtr() -> KeepAlivePtr {
 343   AddKeepAlive();
 344   return KeepAlivePtr{do_AddRef(this).take()};
 345 }
 346
 347 void BrowsingContextGroup::MaybeDestroy() {
 348   // Once there are no synced contexts referencing a `BrowsingContextGroup`, we
 349   // can clear subscribers and destroy this group. We only do this in the parent
 350   // process, as it will orchestrate destruction of BCGs in content processes.
 351   if (XRE_IsParentProcess() && mContexts.IsEmpty() && mKeepAliveCount == 0 &&
 352       this != sChromeGroup) {
 353     Destroy();
 354
 355     // We may have been deleted here, as `Destroy()` will clear references. Do
 356     // not access any members at this point.
 357   }
 358 }
 359
 360 void BrowsingContextGroup::ChildDestroy() {
 361   MOZ_DIAGNOSTIC_ASSERT(XRE_IsContentProcess());
 362   MOZ_DIAGNOSTIC_ASSERT(!mDestroyed);
 363   MOZ_DIAGNOSTIC_ASSERT(mContexts.IsEmpty());
 364   Destroy();
 365 }
 366
 367 nsISupports* BrowsingContextGroup::GetParentObject() const {
 368   return xpc::NativeGlobal(xpc::PrivilegedJunkScope());
 369 }
 370
 371 JSObject* BrowsingContextGroup::WrapObject(JSContext* aCx,
 372                                            JS::Handle<JSObject*> aGivenProto) {
 373   return BrowsingContextGroup_Binding::Wrap(aCx, this, aGivenProto);
 374 }
 375
 376 nsresult BrowsingContextGroup::QueuePostMessageEvent(
 377     already_AddRefed<nsIRunnable>&& aRunnable) {
 378   if (!StaticPrefs::dom_separate_event_queue_for_post_message_enabled()) {
 379     return NS_ERROR_FAILURE;
 380   }
 381
 382   if (!mPostMessageEventQueue) {
 383     nsCOMPtr<nsISerialEventTarget> target = GetMainThreadSerialEventTarget();
 384     mPostMessageEventQueue = ThrottledEventQueue::Create(
 385         target, "PostMessage Queue",
 386         nsIRunnablePriority::PRIORITY_DEFERRED_TIMERS);
 387     nsresult rv = mPostMessageEventQueue->SetIsPaused(false);
 388     MOZ_ALWAYS_SUCCEEDS(rv);
 389   }
 390
 391   // Ensure the queue is enabled
 392   if (mPostMessageEventQueue->IsPaused()) {
 393     nsresult rv = mPostMessageEventQueue->SetIsPaused(false);
 394     MOZ_ALWAYS_SUCCEEDS(rv);
 395   }
 396
 397   mPostMessageEventQueue->Dispatch(std::move(aRunnable), NS_DISPATCH_NORMAL);
 398   return NS_OK;
 399 }
 400
 401 void BrowsingContextGroup::FlushPostMessageEvents() {
 402   if (!mPostMessageEventQueue) {
 403     return;
 404   }
 405   nsresult rv = mPostMessageEventQueue->SetIsPaused(true);
 406   MOZ_ALWAYS_SUCCEEDS(rv);
 407   nsCOMPtr<nsIRunnable> event;
 408   while ((event = mPostMessageEventQueue->GetEvent())) {
 409     NS_DispatchToMainThread(event.forget());
 410   }
 411 }
 412
 413 bool BrowsingContextGroup::HasActiveBC() {
 414   for (auto& topLevelBC : Toplevels()) {
 415     if (topLevelBC->IsActive()) {
 416       return true;
 417     }
 418   }
 419   return false;
 420 }
 421
 422 void BrowsingContextGroup::IncInputEventSuspensionLevel() {
 423   MOZ_ASSERT(StaticPrefs::dom_input_events_canSuspendInBCG_enabled());
 424   if (!mHasIncreasedInputTaskManagerSuspensionLevel && HasActiveBC()) {
 425     IncInputTaskManagerSuspensionLevel();
 426   }
 427   ++mInputEventSuspensionLevel;
 428 }
 429
 430 void BrowsingContextGroup::DecInputEventSuspensionLevel() {
 431   MOZ_ASSERT(StaticPrefs::dom_input_events_canSuspendInBCG_enabled());
 432   --mInputEventSuspensionLevel;
 433   if (!mInputEventSuspensionLevel &&
 434       mHasIncreasedInputTaskManagerSuspensionLevel) {
 435     DecInputTaskManagerSuspensionLevel();
 436   }
 437 }
 438
 439 void BrowsingContextGroup::DecInputTaskManagerSuspensionLevel() {
 440   MOZ_ASSERT(StaticPrefs::dom_input_events_canSuspendInBCG_enabled());
 441   MOZ_ASSERT(mHasIncreasedInputTaskManagerSuspensionLevel);
 442
 443   InputTaskManager::Get()->DecSuspensionLevel();
 444   mHasIncreasedInputTaskManagerSuspensionLevel = false;
 445 }
 446
 447 void BrowsingContextGroup::IncInputTaskManagerSuspensionLevel() {
 448   MOZ_ASSERT(StaticPrefs::dom_input_events_canSuspendInBCG_enabled());
 449   MOZ_ASSERT(!mHasIncreasedInputTaskManagerSuspensionLevel);
 450   MOZ_ASSERT(HasActiveBC());
 451
 452   InputTaskManager::Get()->IncSuspensionLevel();
 453   mHasIncreasedInputTaskManagerSuspensionLevel = true;
 454 }
 455
 456 void BrowsingContextGroup::UpdateInputTaskManagerIfNeeded(bool aIsActive) {
 457   MOZ_ASSERT(StaticPrefs::dom_input_events_canSuspendInBCG_enabled());
 458   if (!aIsActive) {
 459     if (mHasIncreasedInputTaskManagerSuspensionLevel) {
 460       MOZ_ASSERT(mInputEventSuspensionLevel > 0);
 461       if (!HasActiveBC()) {
 462         DecInputTaskManagerSuspensionLevel();
 463       }
 464     }
 465   } else {
 466     if (mInputEventSuspensionLevel &&
 467         !mHasIncreasedInputTaskManagerSuspensionLevel) {
 468       IncInputTaskManagerSuspensionLevel();
 469     }
 470   }
 471 }
 472
 473 /* static */
 474 BrowsingContextGroup* BrowsingContextGroup::GetChromeGroup() {
 475   MOZ_DIAGNOSTIC_ASSERT(XRE_IsParentProcess());
 476   if (!sChromeGroup && XRE_IsParentProcess()) {
 477     sChromeGroup = BrowsingContextGroup::Create();
 478     ClearOnShutdown(&sChromeGroup);
 479   }
 480
 481   return sChromeGroup;
 482 }
 483
 484 void BrowsingContextGroup::GetDocGroups(nsTArray<DocGroup*>& aDocGroups) {
 485   MOZ_ASSERT(NS_IsMainThread());
 486   AppendToArray(aDocGroups, mDocGroups.Values());
 487 }
 488
 489 already_AddRefed<DocGroup> BrowsingContextGroup::AddDocument(
 490     const nsACString& aKey, Document* aDocument) {
 491   MOZ_ASSERT(NS_IsMainThread());
 492
 493   RefPtr<DocGroup>& docGroup = mDocGroups.LookupOrInsertWith(
 494       aKey, [&] { return DocGroup::Create(this, aKey); });
 495
 496   docGroup->AddDocument(aDocument);
 497   return do_AddRef(docGroup);
 498 }
 499
 500 void BrowsingContextGroup::RemoveDocument(Document* aDocument,
 501                                           DocGroup* aDocGroup) {
 502   MOZ_ASSERT(NS_IsMainThread());
 503   RefPtr<DocGroup> docGroup = aDocGroup;
 504   // Removing the last document in DocGroup might decrement the
 505   // DocGroup BrowsingContextGroup's refcount to 0.
 506   RefPtr<BrowsingContextGroup> kungFuDeathGrip(this);
 507   docGroup->RemoveDocument(aDocument);
 508
 509   if (docGroup->IsEmpty()) {
 510     mDocGroups.Remove(docGroup->GetKey());
 511   }
 512 }
 513
 514 already_AddRefed<BrowsingContextGroup> BrowsingContextGroup::Select(
 515     WindowContext* aParent, BrowsingContext* aOpener) {
 516   if (aParent) {
 517     return do_AddRef(aParent->Group());
 518   }
 519   if (aOpener) {
 520     return do_AddRef(aOpener->Group());
 521   }
 522   return Create();
 523 }
 524
 525 void BrowsingContextGroup::GetAllGroups(
 526     nsTArray<RefPtr<BrowsingContextGroup>>& aGroups) {
 527   aGroups.Clear();
 528   if (!sBrowsingContextGroups) {
 529     return;
 530   }
 531
 532   aGroups = ToArray(sBrowsingContextGroups->Values());
 533 }
 534
 535 // For tests only.
 536 void BrowsingContextGroup::ResetDialogAbuseState() {
 537   mDialogAbuseCount = 0;
 538   // Reset the timer.
 539   mLastDialogQuitTime =
 540       TimeStamp::Now() -
 541       TimeDuration::FromSeconds(DEFAULT_SUCCESSIVE_DIALOG_TIME_LIMIT);
 542 }
 543
 544 bool BrowsingContextGroup::DialogsAreBeingAbused() {
 545   if (mLastDialogQuitTime.IsNull() || nsContentUtils::IsCallerChrome()) {
 546     return false;
 547   }
 548
 549   TimeDuration dialogInterval(TimeStamp::Now() - mLastDialogQuitTime);
 550   if (dialogInterval.ToSeconds() <
 551       Preferences::GetInt("dom.successive_dialog_time_limit",
 552                           DEFAULT_SUCCESSIVE_DIALOG_TIME_LIMIT)) {
 553     mDialogAbuseCount++;
 554
 555     return PopupBlocker::GetPopupControlState() > PopupBlocker::openAllowed ||
 556            mDialogAbuseCount > MAX_SUCCESSIVE_DIALOG_COUNT;
 557   }
 558
 559   // Reset the abuse counter
 560   mDialogAbuseCount = 0;
 561
 562   return false;
 563 }
 564
 565 bool BrowsingContextGroup::IsPotentiallyCrossOriginIsolated() {
 566   return GetBrowsingContextGroupIdFlags(mId) &
 567          kPotentiallyCrossOriginIsolatedFlag;
 568 }
 569
 570 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(BrowsingContextGroup, mContexts,
 571                                       mToplevels, mHosts, mSubscribers,
 572                                       mTimerEventQueue, mWorkerEventQueue,
 573                                       mDocGroups)
 574
 575 }  // namespace dom
 576 }  // namespace mozilla