Refactoring DownloadManager::DownloadURL to add proper annotation.

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"
@@ skipping 41 matching lines @@
 
   ~Core() final {
     for (const auto& pair : downloads_)
       pair.first->RemoveObserver(this);
   }
 
   // Returns a weak pointer that can be used to talk to |this|.
   base::WeakPtr<Core> GetWeakPtr() { return weak_ptr_factory_.GetWeakPtr(); }
 
   // Starts fetching the |request| with the download manager.
-  void StartRequest(scoped_refptr<BackgroundFetchRequestInfo> request) {
+  void StartRequest(
+      scoped_refptr<BackgroundFetchRequestInfo> request,
+      const net::NetworkTrafficAnnotationTag& traffic_annotation) {
     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();
 
@@ skipping 28 matching lines @@
     if (base::android::GetDownloadInternalDirectory(&download_directory)) {
       download_parameters->set_file_path(download_directory.Append(
           std::string(kBackgroundFetchFilePrefix) + base::GenerateGUID()));
     }
 #endif  // defined(OS_ANDROID)
 
     download_parameters->set_callback(base::Bind(&Core::DidStartRequest,
                                                  weak_ptr_factory_.GetWeakPtr(),
                                                  std::move(request)));
 
-    download_manager->DownloadUrl(std::move(download_parameters));
+    download_manager->DownloadUrl(std::move(download_parameters),
+                                  traffic_annotation);
   }
 
   // DownloadItem::Observer overrides:
   void OnDownloadUpdated(DownloadItem* download_item) override {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     auto iter = downloads_.find(download_item);
     DCHECK(iter != downloads_.end());
 
     scoped_refptr<BackgroundFetchRequestInfo> request = iter->second;
@@ skipping 107 matching lines @@
   ui_core_.reset(new Core(weak_ptr_factory_.GetWeakPtr(), registration_id,
                           browser_context, std::move(request_context)));
 
   // Get a WeakPtr over which we can talk to the |ui_core_|.
   ui_core_ptr_ = ui_core_->GetWeakPtr();
 }
 
 BackgroundFetchJobController::~BackgroundFetchJobController() = default;
 
 void BackgroundFetchJobController::Start(
-    std::vector<scoped_refptr<BackgroundFetchRequestInfo>> initial_requests) {
+    std::vector<scoped_refptr<BackgroundFetchRequestInfo>> initial_requests,
+    const net::NetworkTrafficAnnotationTag& traffic_annotation) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_LE(initial_requests.size(), kMaximumBackgroundFetchParallelRequests);
   DCHECK_EQ(state_, State::INITIALIZED);
 
   state_ = State::FETCHING;
 
   for (const auto& request : initial_requests)
-    StartRequest(request);
+    StartRequest(request, traffic_annotation);
 }
 
 void BackgroundFetchJobController::StartRequest(
-    scoped_refptr<BackgroundFetchRequestInfo> request) {
+    scoped_refptr<BackgroundFetchRequestInfo> request,
+    const net::NetworkTrafficAnnotationTag& traffic_annotation) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_EQ(state_, State::FETCHING);
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&Core::StartRequest, ui_core_ptr_, std::move(request)));
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&Core::StartRequest, ui_core_ptr_,
+                                     std::move(request), traffic_annotation));
 }
 
 void BackgroundFetchJobController::DidStartRequest(
     scoped_refptr<BackgroundFetchRequestInfo> request,
     const std::string& download_guid) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   data_manager_->MarkRequestAsStarted(registration_id_, request.get(),
                                       download_guid);
 }
 
@@ skipping 11 matching lines @@
                      weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BackgroundFetchJobController::DidGetNextRequest(
     scoped_refptr<BackgroundFetchRequestInfo> request) {
   DCHECK_LE(pending_completed_file_acknowledgements_, 1);
   pending_completed_file_acknowledgements_--;
 
   // If a |request| has been given, start downloading the file and bail.
   if (request) {
-    StartRequest(std::move(request));
+    StartRequest(std::move(request), NO_TRAFFIC_ANNOTATION_YET);
     return;
   }
 
   // If there are outstanding completed file acknowlegements, bail as well.
   if (pending_completed_file_acknowledgements_ > 0)
     return;
 
   state_ = State::COMPLETED;
 
   // Otherwise the job this controller is responsible for has completed.
@@ skipping 11 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