Network traffic annotation added to chrome::BitmapFetcher.

chrome/browser/bitmap_fetcher/bitmap_fetcher_service.cc

 // Copyright 2014 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 "chrome/browser/bitmap_fetcher/bitmap_fetcher_service.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 65 matching lines @@
     if ((*iter)->request_id() == request_id) {
       requests_.erase(iter);
       // Deliberately leave the associated fetcher running to populate cache.
       return;
     }
   }
 }
 
 BitmapFetcherService::RequestId BitmapFetcherService::RequestImage(
     const GURL& url,
-    Observer* observer) {
+    Observer* observer,
+    const net::NetworkTrafficAnnotationTag& traffic_annotation) {
   // Create a new request, assigning next available request ID.
   ++current_request_id_;
   if (current_request_id_ == REQUEST_ID_INVALID)
     ++current_request_id_;
   int request_id = current_request_id_;
   std::unique_ptr<BitmapFetcherRequest> request(
       new BitmapFetcherRequest(request_id, observer));
 
   // Reject invalid URLs.
   if (!url.is_valid())
     return REQUEST_ID_INVALID;
 
   // Check for existing images first.
   auto iter = cache_.Get(url);
   if (iter != cache_.end()) {
     BitmapFetcherService::CacheEntry* entry = iter->second.get();
     request->NotifyImageChanged(entry->bitmap.get());
 
     // There is no request ID associated with this - data is already delivered.
     return REQUEST_ID_INVALID;
   }
 
   // Limit number of simultaneous in-flight requests.
   if (requests_.size() > kMaxRequests)
     return REQUEST_ID_INVALID;
 
   // Make sure there's a fetcher for this URL and attach to request.
-  const chrome::BitmapFetcher* fetcher = EnsureFetcherForUrl(url);
+  const chrome::BitmapFetcher* fetcher = EnsureFetcherForUrl(
+      url, traffic_annotation);
   request->set_fetcher(fetcher);
 
   requests_.push_back(request.release());
   return requests_.back()->request_id();
 }
 
-void BitmapFetcherService::Prefetch(const GURL& url) {
+void BitmapFetcherService::Prefetch(
+    const GURL& url,
+    const net::NetworkTrafficAnnotationTag& traffic_annotation) {
   if (url.is_valid())
-    EnsureFetcherForUrl(url);
+    EnsureFetcherForUrl(url, traffic_annotation);
 }
 
 std::unique_ptr<chrome::BitmapFetcher> BitmapFetcherService::CreateFetcher(
-    const GURL& url) {
+    const GURL& url,
+    const net::NetworkTrafficAnnotationTag& traffic_annotation) {
   std::unique_ptr<chrome::BitmapFetcher> new_fetcher(
-      new chrome::BitmapFetcher(url, this));
+      new chrome::BitmapFetcher(url, this, traffic_annotation));
 
   new_fetcher->Init(
       content::BrowserContext::GetDefaultStoragePartition(context_)->
           GetURLRequestContext(),
       std::string(),
       net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
       net::LOAD_NORMAL);
   new_fetcher->Start();
   return new_fetcher;
 }
 
 const chrome::BitmapFetcher* BitmapFetcherService::EnsureFetcherForUrl(
-    const GURL& url) {
+    const GURL& url,
+    const net::NetworkTrafficAnnotationTag& traffic_annotation) {
   const chrome::BitmapFetcher* fetcher = FindFetcherForUrl(url);
   if (fetcher)
     return fetcher;
 
-  std::unique_ptr<chrome::BitmapFetcher> new_fetcher = CreateFetcher(url);
+  std::unique_ptr<chrome::BitmapFetcher> new_fetcher = CreateFetcher(
+      url, traffic_annotation);
   active_fetchers_.push_back(std::move(new_fetcher));
   return active_fetchers_.back().get();
 }
 
 const chrome::BitmapFetcher* BitmapFetcherService::FindFetcherForUrl(
     const GURL& url) {
   for (auto it = active_fetchers_.begin(); it != active_fetchers_.end(); ++it) {
     if (url == (*it)->url())
       return it->get();
   }
@@ skipping 28 matching lines @@
   }
 
   if (bitmap && !bitmap->isNull()) {
     std::unique_ptr<CacheEntry> entry(new CacheEntry);
     entry->bitmap.reset(new SkBitmap(*bitmap));
     cache_.Put(fetcher->url(), std::move(entry));
   }
 
   RemoveFetcher(fetcher);
 }