Network traffic annotation added to image_data_fetcher.

chrome/browser/chromeos/hats/hats_notification_controller_unittest.cc

 // Copyright 2016 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/chromeos/hats/hats_notification_controller.h"
 
 #include "base/run_loop.h"
 #include "base/strings/string_split.h"
 #include "chrome/browser/notifications/message_center_notification_manager.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/notification_ui_manager.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/browser_with_test_window_test.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/portal_detector/mock_network_portal_detector.h"
 #include "chromeos/network/portal_detector/network_portal_detector.h"
 #include "components/image_fetcher/core/image_fetcher.h"
 #include "components/image_fetcher/core/image_fetcher_delegate.h"
 #include "components/image_fetcher/core/request_metadata.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
+#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/image/image_unittest_util.h"
 #include "ui/message_center/fake_message_center_tray_delegate.h"
 #include "ui/message_center/message_center.h"
 
 using testing::_;
 using testing::AtLeast;
 using testing::Invoke;
 using testing::Return;
 using testing::SaveArg;
 using testing::StrictMock;
 
 using image_fetcher::ImageFetcher;
 using image_fetcher::ImageFetcherDelegate;
 
 namespace chromeos {
 
 namespace {
 
 class MockImageFetcher : public image_fetcher::ImageFetcher {
  public:
   MockImageFetcher() {}
   ~MockImageFetcher() override {}
 
-  MOCK_METHOD3(StartOrQueueNetworkRequest,
+  MOCK_METHOD4(StartOrQueueNetworkRequest,
                void(const std::string&,
                     const GURL&,
-                    const ImageFetcher::ImageFetcherCallback&));
+                    const ImageFetcher::ImageFetcherCallback&,
+                    const net::NetworkTrafficAnnotationTag&));
   MOCK_METHOD1(SetImageFetcherDelegate, void(ImageFetcherDelegate*));
   MOCK_METHOD1(SetDataUseServiceName, void(DataUseServiceName));
   MOCK_METHOD1(SetImageDownloadLimit,
                void(base::Optional<int64_t> max_download_bytes));
   MOCK_METHOD1(SetDesiredImageFrameSize, void(const gfx::Size&));
   MOCK_METHOD0(GetImageDecoder, image_fetcher::ImageDecoder*());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockImageFetcher);
 };
@@ skipping 53 matching lines @@
               NetworkState network_state("");
               online_state.status =
                   NetworkPortalDetector::CAPTIVE_PORTAL_STATUS_ONLINE;
               hats_notification_controller->OnPortalDetectionCompleted(
                   &network_state, online_state);
             }));
 
     // Run the image fetcher callback to simulate a successful 1x icon fetch.
     ON_CALL(*mock_image_fetcher_,
             StartOrQueueNetworkRequest(
-                HatsNotificationController::kImageFetcher1xId, _, _))
+                HatsNotificationController::kImageFetcher1xId, _, _, _))
         .WillByDefault(Invoke([&hats_notification_controller](
                                   const std::string&, const GURL&,
-                                  const ImageFetcher::ImageFetcherCallback&) {
+                                  const ImageFetcher::ImageFetcherCallback&,
+                                  const net::NetworkTrafficAnnotationTag&) {
           gfx::Image icon_1x(gfx::test::CreateImage());
           hats_notification_controller->OnImageFetched(
               HatsNotificationController::kImageFetcher1xId, icon_1x,
               image_fetcher::RequestMetadata());
         }));
 
     // Run the image fetcher callback to simulate a successful 2x icon fetch.
     ON_CALL(*mock_image_fetcher_,
             StartOrQueueNetworkRequest(
-                HatsNotificationController::kImageFetcher2xId, _, _))
+                HatsNotificationController::kImageFetcher2xId, _, _, _))
         .WillByDefault(Invoke([&hats_notification_controller](
                                   const std::string&, const GURL&,
-                                  ImageFetcher::ImageFetcherCallback) {
+                                  ImageFetcher::ImageFetcherCallback,
+                                  const net::NetworkTrafficAnnotationTag&) {
           gfx::Image icon_1x(gfx::test::CreateImage());
           hats_notification_controller->OnImageFetched(
               HatsNotificationController::kImageFetcher2xId, icon_1x,
               image_fetcher::RequestMetadata());
         }));
 
     return hats_notification_controller;
   }
 
   TestingProfile profile_;
@@ skipping 44 matching lines @@
       .Times(1);
   // Observer is removed if an internet connection is detected. It is called
   // a second time when hats_notification_controller is destroyed.
   EXPECT_CALL(mock_network_portal_detector_,
               RemoveObserver(hats_notification_controller.get()))
       .Times(2);
 
   EXPECT_CALL(*mock_image_fetcher_,
               StartOrQueueNetworkRequest(
                   HatsNotificationController::kImageFetcher1xId,
-                  GURL(HatsNotificationController::kGoogleIcon1xUrl), _))
+                  GURL(HatsNotificationController::kGoogleIcon1xUrl), _, _))
       .Times(1);
   EXPECT_CALL(*mock_image_fetcher_,
               StartOrQueueNetworkRequest(
                   HatsNotificationController::kImageFetcher2xId,
-                  GURL(HatsNotificationController::kGoogleIcon2xUrl), _))
+                  GURL(HatsNotificationController::kGoogleIcon2xUrl), _, _))
       .Times(1);
 
   hats_notification_controller->Initialize(false);
 
   // Finally check if notification was launched to confirm initialization.
   const Notification* notification =
       g_browser_process->notification_ui_manager()->FindById(
           HatsNotificationController::kDelegateId, &profile_);
   EXPECT_TRUE(notification != nullptr);
 }
@@ skipping 47 matching lines @@
   ASSERT_TRUE(base::Time::FromInternalValue(new_timestamp) >
               base::Time::FromInternalValue(now_timestamp));
 
   // Destructor for HatsController removes self from observer list.
   EXPECT_CALL(mock_network_portal_detector_,
               RemoveObserver(hats_notification_controller.get()))
       .Times(1);
 }
 
 }  // namespace chromeos