[Android NTP] Logging histograms for users that are part of a control group.

chrome/browser/search/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 <map>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 104 matching lines @@
         suggestions_empty_data_count_(0),
         factory_(NULL, base::Bind(&CreateURLFetcher)),
         mock_suggestions_store_(NULL) {
     profile_ = profile_builder_.Build();
   }
   virtual ~SuggestionsServiceTest() {}
 
   // Enables the "ChromeSuggestions.Group1" field trial.
   void EnableFieldTrial(const std::string& url,
                         const std::string& suggestions_suffix,
-                        const std::string& blacklist_suffix) {
+                        const std::string& blacklist_suffix,
+                        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")));
 
     chrome_variations::testing::ClearAllVariationParams();
     std::map<std::string, std::string> params;
     params[kSuggestionsFieldTrialStateParam] =
         kSuggestionsFieldTrialStateEnabled;
+    if (control_group) {
+      params[kSuggestionsFieldTrialControlParam] =
+          kSuggestionsFieldTrialStateEnabled;
+    }
     params[kSuggestionsFieldTrialURLParam] = url;
     params[kSuggestionsFieldTrialSuggestionsSuffixParam] = suggestions_suffix;
     params[kSuggestionsFieldTrialBlacklistSuffixParam] = blacklist_suffix;
     chrome_variations::AssociateVariationParams(kSuggestionsFieldTrialName,
                                                 "Group1", params);
     field_trial_ = base::FieldTrialList::CreateFieldTrial(
         kSuggestionsFieldTrialName, "Group1");
     field_trial_->group();
   }
 
   SuggestionsService* CreateSuggestionsService() {
     SuggestionsServiceFactory* suggestions_service_factory =
         SuggestionsServiceFactory::GetInstance();
     return suggestions_service_factory->GetForProfile(profile_.get());
   }
 
   // Should not be called more than once per test since it stashes the
   // SuggestionsStore in |mock_suggestions_store_|.
   SuggestionsService* CreateSuggestionsServiceWithMockStore() {
     mock_suggestions_store_ = new StrictMock<MockSuggestionsStore>();
     return new SuggestionsService(
         profile_.get(), scoped_ptr<SuggestionsStore>(mock_suggestions_store_));
   }
 
   void FetchSuggestionsDataNoTimeoutHelper(bool interleaved_requests) {
     // Field trial enabled with a specific suggestions URL.
     EnableFieldTrial(kFakeSuggestionsURL, kFakeSuggestionsSuffix,
-                     kFakeBlacklistSuffix);
+                     kFakeBlacklistSuffix, false);
     scoped_ptr<SuggestionsService> suggestions_service(
         CreateSuggestionsServiceWithMockStore());
     EXPECT_TRUE(suggestions_service != NULL);
     scoped_ptr<SuggestionsProfile> suggestions_profile(
         CreateSuggestionsProfile());
 
     // Set up net::FakeURLFetcherFactory.
     std::string expected_url =
         std::string(kFakeSuggestionsURL) + kFakeSuggestionsSuffix;
     factory_.SetFakeResponse(GURL(expected_url),
@@ skipping 43 matching lines @@
   scoped_ptr<TestingProfile> profile_;
 
   DISALLOW_COPY_AND_ASSIGN(SuggestionsServiceTest);
 };
 
 TEST_F(SuggestionsServiceTest, ServiceBeingCreated) {
   // Field trial not enabled.
   EXPECT_TRUE(CreateSuggestionsService() == NULL);
 
   // Field trial enabled.
-  EnableFieldTrial("", "", "");
+  EnableFieldTrial("", "", "", false);
   EXPECT_TRUE(CreateSuggestionsService() != NULL);
 }
 
+TEST_F(SuggestionsServiceTest, IsControlGroup) {
+  // Field trial enabled.
+  EnableFieldTrial("", "", "", false);
+  EXPECT_FALSE(SuggestionsService::IsControlGroup());
+
+  EnableFieldTrial("", "", "", true);
+  EXPECT_TRUE(SuggestionsService::IsControlGroup());
+}
+
 TEST_F(SuggestionsServiceTest, FetchSuggestionsDataNoTimeout) {
   FetchSuggestionsDataNoTimeoutHelper(false);
 }
 
 TEST_F(SuggestionsServiceTest, FetchSuggestionsDataNoTimeoutInterleaved) {
   FetchSuggestionsDataNoTimeoutHelper(true);
 }
 
 TEST_F(SuggestionsServiceTest, FetchSuggestionsDataRequestError) {
   // Field trial enabled with a specific suggestions URL.
   EnableFieldTrial(kFakeSuggestionsURL, kFakeSuggestionsSuffix,
-                   kFakeBlacklistSuffix);
+                   kFakeBlacklistSuffix, false);
   scoped_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMockStore());
   EXPECT_TRUE(suggestions_service != NULL);
 
   // Fake a request error.
   std::string expected_url =
       std::string(kFakeSuggestionsURL) + kFakeSuggestionsSuffix;
   factory_.SetFakeResponse(GURL(expected_url), "irrelevant", net::HTTP_OK,
                            net::URLRequestStatus::FAILED);
 
   // Set up expectations on the SuggestionsStore.
   EXPECT_CALL(*mock_suggestions_store_, LoadSuggestions(_))
       .WillOnce(Return(true));
 
   // 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();
 
   // 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, kFakeSuggestionsSuffix,
-                   kFakeBlacklistSuffix);
+                   kFakeBlacklistSuffix, false);
   scoped_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMockStore());
   EXPECT_TRUE(suggestions_service != NULL);
 
   // Response code != 200.
   std::string expected_url =
       std::string(kFakeSuggestionsURL) + kFakeSuggestionsSuffix;
   factory_.SetFakeResponse(GURL(expected_url), "irrelevant",
                            net::HTTP_BAD_REQUEST,
                            net::URLRequestStatus::SUCCESS);
 
   // Set up expectations on the SuggestionsStore.
   EXPECT_CALL(*mock_suggestions_store_, ClearSuggestions());
 
   // 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();
 
   // Ensure that ExpectEmptySuggestionsProfile ran once.
   EXPECT_EQ(1, suggestions_empty_data_count_);
 }
 
 TEST_F(SuggestionsServiceTest, BlacklistURL) {
   EnableFieldTrial(kFakeSuggestionsURL, kFakeSuggestionsSuffix,
-                   kFakeBlacklistSuffix);
+                   kFakeBlacklistSuffix, false);
   scoped_ptr<SuggestionsService> suggestions_service(
       CreateSuggestionsServiceWithMockStore());
   EXPECT_TRUE(suggestions_service != NULL);
 
   std::string expected_url(kFakeSuggestionsURL);
   expected_url.append(kFakeBlacklistSuffix)
       .append(net::EscapeQueryParamValue(GURL(kBlacklistUrl).spec(), true));
   scoped_ptr<SuggestionsProfile> suggestions_profile(
       CreateSuggestionsProfile());
   factory_.SetFakeResponse(GURL(expected_url),
@@ skipping 12 matching lines @@
                  base::Unretained(this)));
 
   // (Testing only) wait until blacklist request is complete.
   base::MessageLoop::current()->RunUntilIdle();
 
   // Ensure that CheckSuggestionsData() ran once.
   EXPECT_EQ(1, suggestions_data_check_count_);
 }
 
 }  // namespace suggestions