LanguageState should be owned by TranslateManager

components/translate/core/browser/translate_ui_delegate.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/translate/core/browser/translate_ui_delegate.h"
 
 #include "base/i18n/string_compare.h"
 #include "base/metrics/histogram.h"
 #include "components/translate/core/browser/language_state.h"
 #include "components/translate/core/browser/translate_client.h"
@@ skipping 13 matching lines @@
 const char kNeverTranslateLang[] = "Translate.NeverTranslateLang";
 const char kNeverTranslateSite[] = "Translate.NeverTranslateSite";
 const char kAlwaysTranslateLang[] = "Translate.AlwaysTranslateLang";
 const char kModifyOriginalLang[] = "Translate.ModifyOriginalLang";
 const char kModifyTargetLang[] = "Translate.ModifyTargetLang";
 const char kDeclineTranslateDismissUI[] = "Translate.DeclineTranslateDismissUI";
 const char kShowErrorUI[] = "Translate.ShowErrorUI";
 
 }  // namespace
 
-TranslateUIDelegate::TranslateUIDelegate(TranslateClient* translate_client,
-                                         TranslateManager* translate_manager,
-                                         const std::string& original_language,
-                                         const std::string& target_language)
-    : translate_client_(translate_client),
-      translate_driver_(translate_client->GetTranslateDriver()),
+TranslateUIDelegate::TranslateUIDelegate(
+    const base::WeakPtr<TranslateManager>& translate_manager,
+    const std::string& original_language,
+    const std::string& target_language)
+    : translate_driver_(
+          translate_manager->translate_client()->GetTranslateDriver()),
       translate_manager_(translate_manager),
       original_language_index_(NO_INDEX),
       initial_original_language_index_(NO_INDEX),
       target_language_index_(NO_INDEX) {
-  DCHECK(translate_client_);
   DCHECK(translate_driver_);
   DCHECK(translate_manager_);
 
   std::vector<std::string> language_codes;
   TranslateDownloadManager::GetSupportedLanguages(&language_codes);
 
   // Preparing for the alphabetical order in the locale.
   UErrorCode error = U_ZERO_ERROR;
   std::string locale =
       TranslateDownloadManager::GetInstance()->application_locale();
@@ skipping 24 matching lines @@
        ++iter) {
     std::string language_code = iter->first;
     if (language_code == original_language) {
       original_language_index_ = iter - languages_.begin();
       initial_original_language_index_ = original_language_index_;
     }
     if (language_code == target_language)
       target_language_index_ = iter - languages_.begin();
   }
 
-  prefs_ = translate_client_->GetTranslatePrefs();
+  prefs_ = translate_manager_->translate_client()->GetTranslatePrefs();
 }
 
 TranslateUIDelegate::~TranslateUIDelegate() {}
 
 void TranslateUIDelegate::OnErrorShown(TranslateErrors::Type error_type) {
   DCHECK_LE(TranslateErrors::NONE, error_type);
   DCHECK_LT(error_type, TranslateErrors::TRANSLATE_ERROR_MAX);
 
   if (error_type == TranslateErrors::NONE)
     return;
 
   UMA_HISTOGRAM_ENUMERATION(
       kShowErrorUI, error_type, TranslateErrors::TRANSLATE_ERROR_MAX);
 }
 
 const LanguageState& TranslateUIDelegate::GetLanguageState() {
-  return translate_driver_->GetLanguageState();
+  return translate_manager_->GetLanguageState();
 }
 
 size_t TranslateUIDelegate::GetNumberOfLanguages() const {
   return languages_.size();
 }
 
 size_t TranslateUIDelegate::GetOriginalLanguageIndex() const {
   return original_language_index_;
 }
 
