Network traffic annotation added to safe_search_url_checker.

chrome/browser/safe_search_api/safe_search_url_checker.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/safe_search_api/safe_search_url_checker.h"
 
 #include <string>
 #include <utility>
 
 #include "base/callback.h"
@@ skipping 27 matching lines @@
 const size_t kDefaultCacheSize = 1000;
 const size_t kDefaultCacheTimeoutSeconds = 3600;
 
 // Builds the POST data for SafeSearch API requests.
 std::string BuildRequestData(const std::string& api_key, const GURL& url) {
   std::string query = net::EscapeQueryParamValue(url.spec(), true);
   return base::StringPrintf(kDataFormat, api_key.c_str(), query.c_str());
 }
 
 // Creates a URLFetcher to call the SafeSearch API for |url|.
-std::unique_ptr<net::URLFetcher> CreateFetcher(URLFetcherDelegate* delegate,
-                                               URLRequestContextGetter* context,
-                                               const std::string& api_key,
-                                               const GURL& url) {
-  std::unique_ptr<net::URLFetcher> fetcher =
-      URLFetcher::Create(0, GURL(kApiUrl), URLFetcher::POST, delegate);
+std::unique_ptr<net::URLFetcher> CreateFetcher(
+    URLFetcherDelegate* delegate,
+    URLRequestContextGetter* context,
+    const std::string& api_key,
+    const GURL& url,
+    const net::NetworkTrafficAnnotationTag& traffic_annotation) {
+  std::unique_ptr<net::URLFetcher> fetcher = URLFetcher::Create(
+      0, GURL(kApiUrl), URLFetcher::POST, delegate, traffic_annotation);
   fetcher->SetUploadData(kDataContentType, BuildRequestData(api_key, url));
   fetcher->SetRequestContext(context);
   fetcher->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                         net::LOAD_DO_NOT_SAVE_COOKIES);
   return fetcher;
 }
 
 // Parses a SafeSearch API |response| and stores the result in |is_porn|.
 // On errors, returns false and doesn't set |is_porn|.
 bool ParseResponse(const std::string& response, bool* is_porn) {
@@ skipping 44 matching lines @@
       start_time(base::TimeTicks::Now()) {}
 
 SafeSearchURLChecker::Check::~Check() {}
 
 SafeSearchURLChecker::CheckResult::CheckResult(Classification classification,
                                                bool uncertain)
     : classification(classification),
       uncertain(uncertain),
       timestamp(base::TimeTicks::Now()) {}
 
-SafeSearchURLChecker::SafeSearchURLChecker(URLRequestContextGetter* context)
-    : SafeSearchURLChecker(context, kDefaultCacheSize) {}
+SafeSearchURLChecker::SafeSearchURLChecker(
+    URLRequestContextGetter* context,
+    const net::NetworkTrafficAnnotationTag& traffic_annotation)
+    : SafeSearchURLChecker(context, traffic_annotation, kDefaultCacheSize) {}
 
-SafeSearchURLChecker::SafeSearchURLChecker(URLRequestContextGetter* context,
-                                           size_t cache_size)
+SafeSearchURLChecker::SafeSearchURLChecker(
+    URLRequestContextGetter* context,
+    const net::NetworkTrafficAnnotationTag& traffic_annotation,
+    size_t cache_size)
     : context_(context),
+      traffic_annotation_(traffic_annotation),
       cache_(cache_size),
       cache_timeout_(
           base::TimeDelta::FromSeconds(kDefaultCacheTimeoutSeconds)) {}
 
 SafeSearchURLChecker::~SafeSearchURLChecker() {}
 
 bool SafeSearchURLChecker::CheckURL(const GURL& url,
                                     const CheckCallback& callback) {
   // TODO(treib): Hack: For now, allow all Google URLs to save QPS. If we ever
   // remove this, we should find a way to allow at least the NTP.
@@ skipping 30 matching lines @@
     if (check->url == url) {
       DVLOG(1) << "Adding to pending check for " << url.spec();
       check->callbacks.push_back(callback);
       return false;
     }
   }
 
   DVLOG(1) << "Checking URL " << url;
   std::string api_key = google_apis::GetAPIKey();
   std::unique_ptr<URLFetcher> fetcher(
-      CreateFetcher(this, context_, api_key, url));
+      CreateFetcher(this, context_, api_key, url, traffic_annotation_));
   fetcher->Start();
   checks_in_progress_.push_back(new Check(url, std::move(fetcher), callback));
   return false;
 }
 
 void SafeSearchURLChecker::OnURLFetchComplete(const net::URLFetcher* source) {
   ScopedVector<Check>::iterator it = checks_in_progress_.begin();
   while (it != checks_in_progress_.end()) {
     if (source == (*it)->fetcher.get())
       break;
@@ skipping 21 matching lines @@
   // TODO(msramek): Consider moving this to SupervisedUserResourceThrottle.
   UMA_HISTOGRAM_TIMES("ManagedUsers.SafeSitesDelay",
                       base::TimeTicks::Now() - check->start_time);
 
   cache_.Put(check->url, CheckResult(classification, uncertain));
 
   for (size_t i = 0; i < check->callbacks.size(); i++)
     check->callbacks[i].Run(check->url, classification, uncertain);
   checks_in_progress_.erase(it);
 }