Translate: Changed the rule to determine which language should be translated

Along with changing the UI, the flow sholud be changed.  Currently, a page in an Accept language is not translated.  After the new UI, a page in an Accept language MAY be translated.

Current:
  1) If a language is listed in Accept languages, the page should not be translated.
  2) If a language is blacklisted by prefs, the page should not be translated.
  3) Otherwise, the page may be translated.

After this CL (with switches::kEnableTranslateSettings):
  1) If a language is blacklisted by prefs, and if 1.1) or 1.2), the page should not be translated.
    1.1) the language is listed in Accept languages
    1.2) the language cannot be Accept languages
  2) Otherwise, the page may be translated.

Design Doc: https://docs.google.com/a/google.com/document/d/1mxM00l1h2e59HKPVZR_1DY07jeCg4RwHWu7JDvmWx3w/edit

BUG=243235
TBR=hajimehoshi@chromium.org

Review URL: https://chromiumcodereview.appspot.com/16530004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@206697 0039d316-1c4b-4281-b951-d872f2087c98

12 files changed, 157 insertions, 32 deletions

diff --git a/chrome/browser/translate/options_menu_model.cc b/chrome/browser/translate/options_menu_model.cc
index 015a13c..0abea91 100644
--- a/chrome/browser/translate/options_menu_model.cc
+++ b/chrome/browser/translate/options_menu_model.cc
@@ -68,7 +68,7 @@ OptionsMenuModel::~OptionsMenuModel() {
 bool OptionsMenuModel::IsCommandIdChecked(int command_id) const {
   switch (command_id) {
     case IDC_TRANSLATE_OPTIONS_NEVER_TRANSLATE_LANG:
-      return translate_infobar_delegate_->IsLanguageBlacklisted();
+      return !translate_infobar_delegate_->IsTranslatableLanguageByPrefs();
 
     case IDC_TRANSLATE_OPTIONS_NEVER_TRANSLATE_SITE:
       return translate_infobar_delegate_->IsSiteBlacklisted();
@@ -90,7 +90,7 @@ bool OptionsMenuModel::IsCommandIdEnabled(int command_id) const {
       return !translate_infobar_delegate_->ShouldAlwaysTranslate();
 
     case IDC_TRANSLATE_OPTIONS_ALWAYS :
-      return (!translate_infobar_delegate_->IsLanguageBlacklisted() &&
+      return (translate_infobar_delegate_->IsTranslatableLanguageByPrefs() &&
           !translate_infobar_delegate_->IsSiteBlacklisted());
 
     default:
@@ -108,7 +108,7 @@ void OptionsMenuModel::ExecuteCommand(int command_id, int event_flags) {
   switch (command_id) {
     case IDC_TRANSLATE_OPTIONS_NEVER_TRANSLATE_LANG:
       UMA_HISTOGRAM_BOOLEAN("Translate.NeverTranslateLang", true);
-      translate_infobar_delegate_->ToggleLanguageBlacklist();
+      translate_infobar_delegate_->ToggleTranslatableLanguageByPrefs();
       break;
 
     case IDC_TRANSLATE_OPTIONS_NEVER_TRANSLATE_SITE:
diff --git a/chrome/browser/translate/translate_accept_languages.cc b/chrome/browser/translate/translate_accept_languages.cc
index 4e910ba..6de5225 100644
--- a/chrome/browser/translate/translate_accept_languages.cc
+++ b/chrome/browser/translate/translate_accept_languages.cc
@@ -17,6 +17,7 @@
 #include "chrome/common/translate/translate_util.h"
 #include "content/public/browser/notification_source.h"
 #include "net/url_request/url_fetcher.h"
+#include "ui/base/l10n/l10n_util.h"
 
 TranslateAcceptLanguages::TranslateAcceptLanguages() {
 }
@@ -24,6 +25,25 @@ TranslateAcceptLanguages::TranslateAcceptLanguages() {
 TranslateAcceptLanguages::~TranslateAcceptLanguages() {
 }
 
+// static
+bool TranslateAcceptLanguages::CanBeAcceptLanguage(
+    const std::string& language) {
+  std::string accept_language = language;
+  TranslateUtil::ToChromeLanguageSynonym(&accept_language);
+
+  const std::string locale = g_browser_process->GetApplicationLocale();
+  std::vector<std::string> accept_language_codes;
+  l10n_util::GetAcceptLanguagesForLocale(locale, &accept_language_codes);
+
+  if (std::find(accept_language_codes.begin(),
+                accept_language_codes.end(),
+                accept_language) != accept_language_codes.end()) {
+    return true;
+  }
+
+  return false;
+}
+
 bool TranslateAcceptLanguages::IsAcceptLanguage(Profile* profile,
                                                 const std::string& language) {
   DCHECK(profile);
diff --git a/chrome/browser/translate/translate_accept_languages.h b/chrome/browser/translate/translate_accept_languages.h
index f536150..53af9ba 100644
--- a/chrome/browser/translate/translate_accept_languages.h
+++ b/chrome/browser/translate/translate_accept_languages.h
@@ -22,20 +22,24 @@ class TranslateAcceptLanguages : public content::NotificationObserver {
   TranslateAcceptLanguages();
   virtual ~TranslateAcceptLanguages();
 
+  // Returns true if |language| is available as Accept-Languages. |language|
+  // will be cnverted if it has the synonym of accept language.
+  static bool CanBeAcceptLanguage(const std::string& language);
+
   // Returns true if the passed language has been configured by the user as an
   // accept language. |language| will be converted if it has the synonym of
   // accept languages.
   bool IsAcceptLanguage(Profile* profile,
                         const std::string& language);
 
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TranslateAcceptLanguages);
+
   // content::NotificationObserver implementation:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
- private:
-  DISALLOW_COPY_AND_ASSIGN(TranslateAcceptLanguages);
-
   // Initializes the |accept_languages_| language table based on the associated
   // preference in |prefs|.
   void InitAcceptLanguages(PrefService* prefs);
diff --git a/chrome/browser/translate/translate_infobar_delegate.cc b/chrome/browser/translate/translate_infobar_delegate.cc
index 3569ebe..ca9df4c 100644
--- a/chrome/browser/translate/translate_infobar_delegate.cc
+++ b/chrome/browser/translate/translate_infobar_delegate.cc
@@ -8,9 +8,11 @@
 
 #include "base/i18n/string_compare.h"
 #include "base/metrics/histogram.h"
+#include "base/prefs/pref_service.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/translate/translate_accept_languages.h"
 #include "chrome/browser/translate/translate_manager.h"
 #include "chrome/browser/translate/translate_tab_helper.h"
 #include "content/public/browser/navigation_details.h"
@@ -132,11 +134,15 @@ bool TranslateInfoBarDelegate::InTranslateNavigation() {
   return translate_tab_helper->language_state().InTranslateNavigation();
 }
 
-bool TranslateInfoBarDelegate::IsLanguageBlacklisted() {
-  return prefs_.IsLanguageBlacklisted(original_language_code());
+bool TranslateInfoBarDelegate::IsTranslatableLanguageByPrefs() {
+  Profile* profile =
+      Profile::FromBrowserContext(web_contents()->GetBrowserContext());
+  Profile* original_profile = profile->GetOriginalProfile();
+  return TranslatePrefs::CanTranslateLanguage(original_profile,
+                                              original_language_code());
 }
 
-void TranslateInfoBarDelegate::ToggleLanguageBlacklist() {
+void TranslateInfoBarDelegate::ToggleTranslatableLanguageByPrefs() {
   const std::string& original_lang = original_language_code();
   if (prefs_.IsLanguageBlacklisted(original_lang)) {
     prefs_.RemoveLanguageFromBlacklist(original_lang);
diff --git a/chrome/browser/translate/translate_infobar_delegate.h b/chrome/browser/translate/translate_infobar_delegate.h
index 7f8d251..257a32d 100644
--- a/chrome/browser/translate/translate_infobar_delegate.h
+++ b/chrome/browser/translate/translate_infobar_delegate.h
@@ -129,8 +129,8 @@ class TranslateInfoBarDelegate : public InfoBarDelegate {
   virtual void TranslationDeclined();
 
   // Methods called by the Options menu delegate.
-  virtual bool IsLanguageBlacklisted();
-  virtual void ToggleLanguageBlacklist();
+  virtual bool IsTranslatableLanguageByPrefs();
+  virtual void ToggleTranslatableLanguageByPrefs();
   virtual bool IsSiteBlacklisted();
   virtual void ToggleSiteBlacklist();
   virtual bool ShouldAlwaysTranslate();
diff --git a/chrome/browser/translate/translate_manager.cc b/chrome/browser/translate/translate_manager.cc
index 70f51a2..8a2d93a 100644
--- a/chrome/browser/translate/translate_manager.cc
+++ b/chrome/browser/translate/translate_manager.cc
@@ -176,6 +176,17 @@ bool TranslateManager::IsAlphaLanguage(const std::string& language) {
   return false;
 }
 
+// static
+bool TranslateManager::IsAcceptLanguage(Profile* profile,
+                                        const std::string& language) {
+  if (GetInstance()->accept_languages_.get()) {
+    return GetInstance()->accept_languages_->IsAcceptLanguage(
+        profile, language);
+  }
+  NOTREACHED();
+  return false;
+}
+
 void TranslateManager::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
@@ -436,8 +447,14 @@ void TranslateManager::InitiateTranslation(WebContents* web_contents,
     return;
   }
 
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+
   // Don't translate any language the user configured as accepted languages.
-  if (accept_languages_->IsAcceptLanguage(original_profile, language_code)) {
+  // When the flag --enable-translate-settings is on, the condition is
+  // different. In this case, even though a language is an Accept language,
+  // it could be translated due to the blacklist.
+  if (!command_line->HasSwitch(switches::kEnableTranslateSettings) &&
+      accept_languages_->IsAcceptLanguage(original_profile, language_code)) {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_ACCEPT_LANGUAGES);
     return;
@@ -453,9 +470,17 @@ void TranslateManager::InitiateTranslation(WebContents* web_contents,
     return;
   }
 
-  // Don't translate any user black-listed URLs or user selected language
-  // combination.
-  if (!TranslatePrefs::CanTranslate(prefs, language_code, page_url)) {
+  TranslatePrefs translate_prefs(prefs);
+
+  // Don't translate any user black-listed languages.
+  if (!TranslatePrefs::CanTranslateLanguage(profile, language_code)) {
+    TranslateBrowserMetrics::ReportInitiationStatus(
+        TranslateBrowserMetrics::INITIATION_STATUS_DISABLED_BY_CONFIG);
+    return;
+  }
+
+  // Don't translate any user black-listed URLs.
+  if (translate_prefs.IsSiteBlacklisted(page_url.HostNoBrackets())) {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_DISABLED_BY_CONFIG);
     return;
diff --git a/chrome/browser/translate/translate_manager.h b/chrome/browser/translate/translate_manager.h
index d5feea6..b00f444 100644
--- a/chrome/browser/translate/translate_manager.h
+++ b/chrome/browser/translate/translate_manager.h
@@ -24,6 +24,7 @@ class GURL;
 struct LanguageDetectionDetails;
 struct PageTranslatedDetails;
 class PrefService;
+class Profile;
 struct ShortcutConfiguration;
 class TranslateAcceptLanguages;
 struct TranslateErrorDetails;
@@ -74,6 +75,9 @@ class TranslateManager : public content::NotificationObserver,
   // alpha language.
   static bool IsAlphaLanguage(const std::string& language);
 
+  // Returns true if |language| is an Accept language for the user profile.
+  static bool IsAcceptLanguage(Profile* profile, const std::string& language);
+
   // Let the caller decide if and when we should fetch the language list from
   // the translate server. This is a NOOP if switches::kDisableTranslate is set
   // or if prefs::kEnableTranslate is set to false.
diff --git a/chrome/browser/translate/translate_manager_browsertest.cc b/chrome/browser/translate/translate_manager_browsertest.cc
index 0f22748..5de2bb8 100644
--- a/chrome/browser/translate/translate_manager_browsertest.cc
+++ b/chrome/browser/translate/translate_manager_browsertest.cc
@@ -1090,11 +1090,12 @@ TEST_F(TranslateManagerBrowserTest, NeverTranslateLanguagePref) {
                 pref_callback_);
   TranslatePrefs translate_prefs(prefs);
   EXPECT_FALSE(translate_prefs.IsLanguageBlacklisted("fr"));
-  EXPECT_TRUE(translate_prefs.CanTranslate(prefs, "fr", url));
+  EXPECT_TRUE(translate_prefs.CanTranslateLanguage(profile, "fr"));
   SetPrefObserverExpectation(TranslatePrefs::kPrefTranslateLanguageBlacklist);
   translate_prefs.BlacklistLanguage("fr");
   EXPECT_TRUE(translate_prefs.IsLanguageBlacklisted("fr"));
-  EXPECT_FALSE(translate_prefs.CanTranslate(prefs, "fr", url));
+  EXPECT_FALSE(translate_prefs.IsSiteBlacklisted(url.host()));
+  EXPECT_FALSE(translate_prefs.CanTranslateLanguage(profile, "fr"));
 
   // Close the infobar.
   EXPECT_TRUE(CloseTranslateInfoBar());
@@ -1109,7 +1110,8 @@ TEST_F(TranslateManagerBrowserTest, NeverTranslateLanguagePref) {
   SetPrefObserverExpectation(TranslatePrefs::kPrefTranslateLanguageBlacklist);
   translate_prefs.RemoveLanguageFromBlacklist("fr");
   EXPECT_FALSE(translate_prefs.IsLanguageBlacklisted("fr"));
-  EXPECT_TRUE(translate_prefs.CanTranslate(prefs, "fr", url));
+  EXPECT_FALSE(translate_prefs.IsSiteBlacklisted(url.host()));
+  EXPECT_TRUE(translate_prefs.CanTranslateLanguage(profile, "fr"));
 
   // Navigate to a page in French.
   SimulateNavigation(url, "fr", true);
@@ -1137,11 +1139,11 @@ TEST_F(TranslateManagerBrowserTest, NeverTranslateSitePref) {
   registrar.Add(TranslatePrefs::kPrefTranslateSiteBlacklist, pref_callback_);
   TranslatePrefs translate_prefs(prefs);
   EXPECT_FALSE(translate_prefs.IsSiteBlacklisted(host));
-  EXPECT_TRUE(translate_prefs.CanTranslate(prefs, "fr", url));
+  EXPECT_TRUE(translate_prefs.CanTranslateLanguage(profile, "fr"));
   SetPrefObserverExpectation(TranslatePrefs::kPrefTranslateSiteBlacklist);
   translate_prefs.BlacklistSite(host);
   EXPECT_TRUE(translate_prefs.IsSiteBlacklisted(host));
-  EXPECT_FALSE(translate_prefs.CanTranslate(prefs, "fr", url));
+  EXPECT_TRUE(translate_prefs.CanTranslateLanguage(profile, "fr"));
 
   // Close the infobar.
   EXPECT_TRUE(CloseTranslateInfoBar());
@@ -1156,7 +1158,7 @@ TEST_F(TranslateManagerBrowserTest, NeverTranslateSitePref) {
   SetPrefObserverExpectation(TranslatePrefs::kPrefTranslateSiteBlacklist);
   translate_prefs.RemoveSiteFromBlacklist(host);
   EXPECT_FALSE(translate_prefs.IsSiteBlacklisted(host));
-  EXPECT_TRUE(translate_prefs.CanTranslate(prefs, "fr", url));
+  EXPECT_TRUE(translate_prefs.CanTranslateLanguage(profile, "fr"));
 
   // Navigate to a page in French.
   SimulateNavigation(url, "fr", true);
diff --git a/chrome/browser/translate/translate_prefs.cc b/chrome/browser/translate/translate_prefs.cc
index ad71653..ccb2790 100644
--- a/chrome/browser/translate/translate_prefs.cc
+++ b/chrome/browser/translate/translate_prefs.cc
@@ -4,9 +4,17 @@
 
 #include "chrome/browser/translate/translate_prefs.h"
 
+#include "base/command_line.h"
 #include "base/prefs/pref_service.h"
+#include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/translate/translate_accept_languages.h"
+#include "chrome/browser/translate/translate_manager.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/common/translate/translate_util.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 
 const char TranslatePrefs::kPrefTranslateLanguageBlacklist[] =
@@ -20,6 +28,30 @@ const char TranslatePrefs::kPrefTranslateDeniedCount[] =
 const char TranslatePrefs::kPrefTranslateAcceptedCount[] =
     "translate_accepted_count";
 
+namespace {
+
+void AppendLanguageToAcceptLanguages(PrefService* prefs,
+                                     const std::string& language) {
+  if (!TranslateAcceptLanguages::CanBeAcceptLanguage(language))
+    return;
+
+  std::string accept_language = language;
+  TranslateUtil::ToChromeLanguageSynonym(&accept_language);
+
+  std::string accept_languages_str = prefs->GetString(prefs::kAcceptLanguages);
+  std::vector<std::string> accept_languages;
+  base::SplitString(accept_languages_str, ',', &accept_languages);
+  if (std::find(accept_languages.begin(),
+                accept_languages.end(),
+                accept_language) == accept_languages.end()) {
+    accept_languages.push_back(accept_language);
+  }
+  accept_languages_str = JoinString(accept_languages, ',');
+  prefs->SetString(prefs::kAcceptLanguages, accept_languages_str);
+}
+
+}  // namespace
+
 // TranslatePrefs: public: -----------------------------------------------------
 
 TranslatePrefs::TranslatePrefs(PrefService* user_prefs)
@@ -33,6 +65,9 @@ bool TranslatePrefs::IsLanguageBlacklisted(
 
 void TranslatePrefs::BlacklistLanguage(const std::string& original_language) {
   BlacklistValue(kPrefTranslateLanguageBlacklist, original_language);
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kEnableTranslateSettings))
+    AppendLanguageToAcceptLanguages(prefs_, original_language);
 }
 
 void TranslatePrefs::RemoveLanguageFromBlacklist(
@@ -160,20 +195,45 @@ void TranslatePrefs::ResetTranslationAcceptedCount(
 
 // TranslatePrefs: public, static: ---------------------------------------------
 
-bool TranslatePrefs::CanTranslate(PrefService* user_prefs,
-    const std::string& original_language, const GURL& url) {
-  TranslatePrefs prefs(user_prefs);
-  if (prefs.IsSiteBlacklisted(url.HostNoBrackets()))
-    return false;
-  return (!prefs.IsLanguageBlacklisted(original_language));
+// static
+bool TranslatePrefs::CanTranslateLanguage(Profile* profile,
+                                          const std::string& language) {
+  TranslatePrefs translate_prefs(profile->GetPrefs());
+  bool blacklisted = translate_prefs.IsLanguageBlacklisted(language);
+
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kEnableTranslateSettings)) {
+    bool is_accept_language =
+        TranslateManager::IsAcceptLanguage(profile, language);
+    bool can_be_accept_language =
+        TranslateAcceptLanguages::CanBeAcceptLanguage(language);
+
+    // Don't translate any user black-listed languages. Checking
+    // |is_accept_language| is necessary because if the user eliminates the
+    // language from the preference, it is natural to forget whether or not
+    // the language should be translated. Checking |cannot_be_accept_language|
+    // is also necessary because some minor languages can't be selected in the
+    // language preference even though the language is available in Translate
+    // server.
+    if (blacklisted && (is_accept_language || !can_be_accept_language))
+      return false;
+  } else {
+    // Don't translate any user user selected language.
+    if (blacklisted)
+      return false;
+  }
+
+  return true;
 }
 
+// static
 bool TranslatePrefs::ShouldAutoTranslate(PrefService* user_prefs,
     const std::string& original_language, std::string* target_language) {
   TranslatePrefs prefs(user_prefs);
   return prefs.IsLanguageWhitelisted(original_language, target_language);
 }
 
+// static
 void TranslatePrefs::RegisterUserPrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterListPref(kPrefTranslateLanguageBlacklist,
@@ -191,6 +251,7 @@ void TranslatePrefs::RegisterUserPrefs(
       user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
 }
 
+// static
 void TranslatePrefs::MigrateUserPrefs(PrefService* user_prefs) {
   // Old format of kPrefTranslateWhitelists
   // - original language -> list of target langs to auto-translate
diff --git a/chrome/browser/translate/translate_prefs.h b/chrome/browser/translate/translate_prefs.h
index 214fe6d..d049b05 100644
--- a/chrome/browser/translate/translate_prefs.h
+++ b/chrome/browser/translate/translate_prefs.h
@@ -10,6 +10,7 @@
 #include "googleurl/src/gurl.h"
 
 class PrefService;
+class Profile;
 
 namespace base {
 class DictionaryValue;
@@ -70,8 +71,8 @@ class TranslatePrefs {
   void IncrementTranslationAcceptedCount(const std::string& language);
   void ResetTranslationAcceptedCount(const std::string& language);
 
-  static bool CanTranslate(PrefService* user_prefs,
-      const std::string& original_language, const GURL& url);
+  static bool CanTranslateLanguage(
+      Profile* profile, const std::string& language);
   static bool ShouldAutoTranslate(PrefService* user_prefs,
       const std::string& original_language, std::string* target_language);
   static void RegisterUserPrefs(user_prefs::PrefRegistrySyncable* registry);
diff --git a/chrome/browser/ui/cocoa/infobars/translate_infobar_unittest.mm b/chrome/browser/ui/cocoa/infobars/translate_infobar_unittest.mm
index 2930183..fbbf9f3 100644
--- a/chrome/browser/ui/cocoa/infobars/translate_infobar_unittest.mm
+++ b/chrome/browser/ui/cocoa/infobars/translate_infobar_unittest.mm
@@ -48,8 +48,8 @@ class MockTranslateInfoBarDelegate : public TranslateInfoBarDelegate {
 
   MOCK_METHOD0(TranslationDeclined, void());
 
-  virtual bool IsLanguageBlacklisted() OVERRIDE { return false; }
-  MOCK_METHOD0(ToggleLanguageBlacklist, void());
+  virtual bool IsTranslatableLanguageByPrefs() OVERRIDE { return true; }
+  MOCK_METHOD0(ToggleTranslatableLanguageByPrefs, void());
   virtual bool IsSiteBlacklisted() OVERRIDE { return false; }
   MOCK_METHOD0(ToggleSiteBlacklist, void());
   virtual bool ShouldAlwaysTranslate() OVERRIDE { return false; }
@@ -172,7 +172,7 @@ TEST_F(TranslationInfoBarTest, OptionsMenuItemsHookedUp) {
   }
 
   {
-    EXPECT_CALL(*infobar_delegate_, ToggleLanguageBlacklist())
+    EXPECT_CALL(*infobar_delegate_, ToggleTranslatableLanguageByPrefs())
     .Times(1);
     [infobar_controller_ optionsMenuChanged:neverTranslateLanguateItem];
   }
diff --git a/chrome/common/translate/translate_util.cc b/chrome/common/translate/translate_util.cc
index c607f3b..994e7ea 100644
--- a/chrome/common/translate/translate_util.cc
+++ b/chrome/common/translate/translate_util.cc
@@ -18,6 +18,8 @@ struct LanguageCodeSynonym {
   const char* const chrome_language;
 };
 
+// If this table is updated, please sync this with that in
+// chrome/browser/resources/options/language_options.js
 const LanguageCodeSynonym kLanguageCodeSynonyms[] = {
   {"no", "nb"},
   {"iw", "he"},