[cleanup] Remove feature WinDelaySpellcheckServiceInit

The feature has landed already years ago, but the feature flag has never
been cleaned up.

[email protected]

Bug: 40681243, 356623689
Change-Id: Id94047197e4d79dd4c19af63de770127fd233a9e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/7012087
Reviewed-by: Hidehiko Abe <[email protected]>
Reviewed-by: Guillaume Jenkins <[email protected]>
Commit-Queue: Andreas Haas <[email protected]>
Cr-Commit-Position: refs/heads/main@{#1532372}

Author: gahaas

chrome/browser/chrome_browser_main.cc

@@ -1412,17 +1412,6 @@ void ChromeBrowserMainParts::PostProfileInit(Profile* profile,
                        profile->GetPath()));
   }
 
-#if BUILDFLAG(USE_BROWSER_SPELLCHECKER)
-  // Create the spellcheck service. This will asynchronously retrieve the
-  // Windows platform spellcheck dictionary language tags used to populate the
-  // context menu for editable content.
-  if (spellcheck::UseBrowserSpellChecker() &&
-      profile->GetPrefs()->GetBoolean(spellcheck::prefs::kSpellCheckEnable) &&
-      !base::FeatureList::IsEnabled(
-          spellcheck::kWinDelaySpellcheckServiceInit)) {
-    SpellcheckServiceFactory::GetForContext(profile);
-  }
-#endif
 #endif  // BUILDFLAG(IS_WIN)
 
 #if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_LINUX) || \

chrome/browser/extensions/api/language_settings_private/language_settings_private_api.cc

