Introduce flag to disable static popular sites.

components/ntp_tiles/popular_sites_impl_unittest.cc

 // Copyright 2016 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_tiles/popular_sites_impl.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/important_file_writer.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ptr_util.h"
 #include "base/optional.h"
 #include "base/run_loop.h"
+#include "base/test/scoped_command_line.h"
 #include "base/test/sequenced_worker_pool_owner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
+#include "components/ntp_tiles/constants.h"
 #include "components/ntp_tiles/json_unsafe_parser.h"
 #include "components/ntp_tiles/pref_names.h"
 #include "components/ntp_tiles/switches.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
+#include "components/variations/variations_params_manager.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::Eq;
 using testing::Gt;
 using testing::IsEmpty;
@@ skipping 14 matching lines @@
 }
 
 ::testing::Matcher<const GURL&> URLEq(const std::string& s) {
   return ::testing::Eq(GURL(s));
 }
 
 size_t GetNumberOfDefaultPopularSitesForPlatform() {
 #if defined(OS_ANDROID) || defined(OS_IOS)
   return 8ul;
 #else
-  return 0;
+  return 0ul;
 #endif
 }
 
 class PopularSitesTest : public ::testing::Test {
  protected:
   PopularSitesTest()
       : kWikipedia{
             {kTitle, "Wikipedia, fhta Ph'nglui mglw'nafh"},
             {kUrl, "https://zz.m.wikipedia.org/"},
             {kLargeIconUrl, "https://zz.m.wikipedia.org/wikipedia.png"},
         },
         kYouTube{
             {kTitle, "YouTube"},
             {kUrl, "https://m.youtube.com/"},
             {kLargeIconUrl, "https://s.ytimg.com/apple-touch-icon.png"},
         },
         kChromium{
             {kTitle, "The Chromium Project"},
             {kUrl, "https://www.chromium.org/"},
             {kFaviconUrl, "https://www.chromium.org/favicon.ico"},
         },
         worker_pool_owner_(2, "PopularSitesTest."),
+        prefs_(new sync_preferences::TestingPrefServiceSyncable()),
         url_fetcher_factory_(nullptr) {
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kEnableNTPPopularSites);
-    PopularSitesImpl::RegisterProfilePrefs(prefs_.registry());
+    PopularSitesImpl::RegisterProfilePrefs(prefs_->registry());
     CHECK(scoped_cache_dir_.CreateUniqueTempDir());
     cache_dir_ = scoped_cache_dir_.GetPath();
   }
 
   void SetCountryAndVersion(const std::string& country,
                             const std::string& version) {
-    prefs_.SetString(prefs::kPopularSitesOverrideCountry, country);
-    prefs_.SetString(prefs::kPopularSitesOverrideVersion, version);
+    prefs_->SetString(prefs::kPopularSitesOverrideCountry, country);
+    prefs_->SetString(prefs::kPopularSitesOverrideVersion, version);
   }
 
   void RespondWithJSON(const std::string& url,
                        const TestPopularSiteVector& sites) {
     base::ListValue sites_value;
     for (const TestPopularSite& site : sites) {
       auto site_value = base::MakeUnique<base::DictionaryValue>();
       for (const std::pair<std::string, std::string>& kv : site) {
         site_value->SetString(kv.first, kv.second);
       }
       sites_value.Append(std::move(site_value));
     }
     std::string sites_string;
     base::JSONWriter::Write(sites_value, &sites_string);
     url_fetcher_factory_.SetFakeResponse(GURL(url), sites_string, net::HTTP_OK,
                                          net::URLRequestStatus::SUCCESS);
   }
 
   void RespondWithData(const std::string& url, const std::string& data) {
     url_fetcher_factory_.SetFakeResponse(GURL(url), data, net::HTTP_OK,
                                          net::URLRequestStatus::SUCCESS);
   }
 
   void RespondWith404(const std::string& url) {
     url_fetcher_factory_.SetFakeResponse(GURL(url), "404", net::HTTP_NOT_FOUND,
                                          net::URLRequestStatus::SUCCESS);
   }
 
