[Suggestions] Remove support for a Control logging group.

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 <map>
 #include <sstream>
 
 #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/strings/utf_string_conversions.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/suggestions/suggestions_utils.h"
-#include "components/variations/entropy_provider.h"
-#include "components/variations/variations_associated_data.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 std::string;
 using testing::DoAll;
@@ skipping 160 matching lines @@
         mock_blacklist_store_(NULL),
         test_suggestions_store_(NULL) {}
 
   ~SuggestionsServiceTest() override {}
 
   void SetUp() override {
     request_context_ = new net::TestURLRequestContextGetter(
         io_message_loop_.message_loop_proxy());
   }
 
-  void EnableFieldTrial(bool control_group) {
-    // Clear the existing |field_trial_list_| to avoid firing a DCHECK.
-    field_trial_list_.reset(NULL);
-    field_trial_list_.reset(
-        new base::FieldTrialList(new metrics::SHA1EntropyProvider("foo")));
-
-    variations::testing::ClearAllVariationParams();
-    std::map<std::string, std::string> params;
-    params[kSuggestionsFieldTrialStateParam] =
-        kSuggestionsFieldTrialStateEnabled;
-    if (control_group) {
-      params[kSuggestionsFieldTrialControlParam] =
-          kSuggestionsFieldTrialStateEnabled;
-    }
-    variations::AssociateVariationParams(kSuggestionsFieldTrialName, "Group1",
-                                         params);
-    field_trial_ = base::FieldTrialList::CreateFieldTrial(
-        kSuggestionsFieldTrialName, "Group1");
-    field_trial_->group();
-  }
-
   void FetchSuggestionsDataHelper(SyncState sync_state) {
     scoped_ptr<SuggestionsService> suggestions_service(
         CreateSuggestionsServiceWithMocks());
     EXPECT_TRUE(suggestions_service != NULL);
 
     // Add some suggestions in the cache.
     FillSuggestionsStore();
     SuggestionsProfile suggestions_profile;
     test_suggestions_store_->LoadSuggestions(&suggestions_profile);
 
@@ skipping 103 matching lines @@
  protected:
   base::MessageLoopForIO io_message_loop_;
   net::FakeURLFetcherFactory factory_;
   // Only used if the SuggestionsService is built with mocks. Not owned.
   MockImageManager* mock_thumbnail_manager_;
   MockBlacklistStore* mock_blacklist_store_;
   TestSuggestionsStore* test_suggestions_store_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
 
  private:
-  scoped_ptr<base::FieldTrialList> field_trial_list_;
-  scoped_refptr<base::FieldTrial> field_trial_;
-
   DISALLOW_COPY_AND_ASSIGN(SuggestionsServiceTest);
 };
 
