Populate the response blob for finished Background Fetches

content/browser/background_fetch/background_fetch_service_unittest.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 <map>
 #include <memory>
 #include <utility>
 
+#include "base/files/file_util.h"
+#include "base/files/scoped_temp_dir.h"
 #include "base/guid.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "content/browser/background_fetch/background_fetch_context.h"
 #include "content/browser/background_fetch/background_fetch_embedded_worker_test_helper.h"
 #include "content/browser/background_fetch/background_fetch_registration_id.h"
 #include "content/browser/background_fetch/background_fetch_service_impl.h"
@@ skipping 29 matching lines @@
   // for which is contained in the |params|.
   void DownloadUrl(std::unique_ptr<DownloadUrlParameters> params) override {
     auto iter = registered_responses_.find(params->url());
     if (iter == registered_responses_.end())
       return;
 
     std::unique_ptr<FakeDownloadItem> download_item =
         base::MakeUnique<FakeDownloadItem>();
 
     download_item->SetURL(params->url());
+    download_item->SetUrlChain({params->url()});
     download_item->SetState(DownloadItem::DownloadState::IN_PROGRESS);
     download_item->SetGuid(base::GenerateGUID());
-    download_item->SetStartTime(base::Time());
+    download_item->SetStartTime(base::Time::Now());
 
     // Asynchronously invoke the callback set on the |params|, and then continue
     // dealing with the response in this class.
     BrowserThread::PostTaskAndReply(
         BrowserThread::UI, FROM_HERE,
         base::Bind(params->callback(), download_item.get(),
                    DOWNLOAD_INTERRUPT_REASON_NONE),
         base::Bind(&RespondingDownloadManager::DidStartDownload,
                    weak_ptr_factory_.GetWeakPtr(), download_item.get()));
 
     download_items_.push_back(std::move(download_item));
   }
 
  private:
   // Called when the download has been "started" by the download manager. This
   // is where we finish the download by sending a single update.
   void DidStartDownload(FakeDownloadItem* download_item) {
     auto iter = registered_responses_.find(download_item->GetURL());
     DCHECK(iter != registered_responses_.end());
 
     const ResponseInfo& response_info = iter->second;
 
     download_item->SetState(DownloadItem::DownloadState::COMPLETE);
-    download_item->SetEndTime(base::Time());
+    download_item->SetEndTime(base::Time::Now());
 
-    // TODO(peter): Set response body, status code and so on.
+    base::FilePath response_path;
+    if (!temp_directory_.IsValid())
+      ASSERT_TRUE(temp_directory_.CreateUniqueTempDir());
+
+    // Write the |response_info|'s response_text to a temporary file.
+    ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_directory_.GetPath(),
+                                               &response_path));
+
+    ASSERT_NE(-1 /* error */,
+              base::WriteFile(response_path, response_info.second.c_str(),
+                              response_info.second.size()));
+
+    download_item->SetTargetFilePath(response_path);
     download_item->SetReceivedBytes(response_info.second.size());
 
     // Notify the Job Controller about the download having been updated.
     download_item->NotifyDownloadUpdated();
   }
 
   using ResponseInfo =
       std::pair<int /* status_code */, std::string /* response_text */>;
 
   // Map of URL to the response information associated with that URL.
   std::map<GURL, ResponseInfo> registered_responses_;
 
   // Only used to guarantee the lifetime of the created FakeDownloadItems.
   std::vector<std::unique_ptr<FakeDownloadItem>> download_items_;
 
+  // Temporary directory in which successfully downloaded files will be stored.
+  base::ScopedTempDir temp_directory_;

[harkness, 2017/04/05 09:26:00]

Is there a reason we can't rely on the download manager's storage?

[Peter Beverloo, 2017/04/05 09:39:27]

This is a test.

+
   base::WeakPtrFactory<RespondingDownloadManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RespondingDownloadManager);
 };
 
 IconDefinition CreateIcon(std::string src,
                           std::string sizes,
                           std::string type) {
   IconDefinition icon;
   icon.src = std::move(src);
@@ skipping 322 matching lines @@
   base::RunLoop event_dispatched_loop;
   embedded_worker_test_helper()->set_fetched_event_closure(
       event_dispatched_loop.QuitClosure());
 
   std::vector<ServiceWorkerFetchRequest> requests;
   requests.push_back(CreateRequestWithProvidedResponse(
       "GET", "https://example.com/funny_cat.txt", 200 /* status_code */,
       "This text describes a scenario involving a funny cat."));
   requests.push_back(CreateRequestWithProvidedResponse(
       "GET", "https://example.com/crazy_cat.txt", 200 /* status_code */,
-      "This text descrubes a scenario involving a crazy cat."));
+      "This text describes another scenario that involves a crazy cat."));
 
   // Create the registration with the given |requests|.
   {
     BackgroundFetchOptions options;
 
     blink::mojom::BackgroundFetchError error;
     BackgroundFetchRegistration registration;
 
     // Create the first registration. This must succeed.
     ASSERT_NO_FATAL_FAILURE(
@@ skipping 20 matching lines @@
     EXPECT_EQ(fetches[i].request.url, fetches[i].response.url_list[0]);
 
     // TODO(peter): change-detector tests for unsupported properties.
     EXPECT_EQ(fetches[i].response.status_code, 0);
     EXPECT_TRUE(fetches[i].response.status_text.empty());
     EXPECT_EQ(fetches[i].response.response_type,
               blink::WebServiceWorkerResponseTypeOpaque);
     EXPECT_TRUE(fetches[i].response.headers.empty());
     EXPECT_EQ(fetches[i].response.error,
               blink::WebServiceWorkerResponseErrorUnknown);
-    EXPECT_TRUE(fetches[i].response.response_time.is_null());
 
-    // TODO(peter): Change-detector tests for when bodies are supported.
-    EXPECT_TRUE(fetches[i].response.blob_uuid.empty());
-    EXPECT_EQ(fetches[i].response.blob_size, 0u);
+    // Verify that all properties have a sensible value.
+    EXPECT_FALSE(fetches[i].response.response_time.is_null());
+
+    // Verify that the response blobs have been populated. We cannot consume
+    // their data here since the handles have already been released.
+    ASSERT_FALSE(fetches[i].response.blob_uuid.empty());
+    ASSERT_GT(fetches[i].response.blob_size, 0u);
   }
 }
 
 TEST_F(BackgroundFetchServiceTest, Abort) {
   // This test starts a new Background Fetch, completes the registration, and
   // then aborts the Background Fetch mid-process. Tests all of StartFetch(),
   // GetActiveFetches() and GetActiveTagsForServiceWorkerRegistration().
 
   BackgroundFetchRegistrationId registration_id;
   ASSERT_TRUE(CreateRegistrationId(kExampleTag, &registration_id));
@@ skipping 128 matching lines @@
     const bool has_alternative_tag =
         tags[0] == kAlternativeTag || tags[1] == kAlternativeTag;
 
     EXPECT_TRUE(has_example_tag);
     EXPECT_TRUE(has_alternative_tag);
   }
 }
 
 }  // namespace
 }  // namespace content