Avoid to use the method pointer to Callback<>::Run on gmock tests

components/ntp_snippets/remote/remote_suggestions_provider_impl_unittest.cc

 // Copyright 2015 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/ntp_snippets/remote/remote_suggestions_provider_impl.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 31 matching lines @@
 #include "components/ntp_snippets/remote/remote_suggestions_scheduler.h"
 #include "components/ntp_snippets/remote/test_utils.h"
 #include "components/ntp_snippets/user_classifier.h"
 #include "components/prefs/testing_pref_service.h"
 #include "components/signin/core/browser/fake_profile_oauth2_token_service.h"
 #include "components/signin/core/browser/fake_signin_manager.h"
 #include "components/variations/variations_params_manager.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gmock_mutant.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_unittest_util.h"
 
 using image_fetcher::ImageFetcher;
 using image_fetcher::ImageFetcherDelegate;
 using testing::_;
+using testing::CreateFunctor;
 using testing::ElementsAre;
 using testing::Eq;
 using testing::InSequence;
 using testing::Invoke;
 using testing::IsEmpty;
 using testing::Mock;
 using testing::MockFunction;
 using testing::NiceMock;
 using testing::Not;
 using testing::Return;
@@ skipping 836 matching lines @@
   LoadMoreFromJSONString(service.get(), articles_category(),
                          GetTestJson({GetSuggestionWithUrl("http://second")}),
                          /*known_ids=*/std::set<std::string>(),
                          expect_only_second_suggestion_received);
 
   // Verify we can resolve the image of the new suggestions.
   ServeImageCallback cb =
       base::Bind(&ServeOneByOneImage, &service->GetImageFetcherForTesting());
   EXPECT_CALL(*image_fetcher(), StartOrQueueNetworkRequest(_, _, _))
       .Times(2)
-      .WillRepeatedly(WithArgs<0, 2>(Invoke(&cb, &ServeImageCallback::Run)));
+      .WillRepeatedly(WithArgs<0, 2>(Invoke(CreateFunctor(cb))));
   image_decoder()->SetDecodedImage(gfx::test::CreateImage(1, 1));
   gfx::Image image = FetchImage(service.get(), MakeArticleID("http://first"));
   EXPECT_FALSE(image.IsEmpty());
   EXPECT_EQ(1, image.Width());
 
   image = FetchImage(service.get(), MakeArticleID("http://second"));
   EXPECT_FALSE(image.IsEmpty());
   EXPECT_EQ(1, image.Width());
 
   // Verify that the observer received the update as well. We should see the
@@ skipping 82 matching lines @@
                                   GetSuggestionWithUrl("http://id-2")}));
   LoadFromJSONString(service.get(),
                      GetTestJson({GetSuggestionWithUrl("http://new-id-1"),
                                   GetSuggestionWithUrl("http://new-id-2")}));
   // Make sure images of both batches are available. This is to sanity check our
   // assumptions for the test are right.
   ServeImageCallback cb =
       base::Bind(&ServeOneByOneImage, &service->GetImageFetcherForTesting());
   EXPECT_CALL(*image_fetcher(), StartOrQueueNetworkRequest(_, _, _))
       .Times(2)
-      .WillRepeatedly(WithArgs<0, 2>(Invoke(&cb, &ServeImageCallback::Run)));
+      .WillRepeatedly(WithArgs<0, 2>(Invoke(CreateFunctor(cb))));
   image_decoder()->SetDecodedImage(gfx::test::CreateImage(1, 1));
   gfx::Image image = FetchImage(service.get(), MakeArticleID("http://id-1"));
   ASSERT_FALSE(image.IsEmpty());
   ASSERT_EQ(1, image.Width());
   image = FetchImage(service.get(), MakeArticleID("http://new-id-1"));
   ASSERT_FALSE(image.IsEmpty());
   ASSERT_EQ(1, image.Width());
 
   service->ClearHistory(base::Time::UnixEpoch(), base::Time::Max(),
                         base::Callback<bool(const GURL& url)>());
@@ skipping 217 matching lines @@
       {GetSuggestionWithSources("http://site.com", "Source 1", "")}));
 
   LoadFromJSONString(service.get(), json_str);
 
   ASSERT_THAT(service->GetSuggestionsForTesting(articles_category()),
               SizeIs(1));
   // Load the image to store it in the database.
   ServeImageCallback cb =
       base::Bind(&ServeOneByOneImage, &service->GetImageFetcherForTesting());
   EXPECT_CALL(*image_fetcher(), StartOrQueueNetworkRequest(_, _, _))
