Added translation policy API.

ios/web_view/internal/translate/cwv_translation_controller.mm

Index: ios/web_view/internal/translate/cwv_translation_controller.mm
diff --git a/ios/web_view/internal/translate/cwv_translation_controller.mm b/ios/web_view/internal/translate/cwv_translation_controller.mm
index f38e1ee039feaaa02209a22f33ead50864e00da1..b82ee17c20ed8b5f1ee56f756064627bf652fc54 100644
--- a/ios/web_view/internal/translate/cwv_translation_controller.mm
+++ b/ios/web_view/internal/translate/cwv_translation_controller.mm
@@ -8,12 +8,15 @@
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
+#include "base/strings/sys_string_conversions.h"
+#include "components/translate/core/browser/translate_download_manager.h"
 #include "components/translate/core/browser/translate_manager.h"
-#include "components/translate/core/browser/translate_ui_delegate.h"
 #import "ios/web_view/internal/translate/cwv_language_detection_result_internal.h"
 #import "ios/web_view/internal/translate/cwv_translation_language_internal.h"
 #import "ios/web_view/internal/translate/web_view_translate_client.h"
 #import "ios/web_view/public/cwv_translation_controller_delegate.h"
+#import "ios/web_view/public/cwv_translation_policy.h"
+#include "ui/base/l10n/l10n_util.h"
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
@@ -45,21 +48,22 @@ const NSInteger CWVTranslationErrorScriptLoadError =
 
 @interface CWVTranslationController ()
 
-// Convenience method to generate all supported languages from
-// |translateUIDelegate|.
-- (NSArray<CWVTranslationLanguage*>*)supportedLanguages;
+// A map of CWTranslationLanguages keyed by its language code. Lazily loaded.
+@property(nonatomic, readonly)
+    NSDictionary<NSString*, CWVTranslationLanguage*>* supportedLanguagesByCode;
 
-// Convenience method to get a language at |index| from |translateUIDelegate|.
-- (CWVTranslationLanguage*)languageAtIndex:(size_t)index;
+// Convenience method to get the language with |languageCode|.
+- (CWVTranslationLanguage*)languageWithCode:(const std::string&)languageCode;
 
 @end
 
 @implementation CWVTranslationController {
   ios_web_view::WebViewTranslateClient* _translateClient;
-  std::unique_ptr<translate::TranslateUIDelegate> _translateUIDelegate;
+  std::unique_ptr<translate::TranslatePrefs> _translatePrefs;
 }
 
 @synthesize delegate = _delegate;
+@synthesize supportedLanguagesByCode = _supportedLanguagesByCode;
 @synthesize webState = _webState;
 
 #pragma mark - Internal Methods
@@ -71,6 +75,9 @@ const NSInteger CWVTranslationErrorScriptLoadError =
   _translateClient =
       ios_web_view::WebViewTranslateClient::FromWebState(_webState);
   _translateClient->set_translation_controller(self);
+  _translatePrefs = _translateClient->translate_manager()
+                        ->translate_client()
+                        ->GetTranslatePrefs();
 }
 
 - (void)updateTranslateStep:(translate::TranslateStep)step
