[Suggestions] Moving suggestions code to a new component

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 "chrome/browser/search/suggestions/suggestions_service.h"
+#include "components/suggestions/suggestions_service.h"
 
 #include <map>
 #include <sstream>
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/search/suggestions/blacklist_store.h"
-#include "chrome/browser/search/suggestions/image_manager.h"
-#include "chrome/browser/search/suggestions/proto/suggestions.pb.h"
-#include "chrome/browser/search/suggestions/suggestions_service_factory.h"
-#include "chrome/browser/search/suggestions/suggestions_store.h"
+#include "base/test/test_simple_task_runner.h"
+#include "components/suggestions/blacklist_store.h"
+#include "components/suggestions/image_manager.h"
+#include "components/suggestions/proto/suggestions.pb.h"
+#include "components/suggestions/suggestions_store.h"
 #include "components/variations/entropy_provider.h"
 #include "components/variations/variations_associated_data.h"
-#include "content/public/test/test_browser_thread_bundle.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::DoAll;
 using ::testing::Eq;
@@ skipping 102 matching lines @@
 
   int suggestions_data_check_count_;
   int suggestions_empty_data_count_;
 
  protected:
   SuggestionsServiceTest()
       : suggestions_data_check_count_(0),
         suggestions_empty_data_count_(0),
         factory_(NULL, base::Bind(&CreateURLFetcher)),
         mock_suggestions_store_(NULL),
-        mock_thumbnail_manager_(NULL) {}
+        mock_thumbnail_manager_(NULL),
+        task_runner_(new base::TestSimpleTaskRunner()) {}
 
   virtual ~SuggestionsServiceTest() {}
 
   virtual void SetUp() OVERRIDE {
-    request_context_ =
-        new net::TestURLRequestContextGetter(base::MessageLoopProxy::current());
+    request_context_ = new net::TestURLRequestContextGetter(
+        io_message_loop_.message_loop_proxy());
   }
 
   // Enables the "ChromeSuggestions.Group1" field trial.
   void EnableFieldTrial(const std::string& url,
                         const std::string& common_params,
                         const std::string& blacklist_path,
                         const std::string& blacklist_url_param,
                         bool control_group) {
     // Clear the existing |field_trial_list_| to avoid firing a DCHECK.
     field_trial_list_.reset(NULL);
@@ skipping 21 matching lines @@
 
   // Should not be called more than once per test since it stashes the
   // SuggestionsStore in |mock_suggestions_store_|.
   SuggestionsService* CreateSuggestionsServiceWithMocks() {
     mock_suggestions_store_ = new StrictMock<MockSuggestionsStore>();
     mock_thumbnail_manager_ = new NiceMock<MockImageManager>();
     mock_blacklist_store_ = new MockBlacklistStore();
     return new SuggestionsService(
         request_context_, scoped_ptr<SuggestionsStore>(mock_suggestions_store_),
         scoped_ptr<ImageManager>(mock_thumbnail_manager_),
-        scoped_ptr<BlacklistStore>(mock_blacklist_store_));
+        scoped_ptr<BlacklistStore>(mock_blacklist_store_),
+        task_runner_);
   }
 
   void FetchSuggestionsDataNoTimeoutHelper(bool interleaved_requests) {
     // Field trial enabled with a specific suggestions URL.
     EnableFieldTrial(kFakeSuggestionsURL, kFakeSuggestionsCommonParams,
                      kFakeBlacklistPath, kFakeBlacklistUrlParam, false);
     scoped_ptr<SuggestionsService> suggestions_service(
         CreateSuggestionsServiceWithMocks());
     EXPECT_TRUE(suggestions_service != NULL);
     scoped_ptr<SuggestionsProfile> suggestions_profile(
@@ skipping 21 matching lines @@
         .Times(expected_count);
     EXPECT_CALL(*mock_blacklist_store_, GetFirstUrlFromBlacklist(_))
         .Times(expected_count)
         .WillRepeatedly(Return(false));
 
     // Send the request. The data will be returned to the callback.
     suggestions_service->FetchSuggestionsDataNoTimeout(base::Bind(
         &SuggestionsServiceTest::CheckSuggestionsData, base::Unretained(this)));
 
     if (!interleaved_requests)
-      base::MessageLoop::current()->RunUntilIdle();  // Let request complete.
+      io_message_loop_.RunUntilIdle();  // Let request complete.
 
     // Send the request a second time.
     suggestions_service->FetchSuggestionsDataNoTimeout(base::Bind(
         &SuggestionsServiceTest::CheckSuggestionsData, base::Unretained(this)));
 
     // (Testing only) wait until suggestion fetch is complete.
-    base::MessageLoop::current()->RunUntilIdle();
+    io_message_loop_.RunUntilIdle();
 
     // Ensure that CheckSuggestionsData() ran twice.
     EXPECT_EQ(2, suggestions_data_check_count_);
   }
 
  protected:
+  base::MessageLoopForIO io_message_loop_;
   net::FakeURLFetcherFactory factory_;
   // Only used if the SuggestionsService is built with mocks. Not owned.
   MockSuggestionsStore* mock_suggestions_store_;
   MockImageManager* mock_thumbnail_manager_;
   MockBlacklistStore* mock_blacklist_store_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
+  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
 
  private:
-  content::TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<base::FieldTrialList> field_trial_list_;
   scoped_refptr<base::FieldTrial> field_trial_;
 
   DISALLOW_COPY_AND_ASSIGN(SuggestionsServiceTest);
 };
 
 TEST_F(SuggestionsServiceTest, IsControlGroup) {
   // Field trial enabled.
   EnableFieldTrial("", "", "", "", false);
   EXPECT_FALSE(SuggestionsService::IsControlGroup());
@@ skipping 33 matching lines @@
   EXPECT_CALL(*mock_blacklist_store_, FilterSuggestions(_));
   EXPECT_CALL(*mock_blacklist_store_, GetFirstUrlFromBlacklist(_))
       .WillOnce(Return(false));
 
   // Send the request. Empty data will be returned to the callback.
   suggestions_service->FetchSuggestionsData(
       base::Bind(&SuggestionsServiceTest::ExpectEmptySuggestionsProfile,
                  base::Unretained(this)));
 
   // (Testing only) wait until suggestion fetch is complete.
-  base::MessageLoop::current()->RunUntilIdle();
+  io_message_loop_.RunUntilIdle();
 
   // Ensure that ExpectEmptySuggestionsProfile ran once.
   EXPECT_EQ(1, suggestions_empty_data_count_);
 }
 
 TEST_F(SuggestionsServiceTest, FetchSuggestionsDataResponseNotOK) {
   // Field trial enabled with a specific suggestions URL.
   EnableFieldTrial(kFakeSuggestionsURL, kFakeSuggestionsCommonParams,
                    kFakeBlacklistPath, kFakeBlacklistUrlParam, false);
   scoped_ptr<SuggestionsService> suggestions_service(
@@ skipping 14 matching lines @@
   // blacklist.
   EXPECT_CALL(*mock_blacklist_store_, GetFirstUrlFromBlacklist(_))
       .WillOnce(Return(false));
 
   // Send the request. Empty data will be returned to the callback.
   suggestions_service->FetchSuggestionsData(
       base::Bind(&SuggestionsServiceTest::ExpectEmptySuggestionsProfile,
                  base::Unretained(this)));
 
   // (Testing only) wait until suggestion fetch is complete.
-  base::MessageLoop::current()->RunUntilIdle();
+  io_message_loop_.RunUntilIdle();
 
   // Ensure that ExpectEmptySuggestionsProfile ran once.
   EXPECT_EQ(1, suggestions_empty_data_count_);
 }
 
 TEST_F(SuggestionsServiceTest, BlacklistURL) {
   EnableFieldTrial(kFakeSuggestionsURL, kFakeSuggestionsCommonParams,
                    kFakeBlacklistPath, kFakeBlacklistUrlParam, false);
   scoped_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
@@ skipping 20 matching lines @@
   EXPECT_CALL(*mock_blacklist_store_, FilterSuggestions(_));
   EXPECT_CALL(*mock_blacklist_store_, GetFirstUrlFromBlacklist(_))
       .WillOnce(Return(false));
 
   // Send the request. The data will be returned to the callback.
   suggestions_service->BlacklistURL(
       blacklist_url, base::Bind(&SuggestionsServiceTest::CheckSuggestionsData,
                                 base::Unretained(this)));
 
   // (Testing only) wait until blacklist request is complete.
-  base::MessageLoop::current()->RunUntilIdle();
+  io_message_loop_.RunUntilIdle();
 
   // Ensure that CheckSuggestionsData() ran once.
   EXPECT_EQ(1, suggestions_data_check_count_);
 }
 
 // Initial blacklist request fails, triggering a scheduled upload which
 // succeeds.
 TEST_F(SuggestionsServiceTest, BlacklistURLFails) {
   EnableFieldTrial(kFakeSuggestionsURL, kFakeSuggestionsCommonParams,
                    kFakeBlacklistPath, kFakeBlacklistUrlParam, false);
@@ skipping 35 matching lines @@
       blacklist_url, base::Bind(&SuggestionsServiceTest::CheckSuggestionsData,
                                 base::Unretained(this)));
 
   // The first FakeURLFetcher was created; we can now set up behavior for the
   // second call to blacklist.
   factory_.SetFakeResponse(GURL(request_url),
                            suggestions_profile->SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 
   // (Testing only) wait until both requests are complete.
-  base::MessageLoop::current()->RunUntilIdle();
+  io_message_loop_.RunUntilIdle();
+  // ... Other task gets posted to TestSimpleTaskRunner.
+  task_runner_->RunUntilIdle();
+  // ... And completes.
+  io_message_loop_.RunUntilIdle();
 
   // Ensure that CheckSuggestionsData() ran once.
   EXPECT_EQ(1, suggestions_data_check_count_);
 }
 
 TEST_F(SuggestionsServiceTest, GetBlacklistedUrl) {
   EnableFieldTrial(kFakeSuggestionsURL, kFakeSuggestionsCommonParams,
                    kFakeBlacklistPath, kFakeBlacklistUrlParam, false);
 
   scoped_ptr<GURL> request_url;
@@ skipping 33 matching lines @@
   // Delay increases on failure.
   suggestions_service->UpdateBlacklistDelay(false);
   EXPECT_GT(suggestions_service->blacklist_delay(), initial_delay);
 
   // Delay resets on success.
   suggestions_service->UpdateBlacklistDelay(true);
   EXPECT_EQ(initial_delay, suggestions_service->blacklist_delay());
 }
 
 }  // namespace suggestions