-      .WillOnce(WithArgs<0, 2>(Invoke(&cb, &ServeImageCallback::Run)));
+      .WillOnce(WithArgs<0, 2>(Invoke(CreateFunctor(cb))));
   image_decoder()->SetDecodedImage(gfx::test::CreateImage(1, 1));
   gfx::Image image = FetchImage(service.get(), MakeArticleID(kSuggestionUrl));
   EXPECT_FALSE(image.IsEmpty());
   EXPECT_EQ(1, image.Width());
 
   // Dismissing a non-existent suggestion shouldn't do anything.
   service->DismissSuggestion(MakeArticleID("http://othersite.com"));
   EXPECT_THAT(service->GetSuggestionsForTesting(articles_category()),
               SizeIs(1));
 
@@ skipping 84 matching lines @@
 
   std::string json_str1(GetTestJson({GetExpiredSuggestion()}));
   // Load it.
   LoadFromJSONString(service.get(), json_str1);
   // Load the image to store it in the database.
   // TODO(tschumann): Introduce some abstraction to nicely work with image
   // fetching expectations.
   ServeImageCallback cb =
       base::Bind(&ServeOneByOneImage, &service->GetImageFetcherForTesting());
   EXPECT_CALL(*image_fetcher(), StartOrQueueNetworkRequest(_, _, _))
-      .WillOnce(WithArgs<0, 2>(Invoke(&cb, &ServeImageCallback::Run)));
+      .WillOnce(WithArgs<0, 2>(Invoke(CreateFunctor(cb))));
   image_decoder()->SetDecodedImage(gfx::test::CreateImage(1, 1));
   gfx::Image image = FetchImage(service.get(), MakeArticleID(kSuggestionUrl));
   EXPECT_FALSE(image.IsEmpty());
   EXPECT_EQ(1, image.Width());
 
   // Dismiss the suggestion
   service->DismissSuggestion(
       ContentSuggestion::ID(articles_category(), kSuggestionUrl));
 
   // Load a different suggestion - this will clear the expired dismissed ones.
@@ skipping 153 matching lines @@
 
   LoadFromJSONString(service.get(), GetTestJson({GetSuggestion()}));
 
   gfx::Image image;
   MockFunction<void(const gfx::Image&)> image_fetched;
   ServeImageCallback cb =
       base::Bind(&ServeOneByOneImage, &service->GetImageFetcherForTesting());
   {
     InSequence s;
     EXPECT_CALL(*image_fetcher(), StartOrQueueNetworkRequest(_, _, _))
-        .WillOnce(WithArgs<0, 2>(Invoke(&cb, &ServeImageCallback::Run)));
+        .WillOnce(WithArgs<0, 2>(Invoke(CreateFunctor(cb))));
     EXPECT_CALL(image_fetched, Call(_)).WillOnce(SaveArg<0>(&image));
   }
 
   service->FetchSuggestionImage(
       MakeArticleID(kSuggestionUrl),
       base::Bind(&MockFunction<void(const gfx::Image&)>::Call,
                  base::Unretained(&image_fetched)));
   base::RunLoop().RunUntilIdle();
   // Check that the image by ServeOneByOneImage is really served.
   EXPECT_EQ(1, image.Width());
@@ skipping 86 matching lines @@
 }
 
 TEST_F(RemoteSuggestionsProviderImplTest, ShouldClearOrphanedImagesOnRestart) {
   auto service = MakeSuggestionsProvider();
 
   LoadFromJSONString(service.get(), GetTestJson({GetSuggestion()}));
   ServeImageCallback cb =
       base::Bind(&ServeOneByOneImage, &service->GetImageFetcherForTesting());
 
   EXPECT_CALL(*image_fetcher(), StartOrQueueNetworkRequest(_, _, _))
-      .WillOnce(WithArgs<0, 2>(Invoke(&cb, &ServeImageCallback::Run)));
+      .WillOnce(WithArgs<0, 2>(Invoke(CreateFunctor(cb))));
   image_decoder()->SetDecodedImage(gfx::test::CreateImage(1, 1));
 
   gfx::Image image = FetchImage(service.get(), MakeArticleID(kSuggestionUrl));
   EXPECT_EQ(1, image.Width());
   EXPECT_FALSE(image.IsEmpty());
 
   // Send new suggestion which don't include the suggestion referencing the
   // image.
   LoadFromJSONString(service.get(),
                      GetTestJson({GetSuggestionWithUrl(
@@ skipping 150 matching lines @@
   EXPECT_CALL(scheduler, OnProviderActivated());
   // The scheduler should be notified of clearing the history.
   EXPECT_CALL(scheduler, OnSuggestionsCleared());
 
   service->SetRemoteSuggestionsScheduler(&scheduler);
   service->OnStatusChanged(RemoteSuggestionsStatus::ENABLED_AND_SIGNED_OUT,
                            RemoteSuggestionsStatus::ENABLED_AND_SIGNED_IN);
 }
 
 }  // namespace ntp_snippets