Network traffic annotation added to image_data_fetcher.

components/suggestions/image_manager.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 "components/suggestions/image_manager.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/task_runner_util.h"
 #include "components/image_fetcher/core/image_fetcher.h"
 #include "components/suggestions/image_encoder.h"
+#include "net/traffic_annotation/network_traffic_annotation.h"
 #include "ui/gfx/image/image.h"
 
 using leveldb_proto::ProtoDatabase;
 
 namespace {
 
 // Statistics are logged to UMA with this string as part of histogram name. They
 // can all be found under LevelDB.*.ImageManager. Changing this needs to
 // synchronize with histograms.xml, AND will also become incompatible with older
 // browsers still reporting the previous values.
 const char kDatabaseUMAClientName[] = "ImageManager";
 
 std::unique_ptr<SkBitmap> DecodeImage(
     scoped_refptr<base::RefCountedMemory> encoded_data) {
   return suggestions::DecodeJPEGToSkBitmap(encoded_data->front(),
                                            encoded_data->size());
 }
 
 // Wraps an ImageManager callback so that it can be used with the ImageFetcher.
 void WrapCallback(
     const suggestions::ImageManager::ImageCallback& wrapped_callback,
     const std::string& url,
     const gfx::Image& image,
     const image_fetcher::RequestMetadata& metadata) {
   wrapped_callback.Run(GURL(url), image);
 }
 
+constexpr net::NetworkTrafficAnnotationTag kTrafficAnnotation =
+    net::DefineNetworkTrafficAnnotation("suggestions_image_manager", R"(
+        semantics {
+          sender: "Suggestions Service Thumbnail Fetch"
+          description:
+            "Retrieves thumbnails for site suggestions based on the user's "
+            "synced browsing history, for use e.g. on the New Tab page."
+          trigger:
+            "Triggered when a thumbnail for a suggestion is required, and no "
+            "local thumbnail is available."
+          data: "The URL for which to retrieve a thumbnail."
+          destination: GOOGLE_OWNED_SERVICE
+        }
+        policy {
+          cookies_allowed: false
+          setting:
+          "Users can disable this feature by signing out of Chrome, or "

[msramek, 2017/05/19 08:47:38]

nit: Offset.

[Ramin Halavati, 2017/05/19 09:03:37]

Done.

+          "disabling Sync or History Sync in Chrome settings under 'Advanced "
+          "sync settings...'. The feature is enabled by default."
+        chrome_policy {
+          SyncDisabled {
+            policy_options {mode: MANDATORY}
+            SyncDisabled: true
+          }
+        }
+        chrome_policy {
+          SigninAllowed {
+            policy_options {mode: MANDATORY}
+            SigninAllowed: false
+          }
+        }
+      })");
+
 }  // namespace
 
 namespace suggestions {
 
 ImageManager::ImageManager() : weak_ptr_factory_(this) {}
 
 ImageManager::ImageManager(
     std::unique_ptr<image_fetcher::ImageFetcher> image_fetcher,
     std::unique_ptr<ProtoDatabase<ImageData>> database,
     const base::FilePath& database_dir,
@@ skipping 87 matching lines @@
 
 void ImageManager::OnCacheImageDecoded(
     const GURL& url,
     const GURL& image_url,
     const ImageCallback& callback,
     std::unique_ptr<SkBitmap> bitmap) {
   if (bitmap.get()) {
     callback.Run(url, gfx::Image::CreateFrom1xBitmap(*bitmap));
   } else {
     image_fetcher_->StartOrQueueNetworkRequest(
-        url.spec(), image_url, base::Bind(&WrapCallback, callback));
+        url.spec(), image_url, base::Bind(&WrapCallback, callback),
+        kTrafficAnnotation);
   }
 }
 
 scoped_refptr<base::RefCountedMemory> ImageManager::GetEncodedImageFromCache(
     const GURL& url) {
   ImageMap::iterator image_iter = image_map_.find(url.spec());
   if (image_iter != image_map_.end()) {
     return image_iter->second;
   }
   return nullptr;
 }
 
 void ImageManager::ServeFromCacheOrNetwork(
     const GURL& url,
     const GURL& image_url,
     ImageCallback callback) {
   scoped_refptr<base::RefCountedMemory> encoded_data =
       GetEncodedImageFromCache(url);
   if (encoded_data.get()) {
     base::PostTaskAndReplyWithResult(
         background_task_runner_.get(), FROM_HERE,
         base::Bind(&DecodeImage, encoded_data),
         base::Bind(&ImageManager::OnCacheImageDecoded,
                    weak_ptr_factory_.GetWeakPtr(), url, image_url, callback));
   } else {
     image_fetcher_->StartOrQueueNetworkRequest(
-        url.spec(), image_url, base::Bind(&WrapCallback, callback));
+        url.spec(), image_url, base::Bind(&WrapCallback, callback),
+        kTrafficAnnotation);
   }
 }
 
 void ImageManager::SaveImage(const std::string& url, const SkBitmap& bitmap) {
   scoped_refptr<base::RefCountedBytes> encoded_data(
       new base::RefCountedBytes());
   if (!EncodeSkBitmapToJPEG(bitmap, &encoded_data->data())) {
     return;
   }
 
@@ skipping 67 matching lines @@
        it != pending_cache_requests_.end(); ++it) {
     const ImageCacheRequest& request = it->second;
     for (CallbackVector::const_iterator callback_it = request.callbacks.begin();
          callback_it != request.callbacks.end(); ++callback_it) {
       ServeFromCacheOrNetwork(request.url, request.image_url, *callback_it);
     }
   }
 }
 
 }  // namespace suggestions