Remove spellchecker feedback.

chrome/browser/spellchecker/spellcheck_service.cc

 // Copyright (c) 2012 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/spellchecker/spellcheck_service.h"
 
 #include <set>
 
 #include "base/logging.h"
 #include "base/strings/string_split.h"
 #include "base/supports_user_data.h"
 #include "base/synchronization/waitable_event.h"
 #include "build/build_config.h"
-#include "chrome/browser/spellchecker/feedback_sender.h"
 #include "chrome/browser/spellchecker/spellcheck_factory.h"
 #include "chrome/browser/spellchecker/spellcheck_host_metrics.h"
 #include "chrome/browser/spellchecker/spellcheck_hunspell_dictionary.h"
 #include "chrome/browser/spellchecker/spellcheck_platform.h"
 #include "chrome/browser/spellchecker/spelling_service_client.h"
 #include "chrome/common/pref_names.h"
 #include "components/prefs/pref_member.h"
 #include "components/prefs/pref_service.h"
 #include "components/spellcheck/common/spellcheck_bdict_language.h"
 #include "components/spellcheck/common/spellcheck_common.h"
@@ skipping 49 matching lines @@
 
   if (first_of_dictionaries.empty() && !single_dictionary.empty()) {
     first_of_dictionaries = single_dictionary;
     dictionaries_pref.SetValue(
         std::vector<std::string>(1, first_of_dictionaries));
   }
 
   single_dictionary_pref.SetValue("");
 #endif  // defined(USE_BROWSER_SPELLCHECKER)
 
-  std::string language_code;
-  std::string country_code;
-  spellcheck::GetISOLanguageCountryCodeFromLocale(
-      first_of_dictionaries, &language_code, &country_code);
-  feedback_sender_.reset(new spellcheck::FeedbackSender(
-      content::BrowserContext::GetDefaultStoragePartition(context)->
-            GetURLRequestContext(),
-      language_code, country_code));
-
   pref_change_registrar_.Add(
       prefs::kSpellCheckDictionaries,
       base::Bind(&SpellcheckService::OnSpellCheckDictionariesChanged,
                  base::Unretained(this)));
   pref_change_registrar_.Add(
       prefs::kSpellCheckUseSpellingService,
       base::Bind(&SpellcheckService::OnUseSpellingServiceChanged,
                  base::Unretained(this)));
   pref_change_registrar_.Add(
       prefs::kAcceptLanguages,
       base::Bind(&SpellcheckService::OnAcceptLanguagesChanged,
                  base::Unretained(this)));
   pref_change_registrar_.Add(
       prefs::kEnableContinuousSpellcheck,
       base::Bind(&SpellcheckService::InitForAllRenderers,
                  base::Unretained(this)));
 
   custom_dictionary_.reset(new SpellcheckCustomDictionary(context_->GetPath()));
   custom_dictionary_->AddObserver(this);
   custom_dictionary_->Load();
 
   registrar_.Add(this,
                  content::NOTIFICATION_RENDERER_PROCESS_CREATED,
                  content::NotificationService::AllSources());
 
   LoadHunspellDictionaries();
-  UpdateFeedbackSenderState();
 }
 
 SpellcheckService::~SpellcheckService() {
   // Remove pref observers
   pref_change_registrar_.RemoveAll();
 }
 
 base::WeakPtr<SpellcheckService> SpellcheckService::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
@@ skipping 103 matching lines @@
     hunspell_dictionaries_.back()->AddObserver(this);
     hunspell_dictionaries_.back()->Load();
   }
 }
 
 const ScopedVector<SpellcheckHunspellDictionary>&
 SpellcheckService::GetHunspellDictionaries() {
   return hunspell_dictionaries_;
 }
 
-spellcheck::FeedbackSender* SpellcheckService::GetFeedbackSender() {
-  return feedback_sender_.get();
-}
-
 bool SpellcheckService::LoadExternalDictionary(std::string language,
                                                std::string locale,
                                                std::string path,
                                                DictionaryFormat format) {
   return false;
 }
 
 bool SpellcheckService::UnloadExternalDictionary(
     const std::string& /* path */) {
   return false;
@@ skipping 59 matching lines @@
     content::RenderProcessHost* process = i.GetCurrentValue();
     if (process && process->GetHandle())
       InitForRenderer(process);
   }
 }
 
 void SpellcheckService::OnSpellCheckDictionariesChanged() {
   // If there are hunspell dictionaries, then fire off notifications to the
   // renderers after the dictionaries are finished loading.
   LoadHunspellDictionaries();
-  UpdateFeedbackSenderState();
 
   // If there are no hunspell dictionaries to load, then immediately let the
   // renderers know the new state.
   if (hunspell_dictionaries_.empty())
     InitForAllRenderers();
 }
 
 void SpellcheckService::OnUseSpellingServiceChanged() {
   bool enabled = pref_change_registrar_.prefs()->GetBoolean(
       prefs::kSpellCheckUseSpellingService);
   if (metrics_)
     metrics_->RecordSpellingServiceStats(enabled);
-  UpdateFeedbackSenderState();
 }
 
 void SpellcheckService::OnAcceptLanguagesChanged() {
   PrefService* prefs = user_prefs::UserPrefs::Get(context_);
   std::vector<std::string> accept_languages =
       base::SplitString(prefs->GetString(prefs::kAcceptLanguages), ",",
                         base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   std::transform(accept_languages.begin(), accept_languages.end(),
                  accept_languages.begin(),
                  &spellcheck::GetCorrespondingSpellCheckLanguage);
 
   StringListPrefMember dictionaries_pref;
   dictionaries_pref.Init(prefs::kSpellCheckDictionaries, prefs);
   std::vector<std::string> dictionaries = dictionaries_pref.GetValue();
   std::vector<std::string> filtered_dictionaries;
 
   for (const auto& dictionary : dictionaries) {
     if (std::find(accept_languages.begin(), accept_languages.end(),
                   dictionary) != accept_languages.end()) {
       filtered_dictionaries.push_back(dictionary);
     }
   }
 
   dictionaries_pref.SetValue(filtered_dictionaries);
 }
-
-void SpellcheckService::UpdateFeedbackSenderState() {
-  std::string feedback_language;
-  if (!hunspell_dictionaries_.empty())
-    feedback_language = hunspell_dictionaries_.front()->GetLanguage();
-  std::string language_code;
-  std::string country_code;
-  spellcheck::GetISOLanguageCountryCodeFromLocale(
-      feedback_language, &language_code, &country_code);
-  feedback_sender_->OnLanguageCountryChange(language_code, country_code);
-  if (SpellingServiceClient::IsAvailable(
-          context_, SpellingServiceClient::SPELLCHECK)) {
-    feedback_sender_->StartFeedbackCollection();
-  } else {
-    feedback_sender_->StopFeedbackCollection();
-  }
-}