Added ServiceWorkerResponses to GetJobResponse callback

content/browser/background_fetch/background_fetch_data_manager.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_data_manager.h"
 
 #include "base/memory/ptr_util.h"
 #include "content/browser/background_fetch/background_fetch_context.h"
 #include "content/browser/background_fetch/background_fetch_job_response_data.h"
 #include "content/browser/background_fetch/background_fetch_request_info.h"
+#include "content/browser/blob_storage/chrome_blob_storage_context.h"
 #include "content/public/browser/blob_handle.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_item.h"
 
 namespace content {
 
 BackgroundFetchDataManager::BackgroundFetchDataManager(
     BrowserContext* browser_context)
     : browser_context_(browser_context), weak_ptr_factory_(this) {
@@ skipping 69 matching lines @@
   const std::vector<BackgroundFetchRequestInfo>& request_infos = iter->second;
 
   DCHECK(request_index <= request_infos.size());
   return base::MakeUnique<BackgroundFetchRequestInfo>(
       request_infos[request_index]);
 }
 
 void BackgroundFetchDataManager::GetJobResponse(
     const std::string& job_guid,
     const BackgroundFetchResponseCompleteCallback& callback) {
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::IO, FROM_HERE,

[Peter Beverloo, 2017/03/27 11:05:16]

BrowserThread::UI

This class lives on the IO thread, ChromeBlobStorageContext::GetFor() must be
invoked on the UI thread.

[harkness, 2017/03/27 12:23:19]

According to the comments, only the constructor should be called on the UI
thread. It is odd that it does a post task to the IO thread, but it doesn't seem
to require that it be called on any particular thread.

[harkness, 2017/03/27 12:35:32]

Or maybe the comments are wrong!  :)

+      base::Bind(&ChromeBlobStorageContext::GetFor, browser_context_),
+      base::Bind(&BackgroundFetchDataManager::DidGetBlobStorageContext,
+                 weak_ptr_factory_.GetWeakPtr(), job_guid, callback));
+}
+
+void BackgroundFetchDataManager::DidGetBlobStorageContext(
+    const std::string& job_guid,
+    const BackgroundFetchResponseCompleteCallback& callback,
+    ChromeBlobStorageContext* blob_context) {

[Peter Beverloo, 2017/03/27 11:05:16]

DCHECK(blob_context);

[harkness, 2017/03/27 12:23:19]

Done.

   BackgroundFetchJobInfo* job_info = job_map_[job_guid].get();
   DCHECK(job_info);
 
   // Create a BackgroundFetchJobResponseData object which will aggregate
   // together the response blobs.
   job_info->set_job_response_data(
       base::MakeUnique<BackgroundFetchJobResponseData>(job_info->num_requests(),
                                                        callback));
+  BackgroundFetchJobResponseData* job_response_data =
+      job_info->job_response_data();
+  DCHECK(job_response_data);
 
   // Iterate over the requests and create blobs for each response.
   for (size_t request_index = 0; request_index < job_info->num_requests();
        request_index++) {
     // TODO(harkness): This will need to be asynchronous.
     std::unique_ptr<BackgroundFetchRequestInfo> request_info =
         GetRequestInfo(job_guid, request_index);
 
     // TODO(harkness): Only create a blob response if the request was
     // successful. Otherwise create an error response.
-    content::BrowserContext::CreateFileBackedBlob(
-        browser_context_, request_info->file_path(), 0 /* offset */,
-        request_info->received_bytes(),
-        base::Time() /* expected_modification_time */,
-        base::Bind(&BackgroundFetchDataManager::DidGetRequestResponse,
-                   weak_ptr_factory_.GetWeakPtr(), job_guid, request_index));
+    std::unique_ptr<BlobHandle> blob_handle =
+        blob_context->CreateFileBackedBlob(
+            request_info->file_path(), 0 /* offset */,
+            request_info->received_bytes(),
+            base::Time() /* expected_modification_time */);
+
+    job_response_data->AddResponse(*request_info.get(), std::move(blob_handle));
   }
 }
 
-void BackgroundFetchDataManager::DidGetRequestResponse(
-    const std::string& job_guid,
-    int request_sequence_number,
-    std::unique_ptr<BlobHandle> blob_handle) {
-  BackgroundFetchJobInfo* job_info = job_map_[job_guid].get();
-  DCHECK(job_info);
-
-  BackgroundFetchJobResponseData* job_response_data =
-      job_info->job_response_data();
-  DCHECK(job_response_data);
-
-  job_response_data->AddResponse(request_sequence_number,
-                                 std::move(blob_handle));
-}
-
 bool BackgroundFetchDataManager::UpdateRequestState(
     const std::string& job_guid,
     const std::string& request_guid,
     DownloadItem::DownloadState state,
     DownloadInterruptReason interrupt_reason) {
   // Find the request and set the state and the interrupt reason.
   BackgroundFetchJobInfo* job_info = job_map_[job_guid].get();
   DCHECK(job_info);
   BackgroundFetchRequestInfo* request =
       job_info->GetActiveRequest(request_guid);
@@ skipping 66 matching lines @@
     const std::string& download_guid) {
   BackgroundFetchJobInfo* job_info = job_map_[job_guid].get();
   DCHECK(job_info);
   BackgroundFetchRequestInfo* request =
       job_info->GetActiveRequest(request_guid);
   DCHECK(request);
   request->set_download_guid(download_guid);
 }
 
 }  // namespace content