Remove calls to deprecated MessageLoop methods on Windows and Linux.

components/suggestions/suggestions_service_unittest.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/suggestions_service.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 322 matching lines @@
   // Expectations.
   EXPECT_CALL(*mock_thumbnail_manager_, Initialize(_));
   EXPECT_CALL(*mock_blacklist_store_, FilterSuggestions(_));
   EXPECT_CALL(*mock_blacklist_store_, GetTimeUntilReadyForUpload(_))
       .WillOnce(Return(false));
 
   // Send the request. The data should be returned to the callback.
   suggestions_service->FetchSuggestionsData();
 
   // Let the network request run.
-  io_message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Ensure that CheckCallback() ran once.
   EXPECT_EQ(1, suggestions_data_callback_count_);
 
   CheckSuggestionsData();
 }
 
 TEST_F(SuggestionsServiceTest, FetchSuggestionsDataSyncNotInitializedEnabled) {
   std::unique_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   ASSERT_TRUE(suggestions_service != nullptr);
   EXPECT_CALL(*mock_sync_service_, IsSyncActive())
       .WillRepeatedly(Return(false));
 
   auto subscription = suggestions_service->AddCallback(base::Bind(
       &SuggestionsServiceTest::CheckCallback, base::Unretained(this)));
 
   // Try to fetch suggestions. Since sync is not active, no network request
   // should be sent.
   suggestions_service->FetchSuggestionsData();
 
   // Let any network request run.
-  io_message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Ensure that CheckCallback() didn't run.
   EXPECT_EQ(0, suggestions_data_callback_count_);
 
   // |test_suggestions_store_| should still contain the default values.
   SuggestionsProfile suggestions;
   test_suggestions_store_->LoadSuggestions(&suggestions);
   EXPECT_EQ(CreateSuggestionsProfile().SerializeAsString(),
             suggestions.SerializeAsString());
 }
@@ skipping 14 matching lines @@
 
   // Ensure that CheckCallback ran once with empty data.
   EXPECT_EQ(1, suggestions_data_callback_count_);
   EXPECT_EQ(1, suggestions_empty_data_count_);
 
   // Try to fetch suggestions. Since sync is not active, no network request
   // should be sent.
   suggestions_service->FetchSuggestionsData();
 
   // Let any network request run.
