[Merge M51][Downloads] Set the Referrer header for resumed requests.

content/public/test/test_download_request_handler.cc

 // Copyright 2015 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/public/test/test_download_request_handler.h"
 
 #include <inttypes.h>
+
+#include <memory>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 36 matching lines @@
 
   // Sets |requests| to the vector of completed requests and clears the internal
   // list. The returned requests are stored in the order in which they were
   // reported as being complete (not necessarily the order in which they were
   // received).
   void GetAndResetCompletedRequests(
       TestDownloadRequestHandler::CompletedRequests* requests);
 
   // Can be called by a URLRequestJob to notify this interceptor of a completed
   // request.
-  void AddCompletedRequest(
-      const TestDownloadRequestHandler::CompletedRequest& request);
+  void AddCompletedRequest(std::unique_ptr<CompletedRequest> request);
 
   // Returns the task runner that should be used for invoking any client
   // supplied callbacks.
   scoped_refptr<base::SequencedTaskRunner> GetClientTaskRunner();
 
  private:
   Interceptor(const GURL& url,
               scoped_refptr<base::SequencedTaskRunner> client_task_runner);
 
   // net::URLRequestInterceptor
@@ skipping 116 matching lines @@
 scoped_refptr<net::HttpResponseHeaders> HeadersFromString(
     const std::string& headers_string) {
   scoped_refptr<net::HttpResponseHeaders> headers =
       new net::HttpResponseHeaders(net::HttpUtil::AssembleRawHeaders(
           headers_string.c_str(), headers_string.size()));
   return headers;
 }
 
 }  // namespace
 
+TestDownloadRequestHandler::CompletedRequest::CompletedRequest() {}
+
+TestDownloadRequestHandler::CompletedRequest::~CompletedRequest() {}
+
+TestDownloadRequestHandler::CompletedRequest::CompletedRequest(
+    CompletedRequest&&) = default;
+
 // static
 net::URLRequestJob* TestDownloadRequestHandler::PartialResponseJob::Factory(
     const Parameters& parameters,
     net::URLRequest* request,
     net::NetworkDelegate* delegate,
     base::WeakPtr<Interceptor> interceptor) {
   return new PartialResponseJob(make_scoped_ptr(new Parameters(parameters)),
                                 interceptor, request, delegate);
 }
 
@@ skipping 91 matching lines @@
       buf->data());
   DVLOG(1) << "Read " << bytes_to_copy << " bytes at offset "
            << offset_of_next_read_;
   offset_of_next_read_ += bytes_to_copy;
   read_byte_count_ += bytes_to_copy;
   return bytes_to_copy;
 }
 
 void TestDownloadRequestHandler::PartialResponseJob::ReportCompletedRequest() {
   if (interceptor_.get()) {
-    TestDownloadRequestHandler::CompletedRequest completed_request;
-    completed_request.transferred_byte_count = read_byte_count_;
-    completed_request.request_headers = request()->extra_request_headers();
-    interceptor_->AddCompletedRequest(completed_request);
+    std::unique_ptr<CompletedRequest> completed_request(new CompletedRequest);
+    completed_request->transferred_byte_count = read_byte_count_;
+    completed_request->request_headers = request()->extra_request_headers();
+    completed_request->referrer = request()->referrer();
+    completed_request->referrer_policy = request()->referrer_policy();
+    completed_request->initiator = request()->initiator();
+    completed_request->first_party_for_cookies =
+        request()->first_party_for_cookies();
+    completed_request->first_party_url_policy =
+        request()->first_party_url_policy();
+    interceptor_->AddCompletedRequest(std::move(completed_request));
   }
 }
 
 // static
 void TestDownloadRequestHandler::PartialResponseJob::
     OnStartResponseCallbackOnPossiblyIncorrectThread(
         base::WeakPtr<PartialResponseJob> job,
         const std::string& headers,
         net::Error error) {
   BrowserThread::PostTask(
@@ skipping 177 matching lines @@
   job_factory_ = job_factory;
 }
 
 void TestDownloadRequestHandler::Interceptor::GetAndResetCompletedRequests(
     TestDownloadRequestHandler::CompletedRequests* requests) {
   requests->clear();
   completed_requests_.swap(*requests);
 }
 
 void TestDownloadRequestHandler::Interceptor::AddCompletedRequest(
-    const TestDownloadRequestHandler::CompletedRequest& request) {
-  completed_requests_.push_back(request);
+    std::unique_ptr<CompletedRequest> request) {
+  completed_requests_.push_back(std::move(request));
 }
 
 scoped_refptr<base::SequencedTaskRunner>
 TestDownloadRequestHandler::Interceptor::GetClientTaskRunner() {
   return client_task_runner_;
 }
 
 TestDownloadRequestHandler::Interceptor::Interceptor(
     const GURL& url,
     scoped_refptr<base::SequencedTaskRunner> client_task_runner)
@@ skipping 140 matching lines @@
   base::RunLoop run_loop;
   BrowserThread::PostTaskAndReply(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&Interceptor::GetAndResetCompletedRequests, interceptor_,
                  requests),
       run_loop.QuitClosure());
   run_loop.Run();
 }
 
 }  // namespace content