content/browser/cookie_store/cookie_store_manager.cc - chromium/src - Git at Google

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

 #include "content/browser/cookie_store/cookie_store_manager.h"

 #include <utility>

 #include "base/optional.h"
 #include "content/browser/cookie_store/cookie_change_subscriptions.pb.h"
 #include "content/browser/service_worker/embedded_worker_status.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/common/service_worker/service_worker_status_code.h"
 #include "content/public/browser/browser_context.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "third_party/blink/public/mojom/service_worker/service_worker_event_status.mojom.h"
 #include "url/gurl.h"

 namespace content {

 namespace {

 // ServiceWorkerStorage user data key for cookie change subscriptions.
 const char kSubscriptionsUserKey[] = "cookie_store_subscriptions";

 // Handles the result of ServiceWorkerContextWrapper::StoreRegistrationUserData.
 void HandleStoreRegistrationUserDataStatus(ServiceWorkerStatusCode status) {
   // The current implementation does not have a good way to handle errors in
   // StoreRegistrationUserData. Cookie change subscriptions have been added to
   // the registration during the install event, so it's too late to surface the
   // error to the renderer. The registration has already been persisted, and the
   // Service Worker is likely active by now.
   DLOG_IF(ERROR, status != SERVICE_WORKER_OK)
       << "StoreRegistrationUserData failed";
 }

 }  // namespace

 CookieStoreManager::CookieStoreManager(
     scoped_refptr<ServiceWorkerContextWrapper> service_worker_context)
     : service_worker_context_(std::move(service_worker_context)),
       cookie_change_listener_binding_(this),
       registration_user_data_key_(kSubscriptionsUserKey),
       weak_factory_(this) {
   service_worker_context_->AddObserver(this);
 }

 CookieStoreManager::~CookieStoreManager() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   service_worker_context_->RemoveObserver(this);
 }

 void CookieStoreManager::CreateService(blink::mojom::CookieStoreRequest request,
                                        const url::Origin& origin) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

   bindings_.AddBinding(std::make_unique<CookieStoreHost>(this, origin),
                        std::move(request));
 }

 void CookieStoreManager::LoadAllSubscriptions(
     base::OnceCallback<void(bool)> callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

   DCHECK(!done_loading_subscriptions_) << __func__ << " already called";

   service_worker_context_->GetUserDataForAllRegistrations(
       registration_user_data_key_,
       base::BindOnce(&CookieStoreManager::ProcessOnDiskSubscriptions,
                      weak_factory_.GetWeakPtr(), std::move(callback)));
 }

 void CookieStoreManager::ListenToCookieChanges(
     ::network::mojom::CookieManagerPtr cookie_manager,
     base::OnceCallback<void(bool)> callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

   DCHECK(!cookie_manager_) << __func__ << " already called";
   cookie_manager_ = std::move(cookie_manager);

   DCHECK(!cookie_change_listener_binding_.is_bound());
   ::network::mojom::CookieChangeListenerPtr cookie_change_listener;
   cookie_change_listener_binding_.Bind(
       mojo::MakeRequest(&cookie_change_listener));

   // TODO(pwnall): Switch to an API with subscription confirmation.
   cookie_manager_->AddGlobalChangeListener(std::move(cookie_change_listener));
   std::move(callback).Run(true);
 }

 void CookieStoreManager::ProcessOnDiskSubscriptions(
     base::OnceCallback<void(bool)> load_callback,
     const std::vector<std::pair<int64_t, std::string>>& user_data,
     ServiceWorkerStatusCode status) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

   DCHECK(!done_loading_subscriptions_) << __func__ << " already called";
   done_loading_subscriptions_ = true;

   if (status != SERVICE_WORKER_OK) {
     DidLoadAllSubscriptions(false, std::move(load_callback));
     return;
   }

   DCHECK(subscriptions_by_registration_.empty());
   subscriptions_by_registration_.reserve(user_data.size());
   bool load_success = true;
   for (const auto& pair : user_data) {
     int64_t service_worker_registration_id = pair.first;
     const std::string& proto_string = pair.second;

     base::Optional<std::vector<CookieChangeSubscription>> subscriptions_opt =
         CookieChangeSubscription::DeserializeVector(
             proto_string, service_worker_registration_id);
     if (!subscriptions_opt.has_value()) {
       load_success = false;
       continue;
     }

     ActivateSubscriptions(&subscriptions_opt.value());
     DCHECK(
         !subscriptions_by_registration_.count(service_worker_registration_id));
     subscriptions_by_registration_.emplace(
         std::move(service_worker_registration_id),
         std::move(subscriptions_opt).value());
   }

   DidLoadAllSubscriptions(load_success, std::move(load_callback));
 }

 void CookieStoreManager::DidLoadAllSubscriptions(
     bool succeeded,
     base::OnceCallback<void(bool)> load_callback) {
   DCHECK(done_loading_subscriptions_);
   succeeded_loading_subscriptions_ = succeeded;

   for (auto& callback : subscriptions_loaded_callbacks_)
     std::move(callback).Run();
   subscriptions_loaded_callbacks_.clear();

   std::move(load_callback).Run(succeeded);
 }

 void CookieStoreManager::AppendSubscriptions(
     int64_t service_worker_registration_id,
     const GURL& origin,
     std::vector<blink::mojom::CookieChangeSubscriptionPtr> mojo_subscriptions,
     blink::mojom::CookieStore::AppendSubscriptionsCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

   if (!done_loading_subscriptions_) {
     subscriptions_loaded_callbacks_.emplace_back(base::BindOnce(
         &CookieStoreManager::AppendSubscriptions, weak_factory_.GetWeakPtr(),
         service_worker_registration_id, origin, std::move(mojo_subscriptions),
         std::move(callback)));
     return;
   }

   if (!succeeded_loading_subscriptions_) {
     std::move(callback).Run(false);
     return;
   }

   // GetLiveRegistration() is sufficient here (as opposed to a flavor of
   // FindRegistration()) because AppendSubscriptions is only called from the
   // implementation of the Cookie Store API, which is exposed to
   // ServiceWorkerGlobalScope. ServiceWorkerGlobalScope references the
   // service worker's registration via a ServiceWorkerRegistration JavaScript
   // object, so the registration is guaranteed to be live while the service
   // worker is executing.
   //
   // It is possible for the service worker to get killed while this API call is
   // in progress, for example, if the service worker code exceeds an event
   // handling time limit. In that case, the return value will not be observed,
   // so a false negative is acceptable.
   ServiceWorkerRegistration* service_worker_registration =
       service_worker_context_->GetLiveRegistration(
           service_worker_registration_id);
   if (!service_worker_registration) {
     // This error case is a good fit for mojo::ReportBadMessage(), because the
     // renderer has passed an invalid registration ID. However, the code here
     // might run without a mojo call context, if the original call was delayed
     // while loading on-disk subscription data.
     //
     // While it would be possible to have two code paths for the two situations,
     // the extra complexity doesn't seem warranted for the limited debuggig
     // benefits provided by mojo::ReportBadMessage.
     std::move(callback).Run(false);
     return;
   }

   // TODO(crbug.com/843079): This check incorrectly allows an active service
   //                         worker version to call the API, if another version
   //                         is installing at the same time.
   if (!service_worker_registration->installing_version()) {
     // A service worker's cookie change subscriptions can only be modified while
     // the service worker's install event is handled.
     std::move(callback).Run(false);
     return;
   }

   if (mojo_subscriptions.empty()) {
     // Empty subscriptions are special-cased so we never have to serialize an
     // empty array of subscriptions. This is advantageous because the protobuf
     // serialization of an empty array is the empty string, which is also used
     // by the convenience protobuf serialization API to signal serialization
     // failure. So, supporting serializing an empty array would mean we can't
     // use the convenience serialization API.
     std::move(callback).Run(true);
     return;
   }

   std::vector<CookieChangeSubscription> new_subscriptions =
       CookieChangeSubscription::FromMojoVector(
           std::move(mojo_subscriptions), service_worker_registration->id());
   DCHECK(!new_subscriptions.empty());

   auto old_subscriptions_it =
       subscriptions_by_registration_.find(service_worker_registration_id);
   if (old_subscriptions_it == subscriptions_by_registration_.end()) {
     subscriptions_by_registration_.emplace(service_worker_registration_id,
                                            std::move(new_subscriptions));
     std::move(callback).Run(true);
     return;
   }

   std::vector<CookieChangeSubscription>& old_subscriptions =
       old_subscriptions_it->second;
   old_subscriptions.reserve(old_subscriptions.size() +
                             new_subscriptions.size());
   for (auto& new_subscription : new_subscriptions)
     old_subscriptions.emplace_back(std::move(new_subscription));

   std::move(callback).Run(true);
 }

 void CookieStoreManager::GetSubscriptions(
     int64_t service_worker_registration_id,
     const GURL& origin,
     blink::mojom::CookieStore::GetSubscriptionsCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

   if (!done_loading_subscriptions_) {
     subscriptions_loaded_callbacks_.emplace_back(base::BindOnce(
         &CookieStoreManager::GetSubscriptions, weak_factory_.GetWeakPtr(),
         service_worker_registration_id, origin, std::move(callback)));
     return;
   }

   if (!succeeded_loading_subscriptions_) {
     std::move(callback).Run(
         std::vector<blink::mojom::CookieChangeSubscriptionPtr>(), false);
     return;
   }

   auto it = subscriptions_by_registration_.find(service_worker_registration_id);
   if (it == subscriptions_by_registration_.end()) {
     std::move(callback).Run(
         std::vector<blink::mojom::CookieChangeSubscriptionPtr>(), true);
     return;
   }

   std::move(callback).Run(CookieChangeSubscription::ToMojoVector(it->second),
                           true);
 }

 void CookieStoreManager::OnNewLiveRegistration(
     int64_t service_worker_registration_id,
     const GURL& pattern) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }

 void CookieStoreManager::OnRegistrationStored(
     int64_t service_worker_registration_id,
     const GURL& pattern) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

   // Waiting for the on-disk subscriptions to be loaded ensures that the
   // registration's subscriptions aren't activated twice. Without waiting,
   // there's a risk that LoadAllSubscriptions() sees the result of the
   // StoreRegistrationUserData() call below.
   if (!done_loading_subscriptions_) {
     subscriptions_loaded_callbacks_.emplace_back(base::BindOnce(
         &CookieStoreManager::OnRegistrationStored, weak_factory_.GetWeakPtr(),
         service_worker_registration_id, pattern));
     return;
   }

   auto it = subscriptions_by_registration_.find(service_worker_registration_id);
   if (it == subscriptions_by_registration_.end())
     return;

   ActivateSubscriptions(&it->second);

   std::string subscriptions_data =
       CookieChangeSubscription::SerializeVector(it->second);
   DCHECK(!subscriptions_data.empty())
       << "Failed to create cookie change subscriptions protobuf";

   service_worker_context_->StoreRegistrationUserData(
       service_worker_registration_id, pattern.GetOrigin(),
       std::vector<std::pair<std::string, std::string>>(
           {{registration_user_data_key_, subscriptions_data}}),
       base::BindOnce(&HandleStoreRegistrationUserDataStatus));
 }

 void CookieStoreManager::OnRegistrationDeleted(
     int64_t service_worker_registration_id,
     const GURL& pattern) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

   // Waiting for the on-disk subscriptions to be loaded ensures that the
   // registration's subscriptions are removed. Without waiting, there's a risk
   // that a registration's subscriptions will finish loading (and thus remain
   // active) right after this function runs.
   if (!done_loading_subscriptions_) {
     subscriptions_loaded_callbacks_.emplace_back(base::BindOnce(
         &CookieStoreManager::OnRegistrationDeleted, weak_factory_.GetWeakPtr(),
         service_worker_registration_id, pattern));
     return;
   }

   auto it = subscriptions_by_registration_.find(service_worker_registration_id);
   if (it == subscriptions_by_registration_.end())
     return;

   DeactivateSubscriptions(&it->second);
   subscriptions_by_registration_.erase(it);
 }

 void CookieStoreManager::ActivateSubscriptions(
     std::vector<CookieChangeSubscription>* subscriptions) {
   if (subscriptions->empty())
     return;

   // Service workers can only observe changes to cookies for URLs under their
   // scope. This means all the URLs that the worker is observing must map to the
   // same domain key (eTLD+1).
   //
   // TODO(pwnall): This is the same as implementation as
   //               net::CookieMonsterChangeDispatcher::DomainKey. Extract that
   //               implementation into net/cookies.cookie_util.h and call it.
   std::string url_key = net::registry_controlled_domains::GetDomainAndRegistry(

       (*subscriptions)[0].url(),
       net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
   base::LinkedList<CookieChangeSubscription>& url_key_subscriptions_list =
       subscriptions_by_url_key_[url_key];

   for (auto& subscription : *subscriptions) {
     DCHECK(!subscription.next() && !subscription.previous())
         << "Subscription passed to " << __func__ << " already activated";
     DCHECK_EQ(url_key,
               net::registry_controlled_domains::GetDomainAndRegistry(
                   subscription.url(),
                   net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES))
         << __func__ << " subscriptions belong to different registrations";
     url_key_subscriptions_list.Append(&subscription);
   }
 }

 void CookieStoreManager::DeactivateSubscriptions(
     std::vector<CookieChangeSubscription>* subscriptions) {
   if (subscriptions->empty())
     return;

   // Service workers can only observe changes to cookies for URLs under their
   // scope. This means all the URLs that the worker is observing must map to the
   // same domain key (eTLD+1).
   //
   // TODO(pwnall): This has the same implementation as
   //               net::CookieMonsterChangeDispatcher::DomainKey. Extract that
   //               implementation into net/cookies.cookie_util.h and call it.
   std::string url_key = net::registry_controlled_domains::GetDomainAndRegistry(
       (*subscriptions)[0].url(),
       net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
   for (auto& subscription : *subscriptions) {
     DCHECK(subscription.next() && subscription.previous())
         << "Subscription passed to " << __func__ << " not previously activated";
     DCHECK_EQ(url_key,
               net::registry_controlled_domains::GetDomainAndRegistry(
                   subscription.url(),
                   net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES))
         << __func__ << " subscriptions belong to different registrations";
     subscription.RemoveFromList();
   }
   auto it = subscriptions_by_url_key_.find(url_key);
   DCHECK(it != subscriptions_by_url_key_.end());
   if (it->second.empty())
     subscriptions_by_url_key_.erase(it);
 }

 void CookieStoreManager::OnStorageWiped() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

   // Waiting for the on-disk subscriptions to be loaded ensures that all
   // subscriptions are removed. Without waiting, there's a risk that some
   // subscriptions will finish loading (and thus remain active) after this
   // function runs.
   if (!done_loading_subscriptions_) {
     subscriptions_loaded_callbacks_.emplace_back(base::BindOnce(
         &CookieStoreManager::OnStorageWiped, weak_factory_.GetWeakPtr()));
     return;
   }

   subscriptions_by_url_key_.clear();
   subscriptions_by_registration_.clear();
 }

 void CookieStoreManager::OnCookieChange(
     const net::CanonicalCookie& cookie,
     ::network::mojom::CookieChangeCause cause) {
   // Waiting for on-disk subscriptions to be loaded ensures that changes are
   // delivered to all service workers that subscribed to them in previous
   // browser sessions. Without waiting, workers might miss cookie changes.
   if (!done_loading_subscriptions_) {
     subscriptions_loaded_callbacks_.emplace_back(
         base::BindOnce(&CookieStoreManager::OnCookieChange,
                        weak_factory_.GetWeakPtr(), cookie, cause));
     return;
   }

   // Compute the list of service workers interested in this change. A worker
   // might have multiple subscriptions that cover this change, but should still
   // receive a single change event.
   // TODO(pwnall): This has same as implementation as
   //               net::CookieMonsterChangeDispatcher::DomainKey. Extract that
   //               implementation into net/cookies.cookie_util.h and call it.
   std::string url_key = net::registry_controlled_domains::GetDomainAndRegistry(
       cookie.Domain(),
       net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
   auto it = subscriptions_by_url_key_.find(url_key);
   if (it == subscriptions_by_url_key_.end())
     return;
   std::set<int64_t> interested_registration_ids;
   const base::LinkedList<CookieChangeSubscription>& subscriptions = it->second;
   for (const base::LinkNode<CookieChangeSubscription>* node =
            subscriptions.head();
        node != subscriptions.end(); node = node->next()) {
     const CookieChangeSubscription* subscription = node->value();
     if (subscription->ShouldObserveChangeTo(cookie)) {
       interested_registration_ids.insert(
           subscription->service_worker_registration_id());
     }
   }

   // Dispatch the change to interested workers.
   for (int64_t registration_id : interested_registration_ids) {
     service_worker_context_->FindReadyRegistrationForIdOnly(
         registration_id,
         base::BindOnce(
             [](base::WeakPtr<CookieStoreManager> manager,
                const net::CanonicalCookie& cookie,
                ::network::mojom::CookieChangeCause cause,
                ServiceWorkerStatusCode find_status,
                scoped_refptr<ServiceWorkerRegistration> registration) {
               if (find_status != SERVICE_WORKER_OK)
                 return;

               DCHECK(registration);
               if (!manager)
                 return;
               manager->DispatchChangeEvent(std::move(registration), cookie,
                                            cause);
             },
             weak_factory_.GetWeakPtr(), cookie, cause));
   }
 }

 void CookieStoreManager::DispatchChangeEvent(
     scoped_refptr<ServiceWorkerRegistration> registration,
     const net::CanonicalCookie& cookie,
     ::network::mojom::CookieChangeCause cause) {
   scoped_refptr<ServiceWorkerVersion> active_version =
       registration->active_version();
   if (active_version->running_status() != EmbeddedWorkerStatus::RUNNING) {
     active_version->RunAfterStartWorker(
         ServiceWorkerMetrics::EventType::COOKIE_CHANGE,
         base::BindOnce(&CookieStoreManager::DidStartWorkerForChangeEvent,
                        weak_factory_.GetWeakPtr(), std::move(registration),
                        cookie, cause));
     return;
   }

   int request_id = active_version->StartRequest(
       ServiceWorkerMetrics::EventType::COOKIE_CHANGE, base::DoNothing());

   active_version->event_dispatcher()->DispatchCookieChangeEvent(
       cookie, cause, active_version->CreateSimpleEventCallback(request_id));
 }

 void CookieStoreManager::DidStartWorkerForChangeEvent(
     scoped_refptr<ServiceWorkerRegistration> registration,
     const net::CanonicalCookie& cookie,
     ::network::mojom::CookieChangeCause cause,
     ServiceWorkerStatusCode start_worker_status) {
   if (start_worker_status != SERVICE_WORKER_OK)
     return;
   DispatchChangeEvent(std::move(registration), cookie, cause);
 }

 }  // namespace content
	// Copyright 2018 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "content/browser/cookie_store/cookie_store_manager.h"

	#include <utility>

	#include "base/optional.h"
	#include "content/browser/cookie_store/cookie_change_subscriptions.pb.h"
	#include "content/browser/service_worker/embedded_worker_status.h"
	#include "content/browser/service_worker/service_worker_context_wrapper.h"
	#include "content/browser/service_worker/service_worker_metrics.h"
	#include "content/browser/service_worker/service_worker_registration.h"
	#include "content/browser/service_worker/service_worker_version.h"
	#include "content/common/service_worker/service_worker_status_code.h"
	#include "content/public/browser/browser_context.h"
	#include "net/base/registry_controlled_domains/registry_controlled_domain.h"
	#include "third_party/blink/public/mojom/service_worker/service_worker_event_status.mojom.h"
	#include "url/gurl.h"

	namespace content {

	namespace {

	// ServiceWorkerStorage user data key for cookie change subscriptions.
	const char kSubscriptionsUserKey[] = "cookie_store_subscriptions";

	// Handles the result of ServiceWorkerContextWrapper::StoreRegistrationUserData.
	void HandleStoreRegistrationUserDataStatus(ServiceWorkerStatusCode status) {
	// The current implementation does not have a good way to handle errors in
	// StoreRegistrationUserData. Cookie change subscriptions have been added to
	// the registration during the install event, so it's too late to surface the
	// error to the renderer. The registration has already been persisted, and the
	// Service Worker is likely active by now.
	DLOG_IF(ERROR, status != SERVICE_WORKER_OK)
	<< "StoreRegistrationUserData failed";
	}

	} // namespace

	CookieStoreManager::CookieStoreManager(
	scoped_refptr<ServiceWorkerContextWrapper> service_worker_context)
	: service_worker_context_(std::move(service_worker_context)),
	cookie_change_listener_binding_(this),
	registration_user_data_key_(kSubscriptionsUserKey),
	weak_factory_(this) {
	service_worker_context_->AddObserver(this);
	}

	CookieStoreManager::~CookieStoreManager() {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
	service_worker_context_->RemoveObserver(this);
	}

	void CookieStoreManager::CreateService(blink::mojom::CookieStoreRequest request,
	const url::Origin& origin) {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

	bindings_.AddBinding(std::make_unique<CookieStoreHost>(this, origin),
	std::move(request));
	}

	void CookieStoreManager::LoadAllSubscriptions(
	base::OnceCallback<void(bool)> callback) {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

	DCHECK(!done_loading_subscriptions_) << __func__ << " already called";

	service_worker_context_->GetUserDataForAllRegistrations(
	registration_user_data_key_,
	base::BindOnce(&CookieStoreManager::ProcessOnDiskSubscriptions,
	weak_factory_.GetWeakPtr(), std::move(callback)));
	}

	void CookieStoreManager::ListenToCookieChanges(
	::network::mojom::CookieManagerPtr cookie_manager,
	base::OnceCallback<void(bool)> callback) {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

	DCHECK(!cookie_manager_) << __func__ << " already called";
	cookie_manager_ = std::move(cookie_manager);

	DCHECK(!cookie_change_listener_binding_.is_bound());
	::network::mojom::CookieChangeListenerPtr cookie_change_listener;
	cookie_change_listener_binding_.Bind(
	mojo::MakeRequest(&cookie_change_listener));

	// TODO(pwnall): Switch to an API with subscription confirmation.
	cookie_manager_->AddGlobalChangeListener(std::move(cookie_change_listener));
	std::move(callback).Run(true);
	}

	void CookieStoreManager::ProcessOnDiskSubscriptions(
	base::OnceCallback<void(bool)> load_callback,
	const std::vector<std::pair<int64_t, std::string>>& user_data,
	ServiceWorkerStatusCode status) {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

	DCHECK(!done_loading_subscriptions_) << __func__ << " already called";
	done_loading_subscriptions_ = true;

	if (status != SERVICE_WORKER_OK) {
	DidLoadAllSubscriptions(false, std::move(load_callback));
	return;
	}

	DCHECK(subscriptions_by_registration_.empty());
	subscriptions_by_registration_.reserve(user_data.size());
	bool load_success = true;
	for (const auto& pair : user_data) {
	int64_t service_worker_registration_id = pair.first;
	const std::string& proto_string = pair.second;

	base::Optional<std::vector<CookieChangeSubscription>> subscriptions_opt =
	CookieChangeSubscription::DeserializeVector(
	proto_string, service_worker_registration_id);
	if (!subscriptions_opt.has_value()) {
	load_success = false;
	continue;
	}

	ActivateSubscriptions(&subscriptions_opt.value());
	DCHECK(
	!subscriptions_by_registration_.count(service_worker_registration_id));
	subscriptions_by_registration_.emplace(
	std::move(service_worker_registration_id),
	std::move(subscriptions_opt).value());
	}

	DidLoadAllSubscriptions(load_success, std::move(load_callback));
	}

	void CookieStoreManager::DidLoadAllSubscriptions(
	bool succeeded,
	base::OnceCallback<void(bool)> load_callback) {
	DCHECK(done_loading_subscriptions_);
	succeeded_loading_subscriptions_ = succeeded;

	for (auto& callback : subscriptions_loaded_callbacks_)
	std::move(callback).Run();
	subscriptions_loaded_callbacks_.clear();

	std::move(load_callback).Run(succeeded);
	}

	void CookieStoreManager::AppendSubscriptions(
	int64_t service_worker_registration_id,
	const GURL& origin,
	std::vector<blink::mojom::CookieChangeSubscriptionPtr> mojo_subscriptions,
	blink::mojom::CookieStore::AppendSubscriptionsCallback callback) {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

	if (!done_loading_subscriptions_) {
	subscriptions_loaded_callbacks_.emplace_back(base::BindOnce(
	&CookieStoreManager::AppendSubscriptions, weak_factory_.GetWeakPtr(),
	service_worker_registration_id, origin, std::move(mojo_subscriptions),
	std::move(callback)));
	return;
	}

	if (!succeeded_loading_subscriptions_) {
	std::move(callback).Run(false);
	return;
	}

	// GetLiveRegistration() is sufficient here (as opposed to a flavor of
	// FindRegistration()) because AppendSubscriptions is only called from the
	// implementation of the Cookie Store API, which is exposed to
	// ServiceWorkerGlobalScope. ServiceWorkerGlobalScope references the
	// service worker's registration via a ServiceWorkerRegistration JavaScript
	// object, so the registration is guaranteed to be live while the service
	// worker is executing.
	//
	// It is possible for the service worker to get killed while this API call is
	// in progress, for example, if the service worker code exceeds an event
	// handling time limit. In that case, the return value will not be observed,
	// so a false negative is acceptable.
	ServiceWorkerRegistration* service_worker_registration =
	service_worker_context_->GetLiveRegistration(
	service_worker_registration_id);
	if (!service_worker_registration) {
	// This error case is a good fit for mojo::ReportBadMessage(), because the
	// renderer has passed an invalid registration ID. However, the code here
	// might run without a mojo call context, if the original call was delayed
	// while loading on-disk subscription data.
	//
	// While it would be possible to have two code paths for the two situations,
	// the extra complexity doesn't seem warranted for the limited debuggig
	// benefits provided by mojo::ReportBadMessage.
	std::move(callback).Run(false);
	return;
	}

	// TODO(crbug.com/843079): This check incorrectly allows an active service
	// worker version to call the API, if another version
	// is installing at the same time.
	if (!service_worker_registration->installing_version()) {
	// A service worker's cookie change subscriptions can only be modified while
	// the service worker's install event is handled.
	std::move(callback).Run(false);
	return;
	}

	if (mojo_subscriptions.empty()) {
	// Empty subscriptions are special-cased so we never have to serialize an
	// empty array of subscriptions. This is advantageous because the protobuf
	// serialization of an empty array is the empty string, which is also used
	// by the convenience protobuf serialization API to signal serialization
	// failure. So, supporting serializing an empty array would mean we can't
	// use the convenience serialization API.
	std::move(callback).Run(true);
	return;
	}

	std::vector<CookieChangeSubscription> new_subscriptions =
	CookieChangeSubscription::FromMojoVector(
	std::move(mojo_subscriptions), service_worker_registration->id());
	DCHECK(!new_subscriptions.empty());

	auto old_subscriptions_it =
	subscriptions_by_registration_.find(service_worker_registration_id);
	if (old_subscriptions_it == subscriptions_by_registration_.end()) {
	subscriptions_by_registration_.emplace(service_worker_registration_id,
	std::move(new_subscriptions));
	std::move(callback).Run(true);
	return;
	}

	std::vector<CookieChangeSubscription>& old_subscriptions =
	old_subscriptions_it->second;
	old_subscriptions.reserve(old_subscriptions.size() +
	new_subscriptions.size());
	for (auto& new_subscription : new_subscriptions)
	old_subscriptions.emplace_back(std::move(new_subscription));

	std::move(callback).Run(true);
	}

	void CookieStoreManager::GetSubscriptions(
	int64_t service_worker_registration_id,
	const GURL& origin,
	blink::mojom::CookieStore::GetSubscriptionsCallback callback) {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

	if (!done_loading_subscriptions_) {
	subscriptions_loaded_callbacks_.emplace_back(base::BindOnce(
	&CookieStoreManager::GetSubscriptions, weak_factory_.GetWeakPtr(),
	service_worker_registration_id, origin, std::move(callback)));
	return;
	}

	if (!succeeded_loading_subscriptions_) {
	std::move(callback).Run(
	std::vector<blink::mojom::CookieChangeSubscriptionPtr>(), false);
	return;
	}

	auto it = subscriptions_by_registration_.find(service_worker_registration_id);
	if (it == subscriptions_by_registration_.end()) {
	std::move(callback).Run(
	std::vector<blink::mojom::CookieChangeSubscriptionPtr>(), true);
	return;
	}

	std::move(callback).Run(CookieChangeSubscription::ToMojoVector(it->second),
	true);
	}

	void CookieStoreManager::OnNewLiveRegistration(
	int64_t service_worker_registration_id,
	const GURL& pattern) {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
	}

	void CookieStoreManager::OnRegistrationStored(
	int64_t service_worker_registration_id,
	const GURL& pattern) {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

	// Waiting for the on-disk subscriptions to be loaded ensures that the
	// registration's subscriptions aren't activated twice. Without waiting,
	// there's a risk that LoadAllSubscriptions() sees the result of the
	// StoreRegistrationUserData() call below.
	if (!done_loading_subscriptions_) {
	subscriptions_loaded_callbacks_.emplace_back(base::BindOnce(
	&CookieStoreManager::OnRegistrationStored, weak_factory_.GetWeakPtr(),
	service_worker_registration_id, pattern));
	return;
	}

	auto it = subscriptions_by_registration_.find(service_worker_registration_id);
	if (it == subscriptions_by_registration_.end())
	return;

	ActivateSubscriptions(&it->second);

	std::string subscriptions_data =
	CookieChangeSubscription::SerializeVector(it->second);
	DCHECK(!subscriptions_data.empty())
	<< "Failed to create cookie change subscriptions protobuf";

	service_worker_context_->StoreRegistrationUserData(
	service_worker_registration_id, pattern.GetOrigin(),
	std::vector<std::pair<std::string, std::string>>(
	{{registration_user_data_key_, subscriptions_data}}),
	base::BindOnce(&HandleStoreRegistrationUserDataStatus));
	}

	void CookieStoreManager::OnRegistrationDeleted(
	int64_t service_worker_registration_id,
	const GURL& pattern) {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

	// Waiting for the on-disk subscriptions to be loaded ensures that the
	// registration's subscriptions are removed. Without waiting, there's a risk
	// that a registration's subscriptions will finish loading (and thus remain
	// active) right after this function runs.
	if (!done_loading_subscriptions_) {
	subscriptions_loaded_callbacks_.emplace_back(base::BindOnce(
	&CookieStoreManager::OnRegistrationDeleted, weak_factory_.GetWeakPtr(),
	service_worker_registration_id, pattern));
	return;
	}

	auto it = subscriptions_by_registration_.find(service_worker_registration_id);
	if (it == subscriptions_by_registration_.end())
	return;

	DeactivateSubscriptions(&it->second);
	subscriptions_by_registration_.erase(it);
	}

	void CookieStoreManager::ActivateSubscriptions(
	std::vector<CookieChangeSubscription>* subscriptions) {
	if (subscriptions->empty())
	return;

	// Service workers can only observe changes to cookies for URLs under their
	// scope. This means all the URLs that the worker is observing must map to the
	// same domain key (eTLD+1).
	//
	// TODO(pwnall): This is the same as implementation as
	// net::CookieMonsterChangeDispatcher::DomainKey. Extract that
	// implementation into net/cookies.cookie_util.h and call it.
	std::string url_key = net::registry_controlled_domains::GetDomainAndRegistry(

	(*subscriptions)[0].url(),
	net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
	base::LinkedList<CookieChangeSubscription>& url_key_subscriptions_list =
	subscriptions_by_url_key_[url_key];

	for (auto& subscription : *subscriptions) {
	DCHECK(!subscription.next() && !subscription.previous())
	<< "Subscription passed to " << __func__ << " already activated";
	DCHECK_EQ(url_key,
	net::registry_controlled_domains::GetDomainAndRegistry(
	subscription.url(),
	net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES))
	<< __func__ << " subscriptions belong to different registrations";
	url_key_subscriptions_list.Append(&subscription);
	}
	}

	void CookieStoreManager::DeactivateSubscriptions(
	std::vector<CookieChangeSubscription>* subscriptions) {
	if (subscriptions->empty())
	return;

	// Service workers can only observe changes to cookies for URLs under their
	// scope. This means all the URLs that the worker is observing must map to the
	// same domain key (eTLD+1).
	//
	// TODO(pwnall): This has the same implementation as
	// net::CookieMonsterChangeDispatcher::DomainKey. Extract that
	// implementation into net/cookies.cookie_util.h and call it.
	std::string url_key = net::registry_controlled_domains::GetDomainAndRegistry(
	(*subscriptions)[0].url(),
	net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
	for (auto& subscription : *subscriptions) {
	DCHECK(subscription.next() && subscription.previous())
	<< "Subscription passed to " << __func__ << " not previously activated";
	DCHECK_EQ(url_key,
	net::registry_controlled_domains::GetDomainAndRegistry(
	subscription.url(),
	net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES))
	<< __func__ << " subscriptions belong to different registrations";
	subscription.RemoveFromList();
	}
	auto it = subscriptions_by_url_key_.find(url_key);
	DCHECK(it != subscriptions_by_url_key_.end());
	if (it->second.empty())
	subscriptions_by_url_key_.erase(it);
	}

	void CookieStoreManager::OnStorageWiped() {
	DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

	// Waiting for the on-disk subscriptions to be loaded ensures that all
	// subscriptions are removed. Without waiting, there's a risk that some
	// subscriptions will finish loading (and thus remain active) after this
	// function runs.
	if (!done_loading_subscriptions_) {
	subscriptions_loaded_callbacks_.emplace_back(base::BindOnce(
	&CookieStoreManager::OnStorageWiped, weak_factory_.GetWeakPtr()));
	return;
	}

	subscriptions_by_url_key_.clear();
	subscriptions_by_registration_.clear();
	}

	void CookieStoreManager::OnCookieChange(
	const net::CanonicalCookie& cookie,
	::network::mojom::CookieChangeCause cause) {
	// Waiting for on-disk subscriptions to be loaded ensures that changes are
	// delivered to all service workers that subscribed to them in previous
	// browser sessions. Without waiting, workers might miss cookie changes.
	if (!done_loading_subscriptions_) {
	subscriptions_loaded_callbacks_.emplace_back(
	base::BindOnce(&CookieStoreManager::OnCookieChange,
	weak_factory_.GetWeakPtr(), cookie, cause));
	return;
	}

	// Compute the list of service workers interested in this change. A worker
	// might have multiple subscriptions that cover this change, but should still
	// receive a single change event.
	// TODO(pwnall): This has same as implementation as
	// net::CookieMonsterChangeDispatcher::DomainKey. Extract that
	// implementation into net/cookies.cookie_util.h and call it.
	std::string url_key = net::registry_controlled_domains::GetDomainAndRegistry(
	cookie.Domain(),
	net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES);
	auto it = subscriptions_by_url_key_.find(url_key);
	if (it == subscriptions_by_url_key_.end())
	return;
	std::set<int64_t> interested_registration_ids;
	const base::LinkedList<CookieChangeSubscription>& subscriptions = it->second;
	for (const base::LinkNode<CookieChangeSubscription>* node =
	subscriptions.head();
	node != subscriptions.end(); node = node->next()) {
	const CookieChangeSubscription* subscription = node->value();
	if (subscription->ShouldObserveChangeTo(cookie)) {
	interested_registration_ids.insert(
	subscription->service_worker_registration_id());
	}
	}

	// Dispatch the change to interested workers.
	for (int64_t registration_id : interested_registration_ids) {
	service_worker_context_->FindReadyRegistrationForIdOnly(
	registration_id,
	base::BindOnce(
	[](base::WeakPtr<CookieStoreManager> manager,
	const net::CanonicalCookie& cookie,
	::network::mojom::CookieChangeCause cause,
	ServiceWorkerStatusCode find_status,
	scoped_refptr<ServiceWorkerRegistration> registration) {
	if (find_status != SERVICE_WORKER_OK)
	return;

	DCHECK(registration);
	if (!manager)
	return;
	manager->DispatchChangeEvent(std::move(registration), cookie,
	cause);
	},
	weak_factory_.GetWeakPtr(), cookie, cause));
	}
	}

	void CookieStoreManager::DispatchChangeEvent(
	scoped_refptr<ServiceWorkerRegistration> registration,
	const net::CanonicalCookie& cookie,
	::network::mojom::CookieChangeCause cause) {
	scoped_refptr<ServiceWorkerVersion> active_version =
	registration->active_version();
	if (active_version->running_status() != EmbeddedWorkerStatus::RUNNING) {
	active_version->RunAfterStartWorker(
	ServiceWorkerMetrics::EventType::COOKIE_CHANGE,
	base::BindOnce(&CookieStoreManager::DidStartWorkerForChangeEvent,
	weak_factory_.GetWeakPtr(), std::move(registration),
	cookie, cause));
	return;
	}

	int request_id = active_version->StartRequest(
	ServiceWorkerMetrics::EventType::COOKIE_CHANGE, base::DoNothing());

	active_version->event_dispatcher()->DispatchCookieChangeEvent(
	cookie, cause, active_version->CreateSimpleEventCallback(request_id));
	}

	void CookieStoreManager::DidStartWorkerForChangeEvent(
	scoped_refptr<ServiceWorkerRegistration> registration,
	const net::CanonicalCookie& cookie,
	::network::mojom::CookieChangeCause cause,
	ServiceWorkerStatusCode start_worker_status) {
	if (start_worker_status != SERVICE_WORKER_OK)
	return;
	DispatchChangeEvent(std::move(registration), cookie, cause);
	}

	} // namespace content