+  void ReregisterProfilePrefs() {
+    prefs_ = base::MakeUnique<sync_preferences::TestingPrefServiceSyncable>();
+    PopularSitesImpl::RegisterProfilePrefs(prefs_->registry());
+  }
+
   // Returns an optional bool representing whether the completion callback was
   // called at all, and if yes which was the returned bool value.
   base::Optional<bool> FetchPopularSites(bool force_download,
                                          PopularSites::SitesVector* sites) {
     scoped_refptr<net::TestURLRequestContextGetter> url_request_context(
         new net::TestURLRequestContextGetter(
             base::ThreadTaskRunnerHandle::Get()));
     std::unique_ptr<PopularSites> popular_sites =
         CreatePopularSites(url_request_context.get());
 
     base::RunLoop loop;
     base::Optional<bool> save_success;
     if (popular_sites->MaybeStartFetch(
             force_download, base::Bind(
                                 [](base::Optional<bool>* save_success,
                                    base::RunLoop* loop, bool success) {
                                   save_success->emplace(success);
                                   loop->Quit();
                                 },
                                 &save_success, &loop))) {
       loop.Run();
     }
     *sites = popular_sites->sites();
     return save_success;
   }
 
   std::unique_ptr<PopularSites> CreatePopularSites(
       net::URLRequestContextGetter* context) {
     return base::MakeUnique<PopularSitesImpl>(
-        worker_pool_owner_.pool().get(), &prefs_,
+        worker_pool_owner_.pool().get(), prefs_.get(),
         /*template_url_service=*/nullptr,
         /*variations_service=*/nullptr, context, cache_dir_,
         base::Bind(JsonUnsafeParser::Parse));
   }
 
   const TestPopularSite kWikipedia;
   const TestPopularSite kYouTube;
   const TestPopularSite kChromium;
 
   base::MessageLoopForUI ui_loop_;
   base::SequencedWorkerPoolOwner worker_pool_owner_;
   base::ScopedTempDir scoped_cache_dir_;
   base::FilePath cache_dir_;
-  sync_preferences::TestingPrefServiceSyncable prefs_;
+  std::unique_ptr<sync_preferences::TestingPrefServiceSyncable> prefs_;
   net::FakeURLFetcherFactory url_fetcher_factory_;
 };
 
 TEST_F(PopularSitesTest, ContainsDefaultTilesRightAfterConstruction) {
   scoped_refptr<net::TestURLRequestContextGetter> url_request_context(
       new net::TestURLRequestContextGetter(
           base::ThreadTaskRunnerHandle::Get()));
 
   auto popular_sites = CreatePopularSites(url_request_context.get());
   EXPECT_THAT(popular_sites->sites().size(),
               Eq(GetNumberOfDefaultPopularSitesForPlatform()));
 }
 
-TEST_F(PopularSitesTest, Zasic) {
+TEST_F(PopularSitesTest, IsEmptyOnConstructionIfDisabledByFlag) {
+  // If both switches are present, the disable flag overrides the enable flag.
+  base::test::ScopedCommandLine command_line;
+  command_line.GetProcessCommandLine()->AppendSwitch(
+      switches::kEnableNTPBakedInSites);
+  command_line.GetProcessCommandLine()->AppendSwitch(
+      switches::kDisableNTPBakedInSites);
+  ReregisterProfilePrefs();
+
+  scoped_refptr<net::TestURLRequestContextGetter> url_request_context(
+      new net::TestURLRequestContextGetter(
+          base::ThreadTaskRunnerHandle::Get()));
+  auto popular_sites = CreatePopularSites(url_request_context.get());
+
+  EXPECT_THAT(popular_sites->sites().size(), Eq(0ul));
+}
+
+TEST_F(PopularSitesTest, IsEmptyOnConstructionIfDisabledByTrial) {
+  variations::testing::VariationParamsManager variations_params(
+      ntp_tiles::kPopularSitesFieldTrialName,
+      {{ntp_tiles::kEnableBakedInSitesParamName, "false"}});
+  ReregisterProfilePrefs();
+
+  scoped_refptr<net::TestURLRequestContextGetter> url_request_context(
+      new net::TestURLRequestContextGetter(
+          base::ThreadTaskRunnerHandle::Get()));
+  auto popular_sites = CreatePopularSites(url_request_context.get());
+
+  EXPECT_THAT(popular_sites->sites().size(), Eq(0ul));
+}
+
+TEST_F(PopularSitesTest, ShouldSucceedFetching) {
   SetCountryAndVersion("ZZ", "9");
   RespondWithJSON(
       "https://www.gstatic.com/chrome/ntp/suggested_sites_ZZ_9.json",
       {kWikipedia});
 
   PopularSites::SitesVector sites;
   EXPECT_THAT(FetchPopularSites(/*force_download=*/false, &sites),
               Eq(base::Optional<bool>(true)));
 
   ASSERT_THAT(sites.size(), Eq(1u));
@@ skipping 238 matching lines @@
       "https://www.gstatic.com/chrome/ntp/suggested_sites_ZZ_9.json",
       {kChromium});
   EXPECT_THAT(FetchPopularSites(/*force_download=*/false, &sites),
               Eq(base::Optional<bool>(true)));
   ASSERT_THAT(sites.size(), Eq(1u));
   EXPECT_THAT(sites[0].url, URLEq("https://www.chromium.org/"));
 }
 
 }  // namespace
 }  // namespace ntp_tiles