components/image_fetcher: Expose RequestMetadata from ImageFetcher

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 "base/strings/string_split.h"
 #include "chrome/browser/chromeos/hats/hats_notification_controller.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/network_portal_detector.h"
 #include "components/image_fetcher/image_fetcher.h"
 #include "components/image_fetcher/image_fetcher_delegate.h"
+#include "components/image_fetcher/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 "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 MockNetworkPortalDetector : public NetworkPortalDetector {
  public:
   MockNetworkPortalDetector() {}
   ~MockNetworkPortalDetector() override {}
@@ skipping 16 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockNetworkPortalDetector);
 };
 
 class MockImageFetcher : public image_fetcher::ImageFetcher {
  public:
   MockImageFetcher() {}
   ~MockImageFetcher() override {}
 
-  MOCK_METHOD3(
-      StartOrQueueNetworkRequest,
-      void(const std::string&,
-           const GURL&,
-           base::Callback<void(const std::string&, const gfx::Image&)>));
+  MOCK_METHOD3(StartOrQueueNetworkRequest,
+               void(const std::string&,
+                    const GURL&,
+                    const ImageFetcher::ImageFetcherCallback&));
   MOCK_METHOD1(SetImageFetcherDelegate, void(ImageFetcherDelegate*));
   MOCK_METHOD1(SetDataUseServiceName, void(DataUseServiceName));
   MOCK_METHOD1(SetDesiredImageFrameSize, void(const gfx::Size&));
   MOCK_METHOD0(GetImageDecoder, image_fetcher::ImageDecoder*());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockImageFetcher);
 };
 
 }  // namespace
@@ skipping 50 matching lines @@
                   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, _, _))
         .WillByDefault(Invoke([&hats_notification_controller](
-            const std::string&, const GURL&,
-            base::Callback<void(const std::string&, const gfx::Image&)>) {
+                                  const std::string&, const GURL&,
+                                  const ImageFetcher::ImageFetcherCallback&) {
           gfx::Image icon_1x(gfx::test::CreateImage());
           hats_notification_controller->OnImageFetched(
-              HatsNotificationController::kImageFetcher1xId, icon_1x);
+              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, _, _))
         .WillByDefault(Invoke([&hats_notification_controller](
-            const std::string&, const GURL&,
-            base::Callback<void(const std::string&, const gfx::Image&)>) {
+                                  const std::string&, const GURL&,
+                                  ImageFetcher::ImageFetcherCallback) {
           gfx::Image icon_1x(gfx::test::CreateImage());
           hats_notification_controller->OnImageFetched(
-              HatsNotificationController::kImageFetcher2xId, icon_1x);
+              HatsNotificationController::kImageFetcher2xId, icon_1x,
+              image_fetcher::RequestMetadata());
         }));
 
     return hats_notification_controller;
   }
 
   TestingProfile profile_;
   StrictMock<MockNetworkPortalDetector> mock_network_portal_detector_;
 
  private:
   std::unique_ptr<TestingProfileManager> profile_manager_;
@@ skipping 101 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