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


content / browser / worker_host / dedicated_worker_hosts_for_document.cc [blame]

// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "content/browser/worker_host/dedicated_worker_hosts_for_document.h"

#include "content/browser/renderer_host/render_frame_host_impl.h"
#include "content/browser/service_worker/service_worker_client.h"
#include "content/browser/worker_host/dedicated_worker_host.h"

namespace content {

DedicatedWorkerHostsForDocument::DedicatedWorkerHostsForDocument(
    RenderFrameHost* rfh)
    : DocumentUserData<DedicatedWorkerHostsForDocument>(rfh),
      dedicated_workers_([](const base::SafeRef<DedicatedWorkerHost>& lhs,
                            const base::SafeRef<DedicatedWorkerHost>& rhs) {
        return &*lhs < &*rhs;
      }) {}

DedicatedWorkerHostsForDocument::~DedicatedWorkerHostsForDocument() = default;

void DedicatedWorkerHostsForDocument::Add(
    base::SafeRef<DedicatedWorkerHost> dedicated_worker_host) {
  dedicated_workers_.insert(dedicated_worker_host);
}

void DedicatedWorkerHostsForDocument::Remove(
    base::SafeRef<DedicatedWorkerHost> dedicated_worker_host) {
  dedicated_workers_.erase(dedicated_worker_host);
}

blink::scheduler::WebSchedulerTrackedFeatures
DedicatedWorkerHostsForDocument::GetBackForwardCacheDisablingFeatures() const {
  RenderFrameHostImpl::BackForwardCacheDisablingFeatures features;
  for (auto& feature_detail : GetBackForwardCacheBlockingDetails()) {
    features.Put(static_cast<blink::scheduler::WebSchedulerTrackedFeature>(
        feature_detail->feature));
  }
  return features;
}

DedicatedWorkerHost::BackForwardCacheBlockingDetails
DedicatedWorkerHostsForDocument::GetBackForwardCacheBlockingDetails() const {
  DedicatedWorkerHost::BackForwardCacheBlockingDetails combined_details;
  for (auto worker : dedicated_workers_) {
    auto& details_for_worker = worker->GetBackForwardCacheBlockingDetails();
    for (auto& details : details_for_worker) {
      combined_details.push_back(details.Clone());
    }
  }
  return combined_details;
}

void DedicatedWorkerHostsForDocument::OnEnterBackForwardCache() {
  DCHECK(BackForwardCache::IsBackForwardCacheFeatureEnabled());
  DCHECK_EQ(render_frame_host().GetLifecycleState(),
            RenderFrameHost::LifecycleState::kInBackForwardCache);

  for (auto worker : dedicated_workers_) {
    if (base::WeakPtr<ServiceWorkerClient> service_worker_client =
            worker->GetServiceWorkerClient()) {
      service_worker_client->OnEnterBackForwardCache();
    }
  }
}

void DedicatedWorkerHostsForDocument::OnRestoreFromBackForwardCache() {
  DCHECK(BackForwardCache::IsBackForwardCacheFeatureEnabled());
  DCHECK_EQ(render_frame_host().GetLifecycleState(),
            RenderFrameHost::LifecycleState::kInBackForwardCache);

  for (auto worker : dedicated_workers_) {
    if (base::WeakPtr<ServiceWorkerClient> service_worker_client =
            worker->GetServiceWorkerClient()) {
      service_worker_client->OnRestoreFromBackForwardCache();
    }
  }
}

void DedicatedWorkerHostsForDocument::UpdateSubresourceLoaderFactories() {
  for (auto worker : dedicated_workers_) {
    worker->UpdateSubresourceLoaderFactories();
  }
}

DOCUMENT_USER_DATA_KEY_IMPL(DedicatedWorkerHostsForDocument);

}  // namespace content