[Background Fetch] Cleanup/fix thread safety

content/browser/background_fetch/background_fetch_context.cc

 // Copyright 2017 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/background_fetch/background_fetch_context.h"
 
 #include "base/memory/ptr_util.h"
 #include "content/browser/background_fetch/background_fetch_data_manager.h"
 #include "content/browser/background_fetch/background_fetch_event_dispatcher.h"
 #include "content/browser/background_fetch/background_fetch_job_controller.h"
@@ skipping 26 matching lines @@
 
 BackgroundFetchContext::BackgroundFetchContext(
     BrowserContext* browser_context,
     StoragePartitionImpl* storage_partition,
     scoped_refptr<ServiceWorkerContextWrapper> service_worker_context)
     : browser_context_(browser_context),
       data_manager_(
           base::MakeUnique<BackgroundFetchDataManager>(browser_context)),
       event_dispatcher_(base::MakeUnique<BackgroundFetchEventDispatcher>(
           std::move(service_worker_context))) {
+  // Although this lives only on the IO thread, it is constructed on UI thread.
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 BackgroundFetchContext::~BackgroundFetchContext() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
 void BackgroundFetchContext::InitializeOnIOThread(
     scoped_refptr<net::URLRequestContextGetter> request_context_getter) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   request_context_getter_ = request_context_getter;
 }
 
-void BackgroundFetchContext::Shutdown() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&BackgroundFetchContext::ShutdownOnIO, this));
-}
-
-void BackgroundFetchContext::ShutdownOnIO() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  active_fetches_.clear();
-}
-
 void BackgroundFetchContext::StartFetch(
     const BackgroundFetchRegistrationId& registration_id,
     const std::vector<ServiceWorkerFetchRequest>& requests,
     const BackgroundFetchOptions& options,
     blink::mojom::BackgroundFetchService::FetchCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   data_manager_->CreateRegistration(
       registration_id, requests, options,
       base::BindOnce(&BackgroundFetchContext::DidCreateRegistration, this,
                      registration_id, options, std::move(callback)));
 }
 
 void BackgroundFetchContext::DidCreateRegistration(
     const BackgroundFetchRegistrationId& registration_id,
     const BackgroundFetchOptions& options,
     blink::mojom::BackgroundFetchService::FetchCallback callback,
     blink::mojom::BackgroundFetchError error,
     std::vector<scoped_refptr<BackgroundFetchRequestInfo>> initial_requests) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   RecordRegistrationCreatedError(error);
   if (error != blink::mojom::BackgroundFetchError::NONE) {
     std::move(callback).Run(error, base::nullopt /* registration */);
     return;
   }
 
   // Create the BackgroundFetchJobController, which will do the actual fetching.
   CreateController(registration_id, options, std::move(initial_requests));
 
   // Create the BackgroundFetchRegistration the renderer process will receive,
   // which enables it to resolve the promise telling the developer it worked.
   BackgroundFetchRegistration registration;
   registration.tag = registration_id.tag();
   registration.icons = options.icons;
   registration.title = options.title;
   registration.total_download_size = options.total_download_size;
 
   std::move(callback).Run(blink::mojom::BackgroundFetchError::NONE,
                           registration);
 }
 
 std::vector<std::string>
 BackgroundFetchContext::GetActiveTagsForServiceWorkerRegistration(
     int64_t service_worker_registration_id,
     const url::Origin& origin) const {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   std::vector<std::string> tags;
   for (const auto& pair : active_fetches_) {
     const BackgroundFetchRegistrationId& registration_id =
         pair.second->registration_id();
 
     // Only return the tags when the origin and SW registration id match.
     if (registration_id.origin() == origin &&
         registration_id.service_worker_registration_id() ==
             service_worker_registration_id) {
       tags.push_back(pair.second->registration_id().tag());
@@ skipping 17 matching lines @@
     return nullptr;
   }
 
   return controller;
 }
 
 void BackgroundFetchContext::CreateController(
     const BackgroundFetchRegistrationId& registration_id,
     const BackgroundFetchOptions& options,
     std::vector<scoped_refptr<BackgroundFetchRequestInfo>> initial_requests) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   net::NetworkTrafficAnnotationTag traffic_annotation =
       net::DefineNetworkTrafficAnnotation("background_fetch_context", R"(
         semantics {
           sender: "Background Fetch API"
           description:
             "The Background Fetch API enables developers to upload or download "
             "files on behalf of the user. Such fetches will yield a user "
             "visible notification to inform the user of the operation, through "
             "which it can be suspended, resumed and/or cancelled. The "
             "developer retains control of the file once the fetch is "
@@ skipping 27 matching lines @@
     // future we may want a more elaborate scheduling mechanism here.
     controller->Start(std::move(initial_requests));
   }
 
   active_fetches_.insert(
       std::make_pair(registration_id, std::move(controller)));
 }
 
 void BackgroundFetchContext::DidCompleteJob(
     BackgroundFetchJobController* controller) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   const BackgroundFetchRegistrationId& registration_id =
       controller->registration_id();
 
   DCHECK_GT(active_fetches_.count(registration_id), 0u);
   switch (controller->state()) {
     case BackgroundFetchJobController::State::ABORTED:
       event_dispatcher_->DispatchBackgroundFetchAbortEvent(
           registration_id,
           base::Bind(&BackgroundFetchContext::DeleteRegistration, this,
                      registration_id,
@@ skipping 13 matching lines @@
 
   NOTREACHED();
 }
 
 void BackgroundFetchContext::DidGetSettledFetches(
     const BackgroundFetchRegistrationId& registration_id,
     blink::mojom::BackgroundFetchError error,
     bool background_fetch_succeeded,
     std::vector<BackgroundFetchSettledFetch> settled_fetches,
     std::vector<std::unique_ptr<BlobHandle>> blob_handles) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
   if (error != blink::mojom::BackgroundFetchError::NONE) {
     DeleteRegistration(registration_id, std::move(blob_handles));
     return;
   }
 
   // The `backgroundfetched` event will be invoked when all requests in the
   // registration have completed successfully. In all other cases, the
   // `backgroundfetchfail` event will be invoked instead.
   if (background_fetch_succeeded) {
     event_dispatcher_->DispatchBackgroundFetchedEvent(
         registration_id, std::move(settled_fetches),
         base::Bind(&BackgroundFetchContext::DeleteRegistration, this,
                    registration_id, std::move(blob_handles)));
   } else {
     event_dispatcher_->DispatchBackgroundFetchFailEvent(
         registration_id, std::move(settled_fetches),
         base::Bind(&BackgroundFetchContext::DeleteRegistration, this,
                    registration_id, std::move(blob_handles)));
   }
 }
 
 void BackgroundFetchContext::DeleteRegistration(
     const BackgroundFetchRegistrationId& registration_id,
     const std::vector<std::unique_ptr<BlobHandle>>& blob_handles) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_GT(active_fetches_.count(registration_id), 0u);
 
   // Delete all persistent information associated with the |registration_id|.
   data_manager_->DeleteRegistration(
       registration_id, base::BindOnce(&RecordRegistrationDeletedError));
 
   // Delete the local state associated with the |registration_id|.
   active_fetches_.erase(registration_id);
 }
 
 }  // namespace content