chrome/common/extensions/extension_l10n_util_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/file_path.h"
   6 #include "base/file_util.h"
   7 #include "base/memory/linked_ptr.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/path_service.h"
  10 #include "base/scoped_temp_dir.h"
  11 #include "base/values.h"
  12 #include "chrome/common/chrome_paths.h"
  13 #include "chrome/common/extensions/extension.h"
  14 #include "chrome/common/extensions/extension_manifest_constants.h"
  15 #include "chrome/common/extensions/extension_l10n_util.h"
  16 #include "chrome/common/extensions/message_bundle.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18 #include "ui/base/l10n/l10n_util.h"
  19
  20 using extensions::Extension;
  21 using extensions::ExtensionInfo;
  22 using extensions::MessageBundle;
  23
  24 namespace errors = extension_manifest_errors;
  25 namespace keys = extension_manifest_keys;
  26
  27 namespace {
  28
  29 // crbug.com/108429: Crashing on Windows Vista bots.
  30 #if defined(OS_WIN)
  31 #define GetValidLocalesEmptyLocaleFolder \
  32   DISABLED_GetValidLocalesEmptyLocaleFolder
  33 #define GetValidLocalesWithValidLocaleNoMessagesFile \
  34   DISABLED_GetValidLocalesWithValidLocaleNoMessagesFile
  35 #define GetValidLocalesWithUnsupportedLocale \
  36   DISABLED_GetValidLocalesWithUnsupportedLocale
  37 #define GetValidLocalesWithValidLocalesAndMessagesFile \
  38   DISABLED_GetValidLocalesWithValidLocalesAndMessagesFile
  39 #define LoadMessageCatalogsValidFallback \
  40   DISABLED_LoadMessageCatalogsValidFallback
  41 #define LoadMessageCatalogsMissingFiles DISABLED_LoadMessageCatalogsMissingFiles
  42 #define LoadMessageCatalogsBadJSONFormat \
  43   DISABLED_LoadMessageCatalogsBadJSONFormat
  44 #define LoadMessageCatalogsDuplicateKeys \
  45   DISABLED_LoadMessageCatalogsDuplicateKeys
  46 #define LocalizeEmptyManifest DISABLED_LocalizeEmptyManifest
  47 #define LocalizeManifestWithoutNameMsgAndEmptyDescription \
  48   DISABLED_LocalizeManifestWithoutNameMsgAndEmptyDescription
  49 #define LocalizeManifestWithNameMsgAndEmptyDescription \
  50   DISABLED_LocalizeManifestWithNameMsgAndEmptyDescription
  51 #define LocalizeManifestWithBadNameMsg DISABLED_LocalizeManifestWithBadNameMsg
  52 #define LocalizeManifestWithNameDescriptionDefaultTitleMsgs \
  53   DISABLED_LocalizeManifestWithNameDescriptionDefaultTitleMsgs
  54 #define LocalizeManifestWithNameDescriptionOmniboxMsgs \
  55   DISABLED_LocalizeManifestWithNameDescriptionOmniboxMsgs
  56 #define LocalizeManifestWithNameDescriptionFileHandlerTitle \
  57   DISABLED_LocalizeManifestWithNameDescriptionFileHandlerTitle
  58 #define ShouldRelocalizeManifestWithNullManifest \
  59   DISABLED_ShouldRelocalizeManifestWithNullManifest
  60 #define ShouldRelocalizeManifestEmptyManifest \
  61   DISABLED_ShouldRelocalizeManifestEmptyManifest
  62 #define ShouldRelocalizeManifestWithDefaultLocale \
  63   DISABLED_ShouldRelocalizeManifestWithDefaultLocale
  64 #define ShouldRelocalizeManifestWithCurrentLocale \
  65   DISABLED_ShouldRelocalizeManifestWithCurrentLocale
  66 #define ShouldRelocalizeManifestSameCurrentLocale \
  67   DISABLED_ShouldRelocalizeManifestSameCurrentLocale
  68 #define ShouldRelocalizeManifestDifferentCurrentLocale \
  69   DISABLED_ShouldRelocalizeManifestDifferentCurrentLocale
  70 #endif
  71
  72 TEST(ExtensionL10nUtil, GetValidLocalesEmptyLocaleFolder) {
  73   ScopedTempDir temp;
  74   ASSERT_TRUE(temp.CreateUniqueTempDir());
  75
  76   FilePath src_path = temp.path().Append(Extension::kLocaleFolder);
  77   ASSERT_TRUE(file_util::CreateDirectory(src_path));
  78
  79   std::string error;
  80   std::set<std::string> locales;
  81   EXPECT_FALSE(extension_l10n_util::GetValidLocales(src_path,
  82                                                     &locales,
  83                                                     &error));
  84
  85   EXPECT_TRUE(locales.empty());
  86 }
  87
  88 TEST(ExtensionL10nUtil, GetValidLocalesWithValidLocaleNoMessagesFile) {
  89   ScopedTempDir temp;
  90   ASSERT_TRUE(temp.CreateUniqueTempDir());
  91
  92   FilePath src_path = temp.path().Append(Extension::kLocaleFolder);
  93   ASSERT_TRUE(file_util::CreateDirectory(src_path));
  94   ASSERT_TRUE(file_util::CreateDirectory(src_path.AppendASCII("sr")));
  95
  96   std::string error;
  97   std::set<std::string> locales;
  98   EXPECT_FALSE(extension_l10n_util::GetValidLocales(src_path,
  99                                                     &locales,
 100                                                     &error));
 101
 102   EXPECT_TRUE(locales.empty());
 103 }
 104
 105 TEST(ExtensionL10nUtil, GetValidLocalesWithUnsupportedLocale) {
 106   ScopedTempDir temp;
 107   ASSERT_TRUE(temp.CreateUniqueTempDir());
 108
 109   FilePath src_path = temp.path().Append(Extension::kLocaleFolder);
 110   ASSERT_TRUE(file_util::CreateDirectory(src_path));
 111   // Supported locale.
 112   FilePath locale_1 = src_path.AppendASCII("sr");
 113   ASSERT_TRUE(file_util::CreateDirectory(locale_1));
 114   std::string data("whatever");
 115   ASSERT_TRUE(file_util::WriteFile(
 116       locale_1.Append(Extension::kMessagesFilename),
 117       data.c_str(), data.length()));
 118   // Unsupported locale.
 119   ASSERT_TRUE(file_util::CreateDirectory(src_path.AppendASCII("xxx_yyy")));
 120
 121   std::string error;
 122   std::set<std::string> locales;
 123   EXPECT_TRUE(extension_l10n_util::GetValidLocales(src_path,
 124                                                    &locales,
 125                                                    &error));
 126
 127   EXPECT_FALSE(locales.empty());
 128   EXPECT_TRUE(locales.find("sr") != locales.end());
 129   EXPECT_FALSE(locales.find("xxx_yyy") != locales.end());
 130 }
 131
 132 TEST(ExtensionL10nUtil, GetValidLocalesWithValidLocalesAndMessagesFile) {
 133   FilePath install_dir;
 134   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &install_dir));
 135   install_dir = install_dir.AppendASCII("extensions")
 136       .AppendASCII("good")
 137       .AppendASCII("Extensions")
 138       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
 139       .AppendASCII("1.0.0.0")
 140       .Append(Extension::kLocaleFolder);
 141
 142   std::string error;
 143   std::set<std::string> locales;
 144   EXPECT_TRUE(extension_l10n_util::GetValidLocales(install_dir,
 145                                                    &locales,
 146                                                    &error));
 147   EXPECT_EQ(3U, locales.size());
 148   EXPECT_TRUE(locales.find("sr") != locales.end());
 149   EXPECT_TRUE(locales.find("en") != locales.end());
 150   EXPECT_TRUE(locales.find("en_US") != locales.end());
 151 }
 152
 153 TEST(ExtensionL10nUtil, LoadMessageCatalogsValidFallback) {
 154   FilePath install_dir;
 155   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &install_dir));
 156   install_dir = install_dir.AppendASCII("extensions")
 157       .AppendASCII("good")
 158       .AppendASCII("Extensions")
 159       .AppendASCII("behllobkkfkfnphdnhnkndlbkcpglgmj")
 160       .AppendASCII("1.0.0.0")
 161       .Append(Extension::kLocaleFolder);
 162
 163   std::string error;
 164   std::set<std::string> locales;
 165   EXPECT_TRUE(extension_l10n_util::GetValidLocales(install_dir,
 166                                                    &locales,
 167                                                    &error));
 168
 169   scoped_ptr<MessageBundle> bundle(extension_l10n_util::LoadMessageCatalogs(
 170       install_dir, "sr", "en_US", locales, &error));
 171   ASSERT_FALSE(NULL == bundle.get());
 172   EXPECT_TRUE(error.empty());
 173   EXPECT_EQ("Color", bundle->GetL10nMessage("color"));
 174   EXPECT_EQ("Not in the US or GB.", bundle->GetL10nMessage("not_in_US_or_GB"));
 175 }
 176
 177 TEST(ExtensionL10nUtil, LoadMessageCatalogsMissingFiles) {
 178   ScopedTempDir temp;
 179   ASSERT_TRUE(temp.CreateUniqueTempDir());
 180
 181   FilePath src_path = temp.path().Append(Extension::kLocaleFolder);
 182   ASSERT_TRUE(file_util::CreateDirectory(src_path));
 183
 184   std::set<std::string> valid_locales;
 185   valid_locales.insert("sr");
 186   valid_locales.insert("en");
 187   std::string error;
 188   EXPECT_TRUE(NULL == extension_l10n_util::LoadMessageCatalogs(src_path,
 189                                                                "en",
 190                                                                "sr",
 191                                                                valid_locales,
 192                                                                &error));
 193   EXPECT_FALSE(error.empty());
 194 }
 195
 196 TEST(ExtensionL10nUtil, LoadMessageCatalogsBadJSONFormat) {
 197   ScopedTempDir temp;
 198   ASSERT_TRUE(temp.CreateUniqueTempDir());
 199
 200   FilePath src_path = temp.path().Append(Extension::kLocaleFolder);
 201   ASSERT_TRUE(file_util::CreateDirectory(src_path));
 202
 203   FilePath locale = src_path.AppendASCII("sr");
 204   ASSERT_TRUE(file_util::CreateDirectory(locale));
 205
 206   std::string data = "{ \"name\":";
 207   ASSERT_TRUE(
 208       file_util::WriteFile(locale.Append(Extension::kMessagesFilename),
 209                            data.c_str(), data.length()));
 210
 211   std::set<std::string> valid_locales;
 212   valid_locales.insert("sr");
 213   valid_locales.insert("en_US");
 214   std::string error;
 215   EXPECT_TRUE(NULL == extension_l10n_util::LoadMessageCatalogs(src_path,
 216                                                                "en_US",
 217                                                                "sr",
 218                                                                valid_locales,
 219                                                                &error));
 220   EXPECT_EQ("Line: 1, column: 10, Unexpected token.", error);
 221 }
 222
 223 TEST(ExtensionL10nUtil, LoadMessageCatalogsDuplicateKeys) {
 224   ScopedTempDir temp;
 225   ASSERT_TRUE(temp.CreateUniqueTempDir());
 226
 227   FilePath src_path = temp.path().Append(Extension::kLocaleFolder);
 228   ASSERT_TRUE(file_util::CreateDirectory(src_path));
 229
 230   FilePath locale_1 = src_path.AppendASCII("en");
 231   ASSERT_TRUE(file_util::CreateDirectory(locale_1));
 232
 233   std::string data =
 234     "{ \"name\": { \"message\": \"something\" }, "
 235     "\"name\": { \"message\": \"something else\" } }";
 236   ASSERT_TRUE(
 237       file_util::WriteFile(locale_1.Append(Extension::kMessagesFilename),
 238                            data.c_str(), data.length()));
 239
 240   FilePath locale_2 = src_path.AppendASCII("sr");
 241   ASSERT_TRUE(file_util::CreateDirectory(locale_2));
 242
 243   ASSERT_TRUE(
 244       file_util::WriteFile(locale_2.Append(Extension::kMessagesFilename),
 245                            data.c_str(), data.length()));
 246
 247   std::set<std::string> valid_locales;
 248   valid_locales.insert("sr");
 249   valid_locales.insert("en");
 250   std::string error;
 251   // JSON parser hides duplicates. We are going to get only one key/value
 252   // pair at the end.
 253   scoped_ptr<MessageBundle> message_bundle(
 254       extension_l10n_util::LoadMessageCatalogs(src_path,
 255                                                "en",
 256                                                "sr",
 257                                                valid_locales,
 258                                                &error));
 259   EXPECT_TRUE(NULL != message_bundle.get());
 260   EXPECT_TRUE(error.empty());
 261 }
 262
 263 // Caller owns the returned object.
 264 MessageBundle* CreateManifestBundle() {
 265   linked_ptr<DictionaryValue> catalog(new DictionaryValue);
 266
 267   DictionaryValue* name_tree = new DictionaryValue();
 268   name_tree->SetString("message", "name");
 269   catalog->Set("name", name_tree);
 270
 271   DictionaryValue* description_tree = new DictionaryValue();
 272   description_tree->SetString("message", "description");
 273   catalog->Set("description", description_tree);
 274
 275   DictionaryValue* action_title_tree = new DictionaryValue();
 276   action_title_tree->SetString("message", "action title");
 277   catalog->Set("title", action_title_tree);
 278
 279   DictionaryValue* omnibox_keyword_tree = new DictionaryValue();
 280   omnibox_keyword_tree->SetString("message", "omnibox keyword");
 281   catalog->Set("omnibox_keyword", omnibox_keyword_tree);
 282
 283   DictionaryValue* file_handler_title_tree = new DictionaryValue();
 284   file_handler_title_tree->SetString("message", "file handler title");
 285   catalog->Set("file_handler_title", file_handler_title_tree);
 286
 287   DictionaryValue* launch_local_path_tree = new DictionaryValue();
 288   launch_local_path_tree->SetString("message", "main.html");
 289   catalog->Set("launch_local_path", launch_local_path_tree);
 290
 291   DictionaryValue* launch_web_url_tree = new DictionaryValue();
 292   launch_web_url_tree->SetString("message", "http://www.google.com/");
 293   catalog->Set("launch_web_url", launch_web_url_tree);
 294
 295   DictionaryValue* intent_title_tree = new DictionaryValue();
 296   intent_title_tree->SetString("message", "intent title");
 297   catalog->Set("intent_title", intent_title_tree);
 298
 299   DictionaryValue* intent_title_tree_2 = new DictionaryValue();
 300   intent_title_tree_2->SetString("message", "intent title 2");
 301   catalog->Set("intent_title2", intent_title_tree_2);
 302
 303   std::vector<linked_ptr<DictionaryValue> > catalogs;
 304   catalogs.push_back(catalog);
 305
 306   std::string error;
 307   MessageBundle* bundle = MessageBundle::Create(catalogs, &error);
 308   EXPECT_TRUE(bundle);
 309   EXPECT_TRUE(error.empty());
 310
 311   return bundle;
 312 }
 313
 314 TEST(ExtensionL10nUtil, LocalizeEmptyManifest) {
 315   DictionaryValue manifest;
 316   std::string error;
 317   scoped_ptr<MessageBundle> messages(CreateManifestBundle());
 318
 319   EXPECT_FALSE(
 320       extension_l10n_util::LocalizeManifest(*messages, &manifest, &error));
 321   EXPECT_EQ(std::string(errors::kInvalidName), error);
 322 }
 323
 324 TEST(ExtensionL10nUtil, LocalizeManifestWithoutNameMsgAndEmptyDescription) {
 325   DictionaryValue manifest;
 326   manifest.SetString(keys::kName, "no __MSG");
 327   std::string error;
 328   scoped_ptr<MessageBundle> messages(CreateManifestBundle());
 329
 330   EXPECT_TRUE(
 331       extension_l10n_util::LocalizeManifest(*messages, &manifest, &error));
 332
 333   std::string result;
 334   ASSERT_TRUE(manifest.GetString(keys::kName, &result));
 335   EXPECT_EQ("no __MSG", result);
 336
 337   EXPECT_FALSE(manifest.HasKey(keys::kDescription));
 338
 339   EXPECT_TRUE(error.empty());
 340 }
 341
 342 TEST(ExtensionL10nUtil, LocalizeManifestWithNameMsgAndEmptyDescription) {
 343   DictionaryValue manifest;
 344   manifest.SetString(keys::kName, "__MSG_name__");
 345   std::string error;
 346   scoped_ptr<MessageBundle> messages(CreateManifestBundle());
 347
 348   EXPECT_TRUE(
 349       extension_l10n_util::LocalizeManifest(*messages, &manifest, &error));
 350
 351   std::string result;
 352   ASSERT_TRUE(manifest.GetString(keys::kName, &result));
 353   EXPECT_EQ("name", result);
 354
 355   EXPECT_FALSE(manifest.HasKey(keys::kDescription));
 356
 357   EXPECT_TRUE(error.empty());
 358 }
 359
 360 TEST(ExtensionL10nUtil, LocalizeManifestWithLocalLaunchURL) {
 361   DictionaryValue manifest;
 362   manifest.SetString(keys::kName, "name");
 363   manifest.SetString(keys::kLaunchLocalPath, "__MSG_launch_local_path__");
 364   std::string error;
 365   scoped_ptr<MessageBundle> messages(CreateManifestBundle());
 366
 367   EXPECT_TRUE(
 368       extension_l10n_util::LocalizeManifest(*messages, &manifest, &error));
 369
 370   std::string result;
 371   ASSERT_TRUE(manifest.GetString(keys::kLaunchLocalPath, &result));
 372   EXPECT_EQ("main.html", result);
 373
 374   EXPECT_TRUE(error.empty());
 375 }
 376
 377 TEST(ExtensionL10nUtil, LocalizeManifestWithHostedLaunchURL) {
 378   DictionaryValue manifest;
 379   manifest.SetString(keys::kName, "name");
 380   manifest.SetString(keys::kLaunchWebURL, "__MSG_launch_web_url__");
 381   std::string error;
 382   scoped_ptr<MessageBundle> messages(CreateManifestBundle());
 383
 384   EXPECT_TRUE(
 385       extension_l10n_util::LocalizeManifest(*messages, &manifest, &error));
 386
 387   std::string result;
 388   ASSERT_TRUE(manifest.GetString(keys::kLaunchWebURL, &result));
 389   EXPECT_EQ("http://www.google.com/", result);
 390
 391   EXPECT_TRUE(error.empty());
 392 }
 393
 394 TEST(ExtensionL10nUtil, LocalizeManifestWithIntents) {
 395   DictionaryValue manifest;
 396   DictionaryValue* intents = new DictionaryValue;
 397   DictionaryValue* action = new DictionaryValue;
 398
 399   action->SetString(keys::kIntentTitle, "__MSG_intent_title__");
 400   intents->Set("share", action);
 401   manifest.SetString(keys::kName, "name");
 402   manifest.Set(keys::kIntents, intents);
 403
 404   std::string error;
 405   scoped_ptr<MessageBundle> messages(CreateManifestBundle());
 406
 407   EXPECT_TRUE(
 408       extension_l10n_util::LocalizeManifest(*messages, &manifest, &error));
 409
 410   std::string result;
 411   ASSERT_TRUE(manifest.GetString("intents.share.title", &result));
 412   EXPECT_EQ("intent title", result);
 413
 414   EXPECT_TRUE(error.empty());
 415 }
 416
 417 TEST(ExtensionL10nUtil, LocalizeManifestWithIntentsList) {
 418   DictionaryValue manifest;
 419   DictionaryValue* intents = new DictionaryValue;
 420   ListValue* actions = new ListValue;
 421   DictionaryValue* action1 = new DictionaryValue;
 422   DictionaryValue* action2 = new DictionaryValue;
 423
 424   action1->SetString(keys::kIntentTitle, "__MSG_intent_title__");
 425   action2->SetString(keys::kIntentTitle, "__MSG_intent_title2__");
 426   actions->Append(action1);
 427   actions->Append(action2);
 428   intents->Set("share", actions);
 429   manifest.SetString(keys::kName, "name");
 430   manifest.Set(keys::kIntents, intents);
 431
 432   std::string error;
 433   scoped_ptr<MessageBundle> messages(CreateManifestBundle());
 434
 435   EXPECT_TRUE(
 436       extension_l10n_util::LocalizeManifest(*messages, &manifest, &error));
 437
 438   std::string result;
 439   ListValue* l10n_actions = NULL;
 440   ASSERT_TRUE(manifest.GetList("intents.share", &l10n_actions));
 441
 442   DictionaryValue* l10n_action = NULL;
 443   ASSERT_TRUE(l10n_actions->GetDictionary(0, &l10n_action));
 444
 445   ASSERT_TRUE(l10n_action->GetString(keys::kIntentTitle, &result));
 446   EXPECT_EQ("intent title", result);
 447
 448   l10n_action = NULL;
 449   ASSERT_TRUE(l10n_actions->GetDictionary(1, &l10n_action));
 450
 451   ASSERT_TRUE(l10n_action->GetString(keys::kIntentTitle, &result));
 452   EXPECT_EQ("intent title 2", result);
 453
 454   EXPECT_TRUE(error.empty());
 455 }
 456
 457
 458 TEST(ExtensionL10nUtil, LocalizeManifestWithBadNameMsg) {
 459   DictionaryValue manifest;
 460   manifest.SetString(keys::kName, "__MSG_name_is_bad__");
 461   manifest.SetString(keys::kDescription, "__MSG_description__");
 462   std::string error;
 463   scoped_ptr<MessageBundle> messages(CreateManifestBundle());
 464
 465   EXPECT_FALSE(
 466       extension_l10n_util::LocalizeManifest(*messages, &manifest, &error));
 467
 468   std::string result;
 469   ASSERT_TRUE(manifest.GetString(keys::kName, &result));
 470   EXPECT_EQ("__MSG_name_is_bad__", result);
 471
 472   ASSERT_TRUE(manifest.GetString(keys::kDescription, &result));
 473   EXPECT_EQ("__MSG_description__", result);
 474
 475   EXPECT_EQ("Variable __MSG_name_is_bad__ used but not defined.", error);
 476 }
 477
 478 TEST(ExtensionL10nUtil, LocalizeManifestWithNameDescriptionDefaultTitleMsgs) {
 479   DictionaryValue manifest;
 480   manifest.SetString(keys::kName, "__MSG_name__");
 481   manifest.SetString(keys::kDescription, "__MSG_description__");
 482   std::string action_title(keys::kBrowserAction);
 483   action_title.append(".");
 484   action_title.append(keys::kPageActionDefaultTitle);
 485   manifest.SetString(action_title, "__MSG_title__");
 486
 487   std::string error;
 488   scoped_ptr<MessageBundle> messages(CreateManifestBundle());
 489
 490   EXPECT_TRUE(
 491       extension_l10n_util::LocalizeManifest(*messages, &manifest, &error));
 492
 493   std::string result;
 494   ASSERT_TRUE(manifest.GetString(keys::kName, &result));
 495   EXPECT_EQ("name", result);
 496
 497   ASSERT_TRUE(manifest.GetString(keys::kDescription, &result));
 498   EXPECT_EQ("description", result);
 499
 500   ASSERT_TRUE(manifest.GetString(action_title, &result));
 501   EXPECT_EQ("action title", result);
 502
 503   EXPECT_TRUE(error.empty());
 504 }
 505
 506 TEST(ExtensionL10nUtil, LocalizeManifestWithNameDescriptionOmniboxMsgs) {
 507   DictionaryValue manifest;
 508   manifest.SetString(keys::kName, "__MSG_name__");
 509   manifest.SetString(keys::kDescription, "__MSG_description__");
 510   manifest.SetString(keys::kOmniboxKeyword, "__MSG_omnibox_keyword__");
 511
 512   std::string error;
 513   scoped_ptr<MessageBundle> messages(CreateManifestBundle());
 514
 515   EXPECT_TRUE(
 516       extension_l10n_util::LocalizeManifest(*messages, &manifest, &error));
 517
 518   std::string result;
 519   ASSERT_TRUE(manifest.GetString(keys::kName, &result));
 520   EXPECT_EQ("name", result);
 521
 522   ASSERT_TRUE(manifest.GetString(keys::kDescription, &result));
 523   EXPECT_EQ("description", result);
 524
 525   ASSERT_TRUE(manifest.GetString(keys::kOmniboxKeyword, &result));
 526   EXPECT_EQ("omnibox keyword", result);
 527
 528   EXPECT_TRUE(error.empty());
 529 }
 530
 531 TEST(ExtensionL10nUtil, LocalizeManifestWithNameDescriptionFileHandlerTitle) {
 532   DictionaryValue manifest;
 533   manifest.SetString(keys::kName, "__MSG_name__");
 534   manifest.SetString(keys::kDescription, "__MSG_description__");
 535   ListValue* handlers = new ListValue();
 536   manifest.Set(keys::kFileBrowserHandlers, handlers);
 537   DictionaryValue* handler = new DictionaryValue();
 538   handlers->Append(handler);
 539   handler->SetString(keys::kPageActionDefaultTitle,
 540                      "__MSG_file_handler_title__");
 541
 542   std::string error;
 543   scoped_ptr<MessageBundle> messages(CreateManifestBundle());
 544
 545   EXPECT_TRUE(
 546       extension_l10n_util::LocalizeManifest(*messages, &manifest, &error));
 547
 548   std::string result;
 549   ASSERT_TRUE(manifest.GetString(keys::kName, &result));
 550   EXPECT_EQ("name", result);
 551
 552   ASSERT_TRUE(manifest.GetString(keys::kDescription, &result));
 553   EXPECT_EQ("description", result);
 554
 555   ASSERT_TRUE(handler->GetString(keys::kPageActionDefaultTitle, &result));
 556   EXPECT_EQ("file handler title", result);
 557
 558   EXPECT_TRUE(error.empty());
 559 }
 560
 561 // Try with NULL manifest.
 562 TEST(ExtensionL10nUtil, ShouldRelocalizeManifestWithNullManifest) {
 563   ExtensionInfo info(NULL, "", FilePath(), Extension::LOAD);
 564
 565   EXPECT_FALSE(extension_l10n_util::ShouldRelocalizeManifest(info));
 566 }
 567
 568 // Try with default and current locales missing.
 569 TEST(ExtensionL10nUtil, ShouldRelocalizeManifestEmptyManifest) {
 570   DictionaryValue manifest;
 571   ExtensionInfo info(&manifest, "", FilePath(), Extension::LOAD);
 572
 573   EXPECT_FALSE(extension_l10n_util::ShouldRelocalizeManifest(info));
 574 }
 575
 576 // Try with missing current_locale.
 577 TEST(ExtensionL10nUtil, ShouldRelocalizeManifestWithDefaultLocale) {
 578   DictionaryValue manifest;
 579   manifest.SetString(keys::kDefaultLocale, "en_US");
 580
 581   ExtensionInfo info(&manifest, "", FilePath(), Extension::LOAD);
 582
 583   EXPECT_TRUE(extension_l10n_util::ShouldRelocalizeManifest(info));
 584 }
 585
 586 // Try with missing default_locale.
 587 TEST(ExtensionL10nUtil, ShouldRelocalizeManifestWithCurrentLocale) {
 588   DictionaryValue manifest;
 589   manifest.SetString(keys::kCurrentLocale,
 590                      extension_l10n_util::CurrentLocaleOrDefault());
 591
 592   ExtensionInfo info(&manifest, "", FilePath(), Extension::LOAD);
 593
 594   EXPECT_FALSE(extension_l10n_util::ShouldRelocalizeManifest(info));
 595 }
 596
 597 // Try with all data present, but with same current_locale as system locale.
 598 TEST(ExtensionL10nUtil, ShouldRelocalizeManifestSameCurrentLocale) {
 599   DictionaryValue manifest;
 600   manifest.SetString(keys::kDefaultLocale, "en_US");
 601   manifest.SetString(keys::kCurrentLocale,
 602                      extension_l10n_util::CurrentLocaleOrDefault());
 603
 604   ExtensionInfo info(&manifest, "", FilePath(), Extension::LOAD);
 605
 606   EXPECT_FALSE(extension_l10n_util::ShouldRelocalizeManifest(info));
 607 }
 608
 609 // Try with all data present, but with different current_locale.
 610 TEST(ExtensionL10nUtil, ShouldRelocalizeManifestDifferentCurrentLocale) {
 611   DictionaryValue manifest;
 612   manifest.SetString(keys::kDefaultLocale, "en_US");
 613   manifest.SetString(keys::kCurrentLocale, "sr");
 614
 615   ExtensionInfo info(&manifest, "", FilePath(), Extension::LOAD);
 616
 617   EXPECT_TRUE(extension_l10n_util::ShouldRelocalizeManifest(info));
 618 }
 619
 620 TEST(ExtensionL10nUtil, GetAllFallbackLocales) {
 621   std::vector<std::string> fallback_locales;
 622   extension_l10n_util::GetAllFallbackLocales("en_US", "all", &fallback_locales);
 623   ASSERT_EQ(3U, fallback_locales.size());
 624
 625   CHECK_EQ("en_US", fallback_locales[0]);
 626   CHECK_EQ("en", fallback_locales[1]);
 627   CHECK_EQ("all", fallback_locales[2]);
 628 }
 629
 630 }  // namespace