@@ skipping 38 matching lines @@
 
 std::string TranslateUIDelegate::GetTargetLanguageCode() const {
   return GetLanguageCodeAt(GetTargetLanguageIndex());
 }
 
 void TranslateUIDelegate::Translate() {
   if (!translate_driver_->IsOffTheRecord()) {
     prefs_->ResetTranslationDeniedCount(GetOriginalLanguageCode());
     prefs_->IncrementTranslationAcceptedCount(GetOriginalLanguageCode());
   }
-  translate_manager_->TranslatePage(
-      GetOriginalLanguageCode(), GetTargetLanguageCode(), false);
 
-  UMA_HISTOGRAM_BOOLEAN(kPerformTranslate, true);
+  if (translate_manager_) {
+    translate_manager_->TranslatePage(
+        GetOriginalLanguageCode(), GetTargetLanguageCode(), false);
+    UMA_HISTOGRAM_BOOLEAN(kPerformTranslate, true);
+  }
 }
 
 void TranslateUIDelegate::RevertTranslation() {
-  translate_manager_->RevertTranslation();
-
-  UMA_HISTOGRAM_BOOLEAN(kRevertTranslation, true);
+  if (translate_manager_) {
+    translate_manager_->RevertTranslation();
+    UMA_HISTOGRAM_BOOLEAN(kRevertTranslation, true);
+  }
 }
 
 void TranslateUIDelegate::TranslationDeclined(bool explicitly_closed) {
   if (!translate_driver_->IsOffTheRecord()) {
     prefs_->ResetTranslationAcceptedCount(GetOriginalLanguageCode());
     prefs_->IncrementTranslationDeniedCount(GetOriginalLanguageCode());
   }
 
   // Remember that the user declined the translation so as to prevent showing a
   // translate infobar for that page again.  (TranslateManager initiates
   // translations when getting a LANGUAGE_DETERMINED from the page, which
   // happens when a load stops. That could happen multiple times, including
   // after the user already declined the translation.)
-  translate_driver_->GetLanguageState().set_translation_declined(true);
-
-  UMA_HISTOGRAM_BOOLEAN(kDeclineTranslate, true);
+  if (translate_manager_) {
+    translate_manager_->GetLanguageState().set_translation_declined(true);
+    UMA_HISTOGRAM_BOOLEAN(kDeclineTranslate, true);
+  }
 
   if (!explicitly_closed)
     UMA_HISTOGRAM_BOOLEAN(kDeclineTranslateDismissUI, true);
 }
 
 bool TranslateUIDelegate::IsLanguageBlocked() {
   return prefs_->IsBlockedLanguage(GetOriginalLanguageCode());
 }
 
 void TranslateUIDelegate::SetLanguageBlocked(bool value) {
   if (value) {
     prefs_->BlockLanguage(GetOriginalLanguageCode());
-    translate_driver_->GetLanguageState().SetTranslateEnabled(false);
+    if (translate_manager_) {
+      translate_manager_->GetLanguageState().SetTranslateEnabled(false);
+    }
   } else {
     prefs_->UnblockLanguage(GetOriginalLanguageCode());
   }
 
   UMA_HISTOGRAM_BOOLEAN(kNeverTranslateLang, true);
 }
 
 bool TranslateUIDelegate::IsSiteBlacklisted() {
   std::string host = GetPageHost();
   return !host.empty() && prefs_->IsSiteBlacklisted(host);
 }
 
 void TranslateUIDelegate::SetSiteBlacklist(bool value) {
   std::string host = GetPageHost();
   if (host.empty())
     return;
 
   if (value) {
     prefs_->BlacklistSite(host);
-    translate_driver_->GetLanguageState().SetTranslateEnabled(false);
+    if (translate_manager_) {
+      translate_manager_->GetLanguageState().SetTranslateEnabled(false);
+    }
   } else {
     prefs_->RemoveSiteFromBlacklist(host);
   }
 
   UMA_HISTOGRAM_BOOLEAN(kNeverTranslateSite, true);
 }
 
 bool TranslateUIDelegate::ShouldAlwaysTranslate() {
   return prefs_->IsLanguagePairWhitelisted(GetOriginalLanguageCode(),
                                            GetTargetLanguageCode());
 }
 
 void TranslateUIDelegate::SetAlwaysTranslate(bool value) {
   const std::string& original_lang = GetOriginalLanguageCode();
   const std::string& target_lang = GetTargetLanguageCode();
   if (value)
     prefs_->WhitelistLanguagePair(original_lang, target_lang);
   else
     prefs_->RemoveLanguagePairFromWhitelist(original_lang, target_lang);
 
   UMA_HISTOGRAM_BOOLEAN(kAlwaysTranslateLang, true);
 }
 
 std::string TranslateUIDelegate::GetPageHost() {
   if (!translate_driver_->HasCurrentPage())
     return std::string();
   return translate_driver_->GetActiveURL().HostNoBrackets();
 }