Pass through the response code and headers in Background Fetch

content/browser/background_fetch/background_fetch_test_base.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_test_base.h"
 
 #include <stdint.h>
 #include <memory>
 #include <utility>
 
@@ skipping 45 matching lines @@
   DCHECK(out_service_worker_registration);
   EXPECT_EQ(SERVICE_WORKER_OK, status) << ServiceWorkerStatusToString(status);
 
   *out_service_worker_registration = service_worker_registration;
 
   quit_closure.Run();
 }
 
 }  // namespace
 
+// -----------------------------------------------------------------------------
+// TestResponse
+
+BackgroundFetchTestBase::TestResponse::TestResponse() = default;
+
+BackgroundFetchTestBase::TestResponse::~TestResponse() = default;
+
+// -----------------------------------------------------------------------------
+// TestResponseBuilder
+
+BackgroundFetchTestBase::TestResponseBuilder::TestResponseBuilder(
+    int response_code)
+    : response_(base::MakeUnique<BackgroundFetchTestBase::TestResponse>()) {
+  response_->headers = make_scoped_refptr(new net::HttpResponseHeaders(
+      "HTTP/1.1 " + std::to_string(response_code)));
+}
+
+BackgroundFetchTestBase::TestResponseBuilder::~TestResponseBuilder() = default;
+
+BackgroundFetchTestBase::TestResponseBuilder&
+BackgroundFetchTestBase::TestResponseBuilder::AddResponseHeader(
+    const std::string& name,
+    const std::string& value) {
+  DCHECK(response_);
+  response_->headers->AddHeader(name + ": " + value);
+  return *this;
+}
+
+BackgroundFetchTestBase::TestResponseBuilder&
+BackgroundFetchTestBase::TestResponseBuilder::SetResponseData(
+    std::string data) {
+  DCHECK(response_);
+  response_->data.swap(data);
+  return *this;
+}
+
+std::unique_ptr<BackgroundFetchTestBase::TestResponse>
+BackgroundFetchTestBase::TestResponseBuilder::Build() {
+  return std::move(response_);
+}
+
+// -----------------------------------------------------------------------------
+// RespondingDownloadManager
+
 // Faked download manager that will respond to known HTTP requests with a test-
 // defined response. See CreateRequestWithProvidedResponse().
 class BackgroundFetchTestBase::RespondingDownloadManager
     : public MockDownloadManager {
  public:
   RespondingDownloadManager() : weak_ptr_factory_(this) {}
   ~RespondingDownloadManager() override = default;
 
-  // Responds to requests to |url| with the |status_code| and |response_text|.
+  // Responds to requests to |url| with the given |response|.
   void RegisterResponse(const GURL& url,
-                        int status_code,
-                        const std::string& response_text) {
+                        std::unique_ptr<TestResponse> response) {
     DCHECK_EQ(registered_responses_.count(url), 0u);
-    registered_responses_[url] = std::make_pair(status_code, response_text);
+    registered_responses_[url] = std::move(response);
   }
 
   // Called when the Background Fetch system starts a download, all information
   // 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;
 
+    TestResponse* response = iter->second.get();
+
     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::Now());
+    download_item->SetResponseHeaders(response->headers);
 
     // 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;
+    TestResponse* response = iter->second.get();
 
     download_item->SetState(DownloadItem::DownloadState::COMPLETE);
     download_item->SetEndTime(base::Time::Now());
 
     base::FilePath response_path;
     if (!temp_directory_.IsValid())
       ASSERT_TRUE(temp_directory_.CreateUniqueTempDir());
 
-    // Write the |response_info|'s response_text to a temporary file.
+    // Write the |response|'s data 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()));
+              base::WriteFile(response_path, response->data.c_str(),
+                              response->data.size()));
 
     download_item->SetTargetFilePath(response_path);
-    download_item->SetReceivedBytes(response_info.second.size());
+    download_item->SetReceivedBytes(response->data.size());
     download_item->SetMimeType("text/plain");
 
     // 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_;
+  std::map<GURL, std::unique_ptr<TestResponse>> 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_;
 
   base::WeakPtrFactory<RespondingDownloadManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RespondingDownloadManager);
@@ skipping 72 matching lines @@
   }
 
   *registration_id = BackgroundFetchRegistrationId(
       service_worker_registration->id(), origin_, tag);
 
   service_worker_registrations_.push_back(
       std::move(service_worker_registration));
   return true;
 }
 
-// Creates a ServiceWorkerFetchRequest instance for the given details and
-// provides a faked response with |status_code| and |response_text| to the
-// download manager, that will resolve the download with that information.
 ServiceWorkerFetchRequest
 BackgroundFetchTestBase::CreateRequestWithProvidedResponse(
     const std::string& method,
-    const std::string& url_string,
-    int status_code,
-    const std::string& response_text) {
-  GURL url(url_string);
+    const std::string& url,
+    std::unique_ptr<TestResponse> response) {
+  GURL gurl(url);
 
-  // Register the |status_code| and |response_text| with the download manager.
-  download_manager_->RegisterResponse(GURL(url_string), status_code,
-                                      response_text);
+  // Register the |response| with the faked download manager.
+  download_manager_->RegisterResponse(gurl, std::move(response));
 
   // Create a ServiceWorkerFetchRequest request with the same information.
-  return ServiceWorkerFetchRequest(url, method, ServiceWorkerHeaderMap(),
+  return ServiceWorkerFetchRequest(gurl, method, ServiceWorkerHeaderMap(),
                                    Referrer(), false /* is_reload */);
 }
 
 MockDownloadManager* BackgroundFetchTestBase::download_manager() {
   return download_manager_;
 }
 
 }  // namespace content