@@ -78,14 +85,8 @@ const NSInteger CWVTranslationErrorScriptLoadError =
              targetLanguage:(const std::string&)targetLanguage
                   errorType:(translate::TranslateErrors::Type)errorType
           triggeredFromMenu:(bool)triggeredFromMenu {
-  translate::TranslateManager* manager = _translateClient->translate_manager();
-  _translateUIDelegate = base::MakeUnique<translate::TranslateUIDelegate>(
-      manager->GetWeakPtr(), sourceLanguage, targetLanguage);
-
-  CWVTranslationLanguage* source =
-      [self languageAtIndex:_translateUIDelegate->GetOriginalLanguageIndex()];
-  CWVTranslationLanguage* target =
-      [self languageAtIndex:_translateUIDelegate->GetTargetLanguageIndex()];
+  CWVTranslationLanguage* source = [self languageWithCode:sourceLanguage];
+  CWVTranslationLanguage* target = [self languageWithCode:targetLanguage];
 
   NSError* error;
   if (errorType != translate::TranslateErrors::NONE) {
@@ -96,11 +97,17 @@ const NSInteger CWVTranslationErrorScriptLoadError =
 
   switch (step) {
     case translate::TRANSLATE_STEP_BEFORE_TRANSLATE: {
+      NSArray* supportedLanguages = [self.supportedLanguagesByCode.allValues
+          sortedArrayUsingComparator:^NSComparisonResult(
+              CWVTranslationLanguage* languageA,
+              CWVTranslationLanguage* languageB) {
+            return [languageA.languageName compare:languageB.languageName];
+          }];
       CWVLanguageDetectionResult* languageDetectionResult =
           [[CWVLanguageDetectionResult alloc]
                  initWithPageLanguage:source
               suggestedTargetLanguage:target
-                   supportedLanguages:[self supportedLanguages]];
+                   supportedLanguages:supportedLanguages];
       if ([_delegate respondsToSelector:@selector
                      (translationController:didFinishLanguageDetectionWithResult
                                               :error:)]) {
@@ -140,31 +147,120 @@ const NSInteger CWVTranslationErrorScriptLoadError =
 
 - (void)translatePageFromLanguage:(CWVTranslationLanguage*)sourceLanguage
                        toLanguage:(CWVTranslationLanguage*)targetLanguage {
-  // TODO(706289): Use the passed parameters.
-  _translateUIDelegate->Translate();
+  std::string sourceLanguageCode =
+      base::SysNSStringToUTF8(sourceLanguage.languageCode);
+  std::string targetLanguageCode =
+      base::SysNSStringToUTF8(targetLanguage.languageCode);
+  _translateClient->translate_manager()->TranslatePage(
+      sourceLanguageCode, targetLanguageCode, false);
 }
 
 - (void)revertTranslation {
-  _translateUIDelegate->RevertTranslation();
+  _translateClient->translate_manager()->RevertTranslation();
 }
 
-#pragma mark - Private Methods
+- (void)setTranslationPolicy:(CWVTranslationPolicy*)policy
+             forPageLanguage:(CWVTranslationLanguage*)pageLanguage {
+  std::string languageCode = base::SysNSStringToUTF8(pageLanguage.languageCode);
+  switch (policy.type) {
+    case CWVTranslationPolicyAsk: {
+      _translatePrefs->UnblockLanguage(languageCode);
+      _translatePrefs->RemoveLanguagePairFromWhitelist(languageCode,
+                                                       std::string());
+      break;
+    }
+    case CWVTranslationPolicyNever: {
+      _translatePrefs->BlockLanguage(languageCode);
+      break;
+    }
+    case CWVTranslationPolicyAuto: {
+      _translatePrefs->UnblockLanguage(languageCode);
+      _translatePrefs->WhitelistLanguagePair(
+          languageCode, base::SysNSStringToUTF8(policy.language.languageCode));
+      break;
+    }
+  }
+}
+
+- (CWVTranslationPolicy*)translationPolicyForPageLanguage:
+    (CWVTranslationLanguage*)pageLanguage {
+  std::string languageCode = base::SysNSStringToUTF8(pageLanguage.languageCode);
+  bool isLanguageBlocked = _translatePrefs->IsBlockedLanguage(languageCode);
+  if (isLanguageBlocked) {
+    return [CWVTranslationPolicy translationPolicyNever];
+  }
+
+  std::string autoTargetLanguageCode;
+  if (!_translatePrefs->ShouldAutoTranslate(languageCode,
+                                            &autoTargetLanguageCode)) {
+    return [CWVTranslationPolicy translationPolicyAsk];
+  }
+
+  CWVTranslationLanguage* targetLanguage =
+      [self languageWithCode:autoTargetLanguageCode];
+  return [CWVTranslationPolicy
+      translationPolicyAutoTranslateToLanguage:targetLanguage];
+}
 
-- (NSArray<CWVTranslationLanguage*>*)supportedLanguages {
-  NSMutableArray* supportedLanguages = [NSMutableArray array];
-  for (size_t i = 0; i < _translateUIDelegate->GetNumberOfLanguages(); i++) {
-    CWVTranslationLanguage* language = [self languageAtIndex:i];
-    [supportedLanguages addObject:language];
+- (void)setTranslationPolicy:(CWVTranslationPolicy*)policy
+                 forPageHost:(NSString*)pageHost {
+  DCHECK(pageHost.length);
+  switch (policy.type) {
+    case CWVTranslationPolicyAsk: {
+      _translatePrefs->RemoveSiteFromBlacklist(
+          base::SysNSStringToUTF8(pageHost));
+      break;
+    }
+    case CWVTranslationPolicyNever: {
+      _translatePrefs->BlacklistSite(base::SysNSStringToUTF8(pageHost));
+      break;
+    }
+    case CWVTranslationPolicyAuto: {
+      // TODO(crbug.com/706289): Support auto translation policies for websites.
+      NOTREACHED();
+      break;
+    }
+  }
+}
+
+- (CWVTranslationPolicy*)translationPolicyForPageHost:(NSString*)pageHost {
+  // TODO(crbug.com/706289): Return translationPolicyAuto when implemented.
+  bool isSiteBlackListed =
+      _translatePrefs->IsSiteBlacklisted(base::SysNSStringToUTF8(pageHost));
+  if (isSiteBlackListed) {
+    return [CWVTranslationPolicy translationPolicyNever];
   }
+  return [CWVTranslationPolicy translationPolicyAsk];
+}
+
+#pragma mark - Private Methods
 
-  return [supportedLanguages copy];
+- (NSDictionary<NSString*, CWVTranslationLanguage*>*)supportedLanguagesByCode {
+  if (!_supportedLanguagesByCode) {
+    NSMutableDictionary<NSString*, CWVTranslationLanguage*>*
+        supportedLanguagesByCode = [NSMutableDictionary dictionary];
+    std::vector<std::string> languageCodes;
+    translate::TranslateDownloadManager::GetSupportedLanguages(&languageCodes);
+    std::string locale = translate::TranslateDownloadManager::GetInstance()
+                             ->application_locale();
+    for (const std::string& languageCode : languageCodes) {
+      base::string16 languageName =
+          l10n_util::GetDisplayNameForLocale(languageCode, locale, true);
+      CWVTranslationLanguage* language =
+          [[CWVTranslationLanguage alloc] initWithLanguageCode:languageCode
+                                                  languageName:languageName];
+
+      supportedLanguagesByCode[language.languageCode] = language;
+    }
+
+    _supportedLanguagesByCode = [supportedLanguagesByCode copy];
+  }
+  return _supportedLanguagesByCode;
 }
 
-- (CWVTranslationLanguage*)languageAtIndex:(size_t)index {
-  std::string languageCode = _translateUIDelegate->GetLanguageCodeAt(index);
-  base::string16 languageName = _translateUIDelegate->GetLanguageNameAt(index);
-  return [[CWVTranslationLanguage alloc] initWithLanguageCode:languageCode
-                                                 languageName:languageName];
+- (CWVTranslationLanguage*)languageWithCode:(const std::string&)languageCode {
+  NSString* languageCodeString = base::SysUTF8ToNSString(languageCode);
+  return self.supportedLanguagesByCode[languageCodeString];
 }
 
 @end