Added translation policy API.

ios/web_view/internal/translate/cwv_translation_controller.mm

 // Copyright 2017 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.
 
 #import "ios/web_view/internal/translate/cwv_translation_controller_internal.h"
 
 #include <string>
 
 #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."
 #endif
 
 NSErrorDomain const CWVTranslationErrorDomain =
     @"org.chromium.chromewebview.TranslationErrorDomain";
 
 const NSInteger CWVTranslationErrorNetwork =
     translate::TranslateErrors::NETWORK;
@@ skipping 11 matching lines @@
     translate::TranslateErrors::TRANSLATION_TIMEOUT;
 const NSInteger CWVTranslationErrorUnexpectedScriptError =
     translate::TranslateErrors::UNEXPECTED_SCRIPT_ERROR;
 const NSInteger CWVTranslationErrorBadOrigin =
     translate::TranslateErrors::BAD_ORIGIN;
 const NSInteger CWVTranslationErrorScriptLoadError =
     translate::TranslateErrors::SCRIPT_LOAD_ERROR;
 
 @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
 
 - (void)setWebState:(web::WebState*)webState {
   _webState = webState;
 
   ios_web_view::WebViewTranslateClient::CreateForWebState(_webState);
   _translateClient =
       ios_web_view::WebViewTranslateClient::FromWebState(_webState);
   _translateClient->set_translation_controller(self);
+  _translatePrefs = _translateClient->translate_manager()
+                        ->translate_client()
+                        ->GetTranslatePrefs();
 }
 
 - (void)updateTranslateStep:(translate::TranslateStep)step
              sourceLanguage:(const std::string&)sourceLanguage
              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) {
     error = [NSError errorWithDomain:CWVTranslationErrorDomain
                                 code:errorType
                             userInfo:nil];
   }
 
   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:)]) {
         [_delegate translationController:self
             didFinishLanguageDetectionWithResult:languageDetectionResult
                                            error:error];
       }
       break;
     }
     case translate::TRANSLATE_STEP_TRANSLATING:
@@ skipping 19 matching lines @@
       break;
     case translate::TRANSLATE_STEP_TRANSLATE_ERROR:
       break;
   }
 }
 
 #pragma mark - Public Methods
 
 - (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();
+}
+
+- (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];
+}
+
+- (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
 
-- (NSArray<CWVTranslationLanguage*>*)supportedLanguages {
-  NSMutableArray* supportedLanguages = [NSMutableArray array];
-  for (size_t i = 0; i < _translateUIDelegate->GetNumberOfLanguages(); i++) {
-    CWVTranslationLanguage* language = [self languageAtIndex:i];
-    [supportedLanguages addObject:language];
+- (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 [supportedLanguages 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