@@ -275,21 +275,15 @@ LanguageSettingsPrivateGetLanguageListFunction::Run() {
 
 #if BUILDFLAG(IS_WIN)
   if (spellcheck::UseBrowserSpellChecker()) {
-    if (!base::FeatureList::IsEnabled(
-            spellcheck::kWinDelaySpellcheckServiceInit)) {
-      // Platform dictionary support already determined at browser startup.
-      UpdateSupportedPlatformDictionaries();
-    } else {
-      // Asynchronously load the dictionaries to determine platform support.
-      SpellcheckService* service =
-          SpellcheckServiceFactory::GetForContext(browser_context());
-      AddRef();  // Balanced in OnDictionariesInitialized
-      service->InitializeDictionaries(
-          base::BindOnce(&LanguageSettingsPrivateGetLanguageListFunction::
-                             OnDictionariesInitialized,
-                         base::Unretained(this)));
-      return RespondLater();
-    }
+    // Asynchronously load the dictionaries to determine platform support.
+    SpellcheckService* service =
+        SpellcheckServiceFactory::GetForContext(browser_context());
+    AddRef();  // Balanced in OnDictionariesInitialized
+    service->InitializeDictionaries(
+        base::BindOnce(&LanguageSettingsPrivateGetLanguageListFunction::
+                           OnDictionariesInitialized,
+                       base::Unretained(this)));
+    return RespondLater();
   }
 #endif  // BUILDFLAG(IS_WIN)
 

chrome/browser/extensions/api/language_settings_private/language_settings_private_api_unittest.cc

@@ -116,8 +116,6 @@ class LanguageSettingsPrivateApiTest : public ExtensionServiceTestBase {
  protected:
   void RunGetLanguageListTest();
 
-  virtual void InitFeatures() {}
-
 #if BUILDFLAG(IS_WIN)
   virtual void AddSpellcheckLanguagesForTesting(
       const std::vector<std::string>& spellcheck_languages_for_testing) {
@@ -136,8 +134,6 @@ class LanguageSettingsPrivateApiTest : public ExtensionServiceTestBase {
     EventRouterFactory::GetInstance()->SetTestingFactory(
         profile(), base::BindRepeating(&BuildEventRouter));
 
-    InitFeatures();
-
     LanguageSettingsPrivateDelegateFactory::GetInstance()->SetTestingFactory(
         profile(), base::BindRepeating(&BuildLanguageSettingsPrivateDelegate));
 
@@ -295,28 +291,6 @@ TEST_F(LanguageSettingsPrivateApiTest, GetNeverTranslateLanguagesListTest) {
   }
 }
 
-class LanguageSettingsPrivateApiGetLanguageListTest
-    : public LanguageSettingsPrivateApiTest {
- public:
-  LanguageSettingsPrivateApiGetLanguageListTest() = default;
-  ~LanguageSettingsPrivateApiGetLanguageListTest() override = default;
-
- protected:
-  void InitFeatures() override {
-#if BUILDFLAG(IS_WIN)
-    // Disable the delayed init feature since that case is tested in
-    // LanguageSettingsPrivateApiTestDelayInit below.
-    feature_list_.InitAndDisableFeature(
-        spellcheck::kWinDelaySpellcheckServiceInit);
-#endif  // BUILDFLAG(IS_WIN)
-  }
-};
-
-TEST_F(LanguageSettingsPrivateApiGetLanguageListTest, GetLanguageList) {
-  translate::TranslateDownloadManager::GetInstance()->ResetForTesting();
-  RunGetLanguageListTest();
-}
-
 void LanguageSettingsPrivateApiTest::RunGetLanguageListTest() {
   struct LanguageToTest {
     std::string accept_language;
@@ -726,13 +700,6 @@ class LanguageSettingsPrivateApiTestDelayInit
   LanguageSettingsPrivateApiTestDelayInit() = default;
 
  protected:
-  void InitFeatures() override {
-    // Force Windows hybrid spellcheck and delayed initialization of the
-    // spellcheck service to be enabled.
-    feature_list_.InitAndEnableFeature(
-        spellcheck::kWinDelaySpellcheckServiceInit);
-  }
-
   void AddSpellcheckLanguagesForTesting(
       const std::vector<std::string>& spellcheck_languages_for_testing)
       override {

chrome/browser/renderer_context_menu/spelling_menu_observer_browsertest.cc

@@ -30,7 +30,7 @@ namespace {
 // accesses resources.
 class SpellingMenuObserverTest : public InProcessBrowserTest {
  public:
-  SpellingMenuObserverTest();
+  SpellingMenuObserverTest() = default;
 
   void SetUpOnMainThread() override {
     Reset(false);
@@ -54,6 +54,12 @@ class SpellingMenuObserverTest : public InProcessBrowserTest {
       content::BrowserContext* context) {
     auto spellcheck_service = std::make_unique<SpellcheckService>(context);
 
+    // With delayed initialization, we need to initialize dictionaries.
+    spellcheck_service->InitializeDictionaries(
+        base::BindOnce(&SpellingMenuObserverTest::OnSuggestionsComplete,
+                       base::Unretained(this)));
+    RunUntilCallbackReceived();
+
     // Call SetLanguage to assure that the platform spellchecker is initialized.
     spellcheck_platform::SetLanguage(
         spellcheck_service->platform_spell_checker(), "en-US",
@@ -167,16 +173,6 @@ class SpellingMenuObserverTest : public InProcessBrowserTest {
 #endif  // BUILDFLAG(IS_WIN) && BUILDFLAG(USE_BROWSER_SPELLCHECKER)
 };
 
-#if BUILDFLAG(IS_WIN) && BUILDFLAG(USE_BROWSER_SPELLCHECKER)
-SpellingMenuObserverTest::SpellingMenuObserverTest() {
-  feature_list_.InitWithFeatures(
-      /*enabled_features=*/{},
-      /*disabled_features=*/{spellcheck::kWinDelaySpellcheckServiceInit});
-}
-#else
-SpellingMenuObserverTest::SpellingMenuObserverTest() = default;
-#endif  // BUILDFLAG(IS_WIN) && BUILDFLAG(USE_BROWSER_SPELLCHECKER)
-
 SpellingMenuObserverTest::~SpellingMenuObserverTest() = default;
 
 }  // namespace

chrome/browser/site_isolation/spellcheck_per_process_browsertest.cc

@@ -133,26 +133,21 @@ class MockSpellCheckHost : spellcheck::mojom::SpellCheckHost {
 #if BUILDFLAG(IS_WIN)
   void InitializeDictionaries(
       InitializeDictionariesCallback callback) override {
-    if (base::FeatureList::IsEnabled(
-            spellcheck::kWinDelaySpellcheckServiceInit)) {
-      SpellcheckService* spellcheck = SpellcheckServiceFactory::GetForContext(
-          process_host()->GetBrowserContext());
-
-      if (!spellcheck) {  // Teardown.
-        std::move(callback).Run(/*dictionaries=*/{}, /*custom_words=*/{},
-                                /*enable=*/false);
-        return;
-      }
-
-      dictionaries_loaded_callback_ = std::move(callback);
-
-      spellcheck->InitializeDictionaries(
-          base::BindOnce(&MockSpellCheckHost::OnDictionariesInitialized,
-                         base::Unretained(this)));
+    SpellcheckService* spellcheck = SpellcheckServiceFactory::GetForContext(
+        process_host()->GetBrowserContext());
+
+    if (!spellcheck) {  // Teardown.
+      std::move(callback).Run(/*dictionaries=*/{}, /*custom_words=*/{},
+                              /*enable=*/false);
       return;
     }
 
-    NOTREACHED();
+    dictionaries_loaded_callback_ = std::move(callback);
+
+    spellcheck->InitializeDictionaries(
+        base::BindOnce(&MockSpellCheckHost::OnDictionariesInitialized,
+                       base::Unretained(this)));
+    return;
   }
 
   void OnDictionariesInitialized() {
@@ -264,17 +259,7 @@ class ChromeSitePerProcessSpellCheckTest : public ChromeSitePerProcessTest {
  public:
   ChromeSitePerProcessSpellCheckTest() = default;
 
-  void SetUp() override {
-#if BUILDFLAG(IS_WIN) && BUILDFLAG(USE_BROWSER_SPELLCHECKER)
-    // When delayed initialization of the spellcheck service is enabled by
-    // default, want to maintain test coverage for the older code path that
-    // initializes spellcheck on browser startup.
-    feature_list_.InitAndDisableFeature(
-        spellcheck::kWinDelaySpellcheckServiceInit);
-#endif  // BUILDFLAG(IS_WIN) && BUILDFLAG(USE_BROWSER_SPELLCHECKER)
-
-    ChromeSitePerProcessTest::SetUp();
-  }
+  void SetUp() override { ChromeSitePerProcessTest::SetUp(); }
 
  protected:
   // Tests that spelling in out-of-process subframes is checked.
@@ -381,29 +366,3 @@ IN_PROC_BROWSER_TEST_F(ChromeSitePerProcessSpellCheckTest,
   EXPECT_TRUE(host->SpellingPanelVisible());
 }
 #endif  // BUILDFLAG(HAS_SPELLCHECK_PANEL)
-
-#if BUILDFLAG(IS_WIN) && BUILDFLAG(USE_BROWSER_SPELLCHECKER)
-class ChromeSitePerProcessSpellCheckTestDelayInit
-    : public ChromeSitePerProcessSpellCheckTest {
- public:
-  ChromeSitePerProcessSpellCheckTestDelayInit() = default;
-
-  void SetUp() override {
-    // Don't initialize the SpellcheckService on browser launch.
-    feature_list_.InitAndEnableFeature(
-        spellcheck::kWinDelaySpellcheckServiceInit);
-
-    ChromeSitePerProcessTest::SetUp();
-  }
-};
-
-IN_PROC_BROWSER_TEST_F(ChromeSitePerProcessSpellCheckTestDelayInit,
-                       OOPIFSpellCheckTest) {
-  RunOOPIFSpellCheckTest();
-}
-
-IN_PROC_BROWSER_TEST_F(ChromeSitePerProcessSpellCheckTestDelayInit,
-                       OOPIFDisabledSpellCheckTest) {
-  RunOOPIFDisabledSpellCheckTest();
-}
-#endif  // BUILDFLAG(IS_WIN) && BUILDFLAG(USE_BROWSER_SPELLCHECKER)

chrome/browser/spellchecker/spell_check_host_chrome_impl.cc

@@ -186,27 +186,21 @@ void SpellCheckHostChromeImpl::InitializeDictionaries(
     InitializeDictionariesCallback callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  if (base::FeatureList::IsEnabled(
-          spellcheck::kWinDelaySpellcheckServiceInit)) {
-    // Initialize the spellcheck service if needed. Initialization must
-    // happen on UI thread.
-    SpellcheckService* spellcheck = GetSpellcheckService();
-
-    if (!spellcheck) {  // Teardown.
-      std::move(callback).Run(/*dictionaries=*/{}, /*custom_words=*/{},
-                              /*enable=*/false);
-      return;
-    }
-
-    dictionaries_loaded_callback_ = std::move(callback);
+  // Initialize the spellcheck service if needed. Initialization must
+  // happen on UI thread.
+  SpellcheckService* spellcheck = GetSpellcheckService();
 
-    spellcheck->InitializeDictionaries(
-        base::BindOnce(&SpellCheckHostChromeImpl::OnDictionariesInitialized,
-                       weak_factory_.GetWeakPtr()));
+  if (!spellcheck) {  // Teardown.
+    std::move(callback).Run(/*dictionaries=*/{}, /*custom_words=*/{},
+                            /*enable=*/false);
     return;
   }
 
-  NOTREACHED();
+  dictionaries_loaded_callback_ = std::move(callback);
+
+  spellcheck->InitializeDictionaries(
+      base::BindOnce(&SpellCheckHostChromeImpl::OnDictionariesInitialized,
+                     weak_factory_.GetWeakPtr()));
 }
 
 void SpellCheckHostChromeImpl::OnDictionariesInitialized() {

chrome/browser/spellchecker/spell_check_host_chrome_impl_win_browsertest.cc

@@ -32,12 +32,7 @@ class SpellCheckHostChromeImplWinBrowserTest : public InProcessBrowserTest {
  public:
   SpellCheckHostChromeImplWinBrowserTest() = default;
 
-  void SetUp() override {
-    // Don't delay initialization of the SpellcheckService on browser launch.
-    feature_list_.InitAndDisableFeature(
-        spellcheck::kWinDelaySpellcheckServiceInit);
-    InProcessBrowserTest::SetUp();
-  }
+  void SetUp() override { InProcessBrowserTest::SetUp(); }
 
   void SetUpOnMainThread() override {
     content::BrowserContext* context = browser()->profile();
@@ -55,7 +50,22 @@ class SpellCheckHostChromeImplWinBrowserTest : public InProcessBrowserTest {
 
   void TearDownOnMainThread() override { renderer_.reset(); }
 
-  virtual void InitializeSpellcheckService() {}
+  void InitializeSpellcheckService() {
+    spell_check_host_->InitializeDictionaries(base::BindOnce(
+        &SpellCheckHostChromeImplWinBrowserTest::InitializeDictionariesCallback,
+        base::Unretained(this)));
+    RunUntilResultReceived();
+  }
+
+  void InitializeDictionariesCallback(
+      std::vector<spellcheck::mojom::SpellCheckBDictLanguagePtr> dictionaries,
+      const std::vector<std::string>& custom_words,
+      bool enable) {
+    received_result_ = true;
+    if (quit_) {
+      std::move(quit_).Run();
+    }
+  }
 
   void OnSpellcheckResult(const std::vector<SpellCheckResult>& result) {
     received_result_ = true;
@@ -129,41 +139,3 @@ void SpellCheckHostChromeImplWinBrowserTest::RunSpellCheckReturnMessageTest() {
   EXPECT_EQ(result_[0].length, 2);
   EXPECT_EQ(result_[0].decoration, SpellCheckResult::SPELLING);
 }
-
-class SpellCheckHostChromeImplWinBrowserTestDelayInit
-    : public SpellCheckHostChromeImplWinBrowserTest {
- public:
-  SpellCheckHostChromeImplWinBrowserTestDelayInit() = default;
-
-  void SetUp() override {
-    // Don't initialize the SpellcheckService on browser launch.
-    feature_list_.InitAndEnableFeature(
-        spellcheck::kWinDelaySpellcheckServiceInit);
-    InProcessBrowserTest::SetUp();
-  }
-
-  void InitializeSpellcheckService() override {
-    // With the kWinDelaySpellcheckServiceInit feature flag set, the spellcheck
-    // service is not initialized when instantiated. Call InitializeDictionaries
-    // to load the dictionaries.
-    spell_check_host_->InitializeDictionaries(
-        base::BindOnce(&SpellCheckHostChromeImplWinBrowserTestDelayInit::
-                           InitializeDictionariesCallback,
-                       base::Unretained(this)));
-    RunUntilResultReceived();
-  }
-
-  void InitializeDictionariesCallback(
-      std::vector<spellcheck::mojom::SpellCheckBDictLanguagePtr> dictionaries,
-      const std::vector<std::string>& custom_words,
-      bool enable) {
-    received_result_ = true;
-    if (quit_)
-      std::move(quit_).Run();
-  }
-};
-
-IN_PROC_BROWSER_TEST_F(SpellCheckHostChromeImplWinBrowserTestDelayInit,
-                       SpellCheckReturnMessage) {
-  RunSpellCheckReturnMessageTest();
-}

chrome/browser/spellchecker/spellcheck_service.cc

@@ -165,9 +165,7 @@ SpellcheckService::SpellcheckService(content::BrowserContext* context)
   custom_dictionary_->Load();
 
 #if BUILDFLAG(IS_WIN)
-  if (spellcheck::UseBrowserSpellChecker() &&
-      base::FeatureList::IsEnabled(
-          spellcheck::kWinDelaySpellcheckServiceInit)) {
+  if (spellcheck::UseBrowserSpellChecker()) {
     // If initialization of the spellcheck service is on-demand, it is up to the
     // instantiator of the spellcheck service to call InitializeDictionaries
     // with a callback.
@@ -487,9 +485,7 @@ void SpellcheckService::LoadDictionaries() {
   }
 
 #if BUILDFLAG(USE_BROWSER_SPELLCHECKER)
-  if (base::FeatureList::IsEnabled(
-          spellcheck::kWinDelaySpellcheckServiceInit) &&
-      spellcheck::UseBrowserSpellChecker()) {
+  if (spellcheck::UseBrowserSpellChecker()) {
     // Only want to fire the callback on first call to LoadDictionaries
     // originating from InitializeDictionaries, since supported platform
     // dictionaries are cached throughout the browser session and not
@@ -517,9 +513,7 @@ bool SpellcheckService::IsSpellcheckEnabled() const {
 
   bool enable_if_uninitialized = false;
 #if BUILDFLAG(IS_WIN)
-  if (spellcheck::UseBrowserSpellChecker() &&
-      base::FeatureList::IsEnabled(
-          spellcheck::kWinDelaySpellcheckServiceInit)) {
+  if (spellcheck::UseBrowserSpellChecker()) {
     // If initialization of the spellcheck service is on-demand, the
     // renderer-side SpellCheck object needs to start out as enabled in order
     // for a click on editable content to initialize the spellcheck service.