-  io_message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Ensure that CheckCallback didn't run again.
   EXPECT_EQ(1, suggestions_data_callback_count_);
 }
 
 TEST_F(SuggestionsServiceTest, FetchSuggestionsDataNoAccessToken) {
   token_service_.RevokeCredentials(kAccountId);
 
   std::unique_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   ASSERT_TRUE(suggestions_service != nullptr);
 
   auto subscription = suggestions_service->AddCallback(base::Bind(
       &SuggestionsServiceTest::CheckCallback, base::Unretained(this)));
 
   EXPECT_CALL(*mock_blacklist_store_, GetTimeUntilReadyForUpload(_))
       .WillOnce(Return(false));
 
   suggestions_service->FetchSuggestionsData();
 
   // No network request should be sent.
-  io_message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(HasPendingSuggestionsRequest(suggestions_service.get()));
   EXPECT_EQ(0, suggestions_data_callback_count_);
 }
 
 TEST_F(SuggestionsServiceTest, IssueRequestIfNoneOngoingError) {
   std::unique_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   ASSERT_TRUE(suggestions_service != nullptr);
 
   // Fake a request error.
   factory_.SetFakeResponse(SuggestionsService::BuildSuggestionsURL(),
                            "irrelevant", net::HTTP_OK,
                            net::URLRequestStatus::FAILED);
 
   EXPECT_CALL(*mock_blacklist_store_, GetTimeUntilReadyForUpload(_))
       .WillOnce(Return(false));
 
   // Send the request. Empty data will be returned to the callback.
   suggestions_service->IssueRequestIfNoneOngoing(
       SuggestionsService::BuildSuggestionsURL());
 
   // (Testing only) wait until suggestion fetch is complete.
-  io_message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(SuggestionsServiceTest, IssueRequestIfNoneOngoingResponseNotOK) {
   std::unique_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   ASSERT_TRUE(suggestions_service != nullptr);
 
   // Fake a non-200 response code.
   factory_.SetFakeResponse(SuggestionsService::BuildSuggestionsURL(),
                            "irrelevant", net::HTTP_BAD_REQUEST,
                            net::URLRequestStatus::SUCCESS);
 
   // Expect that an upload to the blacklist is scheduled.
   EXPECT_CALL(*mock_blacklist_store_, GetTimeUntilReadyForUpload(_))
       .WillOnce(Return(false));
 
   // Send the request. Empty data will be returned to the callback.
   suggestions_service->IssueRequestIfNoneOngoing(
       SuggestionsService::BuildSuggestionsURL());
 
   // (Testing only) wait until suggestion fetch is complete.
-  io_message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Expect no suggestions in the cache.
   SuggestionsProfile empty_suggestions;
   EXPECT_FALSE(test_suggestions_store_->LoadSuggestions(&empty_suggestions));
 }
 
 TEST_F(SuggestionsServiceTest, BlacklistURL) {
   std::unique_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   EXPECT_TRUE(suggestions_service != nullptr);
@@ skipping 25 matching lines @@
       .WillOnce(Return(true));
 
   Blacklist(suggestions_service.get(), blacklisted_url);
   EXPECT_EQ(1, suggestions_data_callback_count_);
 
   // Wait on the upload task. This only works when the scheduling task is not
   // for future execution (note how both the SuggestionsService's scheduling
   // delay and the BlacklistStore's candidacy delay are zero). Then wait on
   // the blacklist request, then again on the next blacklist scheduling task.
   base::RunLoop().RunUntilIdle();
-  io_message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(2, suggestions_data_callback_count_);
   EXPECT_FALSE(blacklisting_failed_);
   CheckSuggestionsData();
 }
 
 TEST_F(SuggestionsServiceTest, BlacklistURLFails) {
   std::unique_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
@@ skipping 59 matching lines @@
   // Blacklist call, first request attempt.
   Blacklist(suggestions_service.get(), blacklisted_url);
   EXPECT_EQ(1, suggestions_data_callback_count_);
   EXPECT_FALSE(blacklisting_failed_);
 
   // Wait for the first scheduling, the first request, the second scheduling,
   // second request and the third scheduling. Again, note that calling
   // RunUntilIdle on the MessageLoop only works when the task is not posted for
   // the future.
   base::RunLoop().RunUntilIdle();
-  io_message_loop_.RunUntilIdle();
   base::RunLoop().RunUntilIdle();
-  io_message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   base::RunLoop().RunUntilIdle();

[gab, 2016/08/05 01:09:57]

This doesn't make sense anymore (I guess the logic was already only using
current message loop but it should be addressed in its own CL with this code's
owners)

[fdoray, 2016/08/05 16:10:35]

Multiple RunUntilIdle in a row really doesn't make sense... after one call, the
MessageLoop is idle and the next RunUntilIdle won't do anything. Addressed in a
separate CL https://codereview.chromium.org/2212223003/

   CheckSuggestionsData();
 }
 
 TEST_F(SuggestionsServiceTest, UndoBlacklistURL) {
   std::unique_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   ASSERT_TRUE(suggestions_service != nullptr);
   // Ensure scheduling the request doesn't happen before undo.
   base::TimeDelta delay = base::TimeDelta::FromHours(1);
   suggestions_service->set_blacklist_delay(delay);
@@ skipping 142 matching lines @@
   suggestions_service->GetPageThumbnail(test_url, dummy_callback);
 
   EXPECT_CALL(*mock_thumbnail_manager_, AddImageURL(test_url, thumbnail_url));
   EXPECT_CALL(*mock_thumbnail_manager_, GetImageForURL(test_url, _));
   suggestions_service->GetPageThumbnailWithURL(test_url, thumbnail_url,
                                                dummy_callback);
 
 }
 
 }  // namespace suggestions