Dispatch a bare Service Worker event for a finished Background Fetch

content/browser/background_fetch/background_fetch_job_controller.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_job_controller.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 23 matching lines @@
   ~Core() final {
     for (const auto& pair : downloads_)
       pair.first->RemoveObserver(this);
   }
 
   // Returns a weak pointer that can be used to talk to |this|.
   base::WeakPtr<Core> GetWeakPtr() { return weak_ptr_factory_.GetWeakPtr(); }
 
   // Starts fetching the |request| with the download manager.
   void StartRequest(const BackgroundFetchRequestInfo& request) {
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(request_context_);
 
     DownloadManager* download_manager =
         BrowserContext::GetDownloadManager(browser_context_);
     DCHECK(download_manager);
 
     std::unique_ptr<DownloadUrlParameters> download_parameters(
         base::MakeUnique<DownloadUrlParameters>(request.GetURL(),
                                                 request_context_.get()));
 
     // TODO(peter): The |download_parameters| should be populated with all the
     // properties set in the |request|'s ServiceWorkerFetchRequest member.
 
     download_parameters->set_callback(base::Bind(
         &Core::DidStartRequest, weak_ptr_factory_.GetWeakPtr(), request));
 
     download_manager->DownloadUrl(std::move(download_parameters));
   }
 
   // DownloadItem::Observer overrides:
   void OnDownloadUpdated(DownloadItem* item) override {
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
     auto iter = downloads_.find(item);
     DCHECK(iter != downloads_.end());
 
     const BackgroundFetchRequestInfo& request = iter->second;
 
     switch (item->GetState()) {
       case DownloadItem::DownloadState::COMPLETE:
         // TODO(peter): Populate the responses' information in the |request|.
 
         item->RemoveObserver(this);
@@ skipping 17 matching lines @@
         // TODO(harkness): If the download was previously paused, this should
         // now unpause the notification.
         break;
       case DownloadItem::DownloadState::MAX_DOWNLOAD_STATE:
         NOTREACHED();
         break;
     }
   }
 
   void OnDownloadDestroyed(DownloadItem* item) override {
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK_EQ(downloads_.count(item), 1u);
     downloads_.erase(item);
 
     item->RemoveObserver(this);
   }
 
  private:
   // Called when the download manager has started the given |request|. The
   // |download_item| continues to be owned by the download system. The
   // |interrupt_reason| will indicate when a request could not be started.
   void DidStartRequest(const BackgroundFetchRequestInfo& request,
                        DownloadItem* download_item,
                        DownloadInterruptReason interrupt_reason) {
+    DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK_EQ(interrupt_reason, DOWNLOAD_INTERRUPT_REASON_NONE);
     DCHECK(download_item);
 
     // TODO(peter): The above two DCHECKs are assumptions our implementation
     // currently makes, but are not fit for production. We need to handle such
     // failures gracefully.
 
     // Register for updates on the download's progress.
     download_item->AddObserver(this);
 
@@ skipping 124 matching lines @@
 
   // TODO(harkness): Abort all in-progress downloads.
 
   state_ = State::ABORTED;
 
   // Inform the owner of the controller about the job having completed.
   std::move(completed_callback_).Run(this);
 }
 
 }  // namespace content