Allow app launch URLs to be localized.

chrome/common/extensions/extension_manifests_unittest.cc

 // Copyright (c) 2012 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 "chrome/common/extensions/extension.h"
 
 #if defined(TOOLKIT_GTK)
 #include <gtk/gtk.h>
 #endif
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/i18n/rtl.h"
 #include "base/json/json_value_serializer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_utils.h"
+#include "chrome/common/extensions/extension_l10n_util.h"
 #include "chrome/common/extensions/file_browser_handler.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/glue/web_intent_service_data.h"
 
 namespace {
 
 static void AddPattern(URLPatternSet* extent, const std::string& pattern) {
   int schemes = URLPattern::SCHEME_ALL;
   extent->AddPattern(URLPattern(schemes, pattern));
 }
 
 }
 
 namespace errors = extension_manifest_errors;
 namespace keys = extension_manifest_keys;
 
 class ExtensionManifestTest : public testing::Test {
  public:
   ExtensionManifestTest() : enable_apps_(true) {}
 
  protected:
   static DictionaryValue* LoadManifestFile(const std::string& filename,
                                            std::string* error) {
-    FilePath path;
-    PathService::Get(chrome::DIR_TEST_DATA, &path);
-    path = path.AppendASCII("extensions")
-        .AppendASCII("manifest_tests")
-        .AppendASCII(filename.c_str());
-    EXPECT_TRUE(file_util::PathExists(path)) <<
-        "Couldn't find " << path.value();
+    FilePath extension_path;
+    PathService::Get(chrome::DIR_TEST_DATA, &extension_path);
+    extension_path = extension_path.AppendASCII("extensions")
+        .AppendASCII("manifest_tests");
 
-    JSONFileValueSerializer serializer(path);
-    return static_cast<DictionaryValue*>(serializer.Deserialize(NULL, error));
+    FilePath manifest_path = extension_path.AppendASCII(filename.c_str());
+    EXPECT_TRUE(file_util::PathExists(manifest_path)) <<
+        "Couldn't find " << manifest_path.value();
+
+    JSONFileValueSerializer serializer(manifest_path);
+    DictionaryValue* manifest =
+        static_cast<DictionaryValue*>(serializer.Deserialize(NULL, error));
+
+    // Most unit tests don't need localization, and they'll fail if we try to
+    // localize them, since their manifests don't have a default_locale key.
+    // Only localize manifests that indicate they want to be localized.
+    // Calling LocalizeExtension at this point mirrors
+    // extension_file_util::LoadExtension.
+    if (manifest && filename.find("localized") != std::string::npos)
+      extension_l10n_util::LocalizeExtension(extension_path, manifest, error);
+
+    return manifest;
   }
 
   // Helper class that simplifies creating methods that take either a filename
   // to a manifest or the manifest itself.
   class Manifest {
    public:
     // Purposely not marked explicit for convenience. The vast majority of
     // callers pass string literal.
     Manifest(const char* name)
         : name_(name), manifest_(NULL) {
@@ skipping 353 matching lines @@
 
 TEST_F(ExtensionManifestTest, AppLaunchURL) {
   LoadAndExpectError("launch_path_and_url.json",
                      errors::kLaunchPathAndURLAreExclusive);
   LoadAndExpectError("launch_path_and_extent.json",
                      errors::kLaunchPathAndExtentAreExclusive);
   LoadAndExpectError("launch_path_invalid_type.json",
                      errors::kInvalidLaunchLocalPath);
   LoadAndExpectError("launch_path_invalid_value.json",
                      errors::kInvalidLaunchLocalPath);
+  LoadAndExpectError("launch_path_invalid_localized.json",
+                     errors::kInvalidLaunchLocalPath);
   LoadAndExpectError("launch_url_invalid_type_1.json",
                      errors::kInvalidLaunchWebURL);
   LoadAndExpectError("launch_url_invalid_type_2.json",
                      errors::kInvalidLaunchWebURL);
   LoadAndExpectError("launch_url_invalid_type_3.json",
                      errors::kInvalidLaunchWebURL);
+  LoadAndExpectError("launch_url_invalid_localized.json",
+                     errors::kInvalidLaunchWebURL);
 
   scoped_refptr<Extension> extension;
   extension = LoadAndExpectSuccess("launch_local_path.json");
   EXPECT_EQ(extension->url().spec() + "launch.html",
             extension->GetFullLaunchURL().spec());
 
+  extension = LoadAndExpectSuccess("launch_local_path_localized.json");
+  EXPECT_EQ(extension->url().spec() + "launch.html",
+            extension->GetFullLaunchURL().spec());
+
   LoadAndExpectError("launch_web_url_relative.json",
                      errors::kInvalidLaunchWebURL);
 
   extension = LoadAndExpectSuccess("launch_web_url_absolute.json");
   EXPECT_EQ(GURL("http://www.google.com/launch.html"),
             extension->GetFullLaunchURL());
+  extension = LoadAndExpectSuccess("launch_web_url_localized.json");
+  EXPECT_EQ(GURL("http://www.google.com/launch.html"),
+            extension->GetFullLaunchURL());
 }
 
 TEST_F(ExtensionManifestTest, Override) {
   LoadAndExpectError("override_newtab_and_history.json",
                      errors::kMultipleOverrides);
   LoadAndExpectError("override_invalid_page.json",
                      errors::kInvalidChromeURLOverrides);
 
   scoped_refptr<Extension> extension;
 
@@ skipping 514 matching lines @@
   EXPECT_EQ("", extension->page_action()->id());
   EXPECT_EQ(0u, extension->page_action()->icon_paths()->size());
   EXPECT_EQ("", extension->page_action()->GetTitle(
       ExtensionAction::kDefaultTabId));
   EXPECT_FALSE(extension->page_action()->HasPopup(
       ExtensionAction::kDefaultTabId));
 
   LoadAndExpectError("page_action_manifest_version_2b.json",
                      errors::kInvalidPageActionPopup);
 }