Populate the response blob for finished Background Fetches

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"
 #include "base/memory/ptr_util.h"
 #include "content/browser/background_fetch/background_fetch_constants.h"
 #include "content/browser/background_fetch/background_fetch_data_manager.h"
+#include "content/common/service_worker/service_worker_types.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_manager.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace content {
 
 // Internal functionality of the BackgroundFetchJobController that lives on the
 // UI thread, where all interaction with the download manager must happen.
@@ skipping 18 matching lines @@
   // Starts fetching the |request| with the download manager.
   void StartRequest(scoped_refptr<BackgroundFetchRequestInfo> request) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(request_context_);
     DCHECK(request);
 
     DownloadManager* download_manager =
         BrowserContext::GetDownloadManager(browser_context_);
     DCHECK(download_manager);
 
+    const ServiceWorkerFetchRequest& fetch_request = request->fetch_request();
+
     std::unique_ptr<DownloadUrlParameters> download_parameters(
-        base::MakeUnique<DownloadUrlParameters>(request->GetURL(),
+        base::MakeUnique<DownloadUrlParameters>(fetch_request.url,
                                                 request_context_.get()));
 
     // TODO(peter): The |download_parameters| should be populated with all the
-    // properties set in the |request|'s ServiceWorkerFetchRequest member.
+    // properties set in the |fetch_request| structure.
 
     download_parameters->set_callback(base::Bind(&Core::DidStartRequest,
                                                  weak_ptr_factory_.GetWeakPtr(),
                                                  std::move(request)));
 
     download_manager->DownloadUrl(std::move(download_parameters));
   }
 
   // DownloadItem::Observer overrides:
-  void OnDownloadUpdated(DownloadItem* item) override {
+  void OnDownloadUpdated(DownloadItem* download_item) override {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-    auto iter = downloads_.find(item);
+    auto iter = downloads_.find(download_item);
     DCHECK(iter != downloads_.end());
 
-    const scoped_refptr<BackgroundFetchRequestInfo>& request = iter->second;
+    scoped_refptr<BackgroundFetchRequestInfo> request = iter->second;
 
-    switch (item->GetState()) {
+    switch (download_item->GetState()) {
       case DownloadItem::DownloadState::COMPLETE:
-        // TODO(peter): Populate the responses' information in the |request|.
-
-        item->RemoveObserver(this);
+        request->PopulateResponseFromDownloadItem(download_item);
+        download_item->RemoveObserver(this);
 
         // Inform the host about |host| having completed.
         BrowserThread::PostTask(
             BrowserThread::IO, FROM_HERE,
             base::Bind(&BackgroundFetchJobController::DidCompleteRequest,
-                       io_parent_, request));
+                       io_parent_, std::move(request)));
 
         // Clear the local state for the |request|, it no longer is our concern.
         downloads_.erase(iter);
         break;
       case DownloadItem::DownloadState::CANCELLED:
         // TODO(harkness): Consider how we want to handle cancelled downloads.
         break;
       case DownloadItem::DownloadState::INTERRUPTED:
         // TODO(harkness): Just update the notification that it is paused.
         break;
       case DownloadItem::DownloadState::IN_PROGRESS:
         // 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 {
+  void OnDownloadDestroyed(DownloadItem* download_item) override {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
-    DCHECK_EQ(downloads_.count(item), 1u);
-    downloads_.erase(item);
+    DCHECK_EQ(downloads_.count(download_item), 1u);
+    downloads_.erase(download_item);
 
-    item->RemoveObserver(this);
+    download_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(scoped_refptr<BackgroundFetchRequestInfo> request,
                        DownloadItem* download_item,
                        DownloadInterruptReason interrupt_reason) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK_EQ(interrupt_reason, DOWNLOAD_INTERRUPT_REASON_NONE);
     DCHECK(download_item);
 
+    request->PopulateDownloadState(download_item, interrupt_reason);
+
     // 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);
 
     // Inform the host about the |request| having started.
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
@@ skipping 123 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