-TEST_F(SuggestionsServiceTest, IsControlGroup) {
-  EnableFieldTrial(false);
-  EXPECT_FALSE(SuggestionsService::IsControlGroup());
-
-  EnableFieldTrial(true);
-  EXPECT_TRUE(SuggestionsService::IsControlGroup());
-}
-
 TEST_F(SuggestionsServiceTest, FetchSuggestionsData) {
-  EnableFieldTrial(false);
   FetchSuggestionsDataHelper(INITIALIZED_ENABLED_HISTORY);
 }
 
 TEST_F(SuggestionsServiceTest, FetchSuggestionsDataSyncNotInitializedEnabled) {
-  EnableFieldTrial(false);
   FetchSuggestionsDataHelper(NOT_INITIALIZED_ENABLED);
 }
 
 TEST_F(SuggestionsServiceTest, FetchSuggestionsDataSyncDisabled) {
-  EnableFieldTrial(false);
   scoped_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   EXPECT_TRUE(suggestions_service != NULL);
 
   FillSuggestionsStore();
 
   // Send the request. Cache is cleared and empty data will be returned to the
   // callback.
   suggestions_service->FetchSuggestionsData(
       SYNC_OR_HISTORY_SYNC_DISABLED,
       base::Bind(&SuggestionsServiceTest::ExpectEmptySuggestionsProfile,
                  base::Unretained(this)));
 
   // Ensure that ExpectEmptySuggestionsProfile ran once.
   EXPECT_EQ(1, suggestions_empty_data_count_);
 }
 
 TEST_F(SuggestionsServiceTest, IssueRequestIfNoneOngoingError) {
-  EnableFieldTrial(false);
   scoped_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   EXPECT_TRUE(suggestions_service != NULL);
 
   // Fake a request error.
   factory_.SetFakeResponse(GURL(kSuggestionsURL), "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(GURL(kSuggestionsURL));
 
   // (Testing only) wait until suggestion fetch is complete.
   io_message_loop_.RunUntilIdle();
 }
 
 TEST_F(SuggestionsServiceTest, IssueRequestIfNoneOngoingResponseNotOK) {
-  EnableFieldTrial(false);
   scoped_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   EXPECT_TRUE(suggestions_service != NULL);
 
   // Add some suggestions in the cache.
   FillSuggestionsStore();
 
   // Fake a non-200 response code.
   factory_.SetFakeResponse(GURL(kSuggestionsURL), "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(GURL(kSuggestionsURL));
 
   // (Testing only) wait until suggestion fetch is complete.
   io_message_loop_.RunUntilIdle();
 
   // Expect no suggestions in the cache.
   SuggestionsProfile empty_suggestions;
   EXPECT_FALSE(test_suggestions_store_->LoadSuggestions(&empty_suggestions));
 }
 
 TEST_F(SuggestionsServiceTest, BlacklistURL) {
-  EnableFieldTrial(false);
   scoped_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   EXPECT_TRUE(suggestions_service != NULL);
   base::TimeDelta no_delay = base::TimeDelta::FromSeconds(0);
   suggestions_service->set_blacklist_delay(no_delay);
 
   GURL blacklist_url(kBlacklistUrl);
   std::string request_url = GetExpectedBlacklistRequestUrl(blacklist_url);
   SuggestionsProfile suggestions_profile = CreateSuggestionsProfile();
   factory_.SetFakeResponse(GURL(request_url),
@@ skipping 23 matching lines @@
   base::MessageLoop::current()->RunUntilIdle();
   io_message_loop_.RunUntilIdle();
   base::MessageLoop::current()->RunUntilIdle();
 
   // Ensure that CheckSuggestionsData() ran once.
   EXPECT_EQ(1, suggestions_data_check_count_);
   EXPECT_FALSE(blacklisting_failed_);
 }
 
 TEST_F(SuggestionsServiceTest, BlacklistURLFails) {
-  EnableFieldTrial(false);
   scoped_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   EXPECT_TRUE(suggestions_service != NULL);
   GURL blacklist_url(kBlacklistUrl);
   EXPECT_CALL(*mock_blacklist_store_, BlacklistUrl(Eq(blacklist_url)))
       .WillOnce(Return(false));
 
   Blacklist(suggestions_service.get(), blacklist_url);
 
   EXPECT_TRUE(blacklisting_failed_);
   EXPECT_EQ(0, suggestions_data_check_count_);
 }
 
 // Initial blacklist request fails, triggering a second which succeeds.
 TEST_F(SuggestionsServiceTest, BlacklistURLRequestFails) {
-  EnableFieldTrial(false);
   scoped_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   EXPECT_TRUE(suggestions_service != NULL);
   base::TimeDelta no_delay = base::TimeDelta::FromSeconds(0);
   suggestions_service->set_blacklist_delay(no_delay);
 
   GURL blacklist_url(kBlacklistUrl);
   std::string request_url = GetExpectedBlacklistRequestUrl(blacklist_url);
   GURL blacklist_url_alt(kBlacklistUrlAlt);
   std::string request_url_alt = GetExpectedBlacklistRequestUrl(
@@ skipping 36 matching lines @@
   // RunUntilIdle on the MessageLoop only works when the task is not posted for
   // the future.
   base::MessageLoop::current()->RunUntilIdle();
   io_message_loop_.RunUntilIdle();
   base::MessageLoop::current()->RunUntilIdle();
   io_message_loop_.RunUntilIdle();
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 TEST_F(SuggestionsServiceTest, UndoBlacklistURL) {
-  EnableFieldTrial(false);
   scoped_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   EXPECT_TRUE(suggestions_service != NULL);
   // Ensure scheduling the request doesn't happen before undo.
   base::TimeDelta delay = base::TimeDelta::FromHours(1);
   suggestions_service->set_blacklist_delay(delay);
   SuggestionsProfile suggestions_profile = CreateSuggestionsProfile();
   GURL blacklist_url(kBlacklistUrl);
 
   // Blacklist expectations.
@@ skipping 16 matching lines @@
   Blacklist(suggestions_service.get(), blacklist_url);
   UndoBlacklist(suggestions_service.get(), blacklist_url);
 
   EXPECT_EQ(2, suggestions_data_check_count_);
   EXPECT_FALSE(blacklisting_failed_);
   EXPECT_FALSE(undo_blacklisting_failed_);
 }
 
 
 TEST_F(SuggestionsServiceTest, UndoBlacklistURLFailsIfNotInBlacklist) {
-  EnableFieldTrial(false);
   UndoBlacklistURLFailsHelper(true);
 }
 
 TEST_F(SuggestionsServiceTest, UndoBlacklistURLFailsIfAlreadyCandidate) {
-  EnableFieldTrial(false);
   UndoBlacklistURLFailsHelper(false);
 }
 
 TEST_F(SuggestionsServiceTest, GetBlacklistedUrl) {
-  EnableFieldTrial(false);
   scoped_ptr<GURL> request_url;
   scoped_ptr<net::FakeURLFetcher> fetcher;
   GURL retrieved_url;
 
   // Not a blacklist request.
   request_url.reset(new GURL("http://not-blacklisting.com/a?b=c"));
   fetcher = CreateURLFetcher(*request_url, NULL, "", net::HTTP_OK,
                              net::URLRequestStatus::SUCCESS);
   EXPECT_FALSE(SuggestionsService::GetBlacklistedUrl(*fetcher, &retrieved_url));
 
   // An actual blacklist request.
   string blacklisted_url = "http://blacklisted.com/a?b=c&d=e";
   string encoded_blacklisted_url =
       "http%3A%2F%2Fblacklisted.com%2Fa%3Fb%3Dc%26d%3De";
   string blacklist_request_prefix(kSuggestionsBlacklistURLPrefix);
   request_url.reset(
       new GURL(blacklist_request_prefix + encoded_blacklisted_url));
   fetcher.reset();
   fetcher = CreateURLFetcher(*request_url, NULL, "", net::HTTP_OK,
                              net::URLRequestStatus::SUCCESS);
   EXPECT_TRUE(SuggestionsService::GetBlacklistedUrl(*fetcher, &retrieved_url));
   EXPECT_EQ(blacklisted_url, retrieved_url.spec());
 }
 
 TEST_F(SuggestionsServiceTest, UpdateBlacklistDelay) {
-  EnableFieldTrial(false);
   scoped_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   base::TimeDelta initial_delay = suggestions_service->blacklist_delay();
 
   // Delay unchanged on success.
   suggestions_service->UpdateBlacklistDelay(true);
   EXPECT_EQ(initial_delay, suggestions_service->blacklist_delay());
 
   // 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());
 }
 
 TEST_F(SuggestionsServiceTest, CheckDefaultTimeStamps) {
-  EnableFieldTrial(false);
   scoped_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMocks());
   SuggestionsProfile suggestions =
       CreateSuggestionsProfileWithExpiryTimestamps();
   suggestions_service->SetDefaultExpiryTimestamp(&suggestions,
                                                  kTestDefaultExpiry);
   EXPECT_EQ(kTestSetExpiry, suggestions.suggestions(0).expiry_ts());
   EXPECT_EQ(kTestDefaultExpiry, suggestions.suggestions(1).expiry_ts());
 }
 }  // namespace suggestions