1 files changed, 80 insertions, 51 deletions

diff --git a/chrome/common/extensions/extension_manifests_unittest.cc b/chrome/common/extensions/extension_manifests_unittest.cc
index ac56f70..3a89166 100644
--- a/chrome/common/extensions/extension_manifests_unittest.cc
+++ b/chrome/common/extensions/extension_manifests_unittest.cc
@@ -37,53 +37,48 @@ class ExtensionManifestTest : public testing::Test {
     return static_cast<DictionaryValue*>(serializer.Deserialize(NULL, error));
   }
 
-  Extension* LoadExtensionWithLocation(DictionaryValue* value,
-                                       Extension::Location location,
-                                       std::string* error) {
+  scoped_refptr<Extension> LoadExtensionWithLocation(
+      DictionaryValue* value,
+      Extension::Location location,
+      std::string* error) {
     FilePath path;
     PathService::Get(chrome::DIR_TEST_DATA, &path);
     path = path.AppendASCII("extensions").AppendASCII("manifest_tests");
-
-    scoped_ptr<Extension> extension(new Extension(path.DirName()));
-    extension->set_location(location);
-
-    if (!extension->InitFromValue(*value, false, error))
-      return NULL;
-
-    return extension.release();
+    return Extension::Create(path.DirName(), location, *value, false, error);
   }
 
-  Extension* LoadExtension(const std::string& name,
-                           std::string* error) {
+  scoped_refptr<Extension> LoadExtension(const std::string& name,
+                                         std::string* error) {
     return LoadExtensionWithLocation(name, Extension::INTERNAL, error);
   }
 
-  Extension* LoadExtension(DictionaryValue* value,
-                           std::string* error) {
+  scoped_refptr<Extension> LoadExtension(DictionaryValue* value,
+                                         std::string* error) {
     return LoadExtensionWithLocation(value, Extension::INTERNAL, error);
   }
 
-  Extension* LoadExtensionWithLocation(const std::string& name,
-                                       Extension::Location location,
-                                       std::string* error) {
+  scoped_refptr<Extension> LoadExtensionWithLocation(
+      const std::string& name,
+      Extension::Location location,
+      std::string* error) {
     scoped_ptr<DictionaryValue> value(LoadManifestFile(name, error));
     if (!value.get())
       return NULL;
     return LoadExtensionWithLocation(value.get(), location, error);
   }
 
-  Extension* LoadAndExpectSuccess(const std::string& name) {
+  scoped_refptr<Extension> LoadAndExpectSuccess(const std::string& name) {
     std::string error;
-    Extension* extension = LoadExtension(name, &error);
+    scoped_refptr<Extension> extension = LoadExtension(name, &error);
     EXPECT_TRUE(extension) << name;
     EXPECT_EQ("", error) << name;
     return extension;
   }
 
-  Extension* LoadAndExpectSuccess(DictionaryValue* manifest,
-                                  const std::string& name) {
+  scoped_refptr<Extension> LoadAndExpectSuccess(DictionaryValue* manifest,
+                                                const std::string& name) {
     std::string error;
-    Extension* extension = LoadExtension(manifest, &error);
+    scoped_refptr<Extension> extension = LoadExtension(manifest, &error);
     EXPECT_TRUE(extension) << "Unexpected success for " << name;
     EXPECT_EQ("", error) << "Unexpected no error for " << name;
     return extension;
@@ -103,7 +98,7 @@ class ExtensionManifestTest : public testing::Test {
   void LoadAndExpectError(const std::string& name,
                           const std::string& expected_error) {
     std::string error;
-    scoped_ptr<Extension> extension(LoadExtension(name, &error));
+    scoped_refptr<Extension> extension(LoadExtension(name, &error));
     VerifyExpectedError(extension.get(), name, error, expected_error);
   }
 
@@ -111,7 +106,7 @@ class ExtensionManifestTest : public testing::Test {
                           const std::string& name,
                           const std::string& expected_error) {
     std::string error;
-    scoped_ptr<Extension> extension(LoadExtension(manifest, &error));
+    scoped_refptr<Extension> extension(LoadExtension(manifest, &error));
     VerifyExpectedError(extension.get(), name, error, expected_error);
   }
 
@@ -119,7 +114,7 @@ class ExtensionManifestTest : public testing::Test {
 };
 
 TEST_F(ExtensionManifestTest, ValidApp) {
-  scoped_ptr<Extension> extension(LoadAndExpectSuccess("valid_app.json"));
+  scoped_refptr<Extension> extension(LoadAndExpectSuccess("valid_app.json"));
   ASSERT_EQ(2u, extension->web_extent().patterns().size());
   EXPECT_EQ("http://www.google.com/mail/*",
             extension->web_extent().patterns()[0].GetAsString());
@@ -145,7 +140,7 @@ TEST_F(ExtensionManifestTest, AppWebUrls) {
                      ExtensionErrorUtils::FormatErrorMessage(
                          errors::kInvalidWebURL, "0"));
 
-  scoped_ptr<Extension> extension(
+  scoped_refptr<Extension> extension(
       LoadAndExpectSuccess("web_urls_default.json"));
   ASSERT_EQ(1u, extension->web_extent().patterns().size());
   EXPECT_EQ("*://www.google.com/*",
@@ -153,21 +148,21 @@ TEST_F(ExtensionManifestTest, AppWebUrls) {
 }
 
 TEST_F(ExtensionManifestTest, AppLaunchContainer) {
-  scoped_ptr<Extension> extension;
+  scoped_refptr<Extension> extension;
 
-  extension.reset(LoadAndExpectSuccess("launch_tab.json"));
+  extension = LoadAndExpectSuccess("launch_tab.json");
   EXPECT_EQ(extension_misc::LAUNCH_TAB, extension->launch_container());
 
-  extension.reset(LoadAndExpectSuccess("launch_panel.json"));
+  extension = LoadAndExpectSuccess("launch_panel.json");
   EXPECT_EQ(extension_misc::LAUNCH_PANEL, extension->launch_container());
 
-  extension.reset(LoadAndExpectSuccess("launch_default.json"));
+  extension = LoadAndExpectSuccess("launch_default.json");
   EXPECT_EQ(extension_misc::LAUNCH_TAB, extension->launch_container());
 
-  extension.reset(LoadAndExpectSuccess("launch_width.json"));
+  extension = LoadAndExpectSuccess("launch_width.json");
   EXPECT_EQ(640, extension->launch_width());
 
-  extension.reset(LoadAndExpectSuccess("launch_height.json"));
+  extension = LoadAndExpectSuccess("launch_height.json");
   EXPECT_EQ(480, extension->launch_height());
 
   LoadAndExpectError("launch_window.json",
@@ -198,15 +193,15 @@ TEST_F(ExtensionManifestTest, AppLaunchURL) {
   LoadAndExpectError("launch_url_invalid_type.json",
                      errors::kInvalidLaunchWebURL);
 
-  scoped_ptr<Extension> extension;
-  extension.reset(LoadAndExpectSuccess("launch_local_path.json"));
+  scoped_refptr<Extension> extension;
+  extension = LoadAndExpectSuccess("launch_local_path.json");
   EXPECT_EQ(extension->url().spec() + "launch.html",
             extension->GetFullLaunchURL().spec());
 
   LoadAndExpectError("launch_web_url_relative.json",
                      errors::kInvalidLaunchWebURL);
 
-  extension.reset(LoadAndExpectSuccess("launch_web_url_absolute.json"));
+  extension = LoadAndExpectSuccess("launch_web_url_absolute.json");
   EXPECT_EQ(GURL("http://www.google.com/launch.html"),
             extension->GetFullLaunchURL());
 }
@@ -217,13 +212,13 @@ TEST_F(ExtensionManifestTest, Override) {
   LoadAndExpectError("override_invalid_page.json",
                      errors::kInvalidChromeURLOverrides);
 
-  scoped_ptr<Extension> extension;
+  scoped_refptr<Extension> extension;
 
-  extension.reset(LoadAndExpectSuccess("override_new_tab.json"));
+  extension = LoadAndExpectSuccess("override_new_tab.json");
   EXPECT_EQ(extension->url().spec() + "newtab.html",
             extension->GetChromeURLOverrides().find("newtab")->second.spec());
 
-  extension.reset(LoadAndExpectSuccess("override_history.json"));
+  extension = LoadAndExpectSuccess("override_history.json");
   EXPECT_EQ(extension->url().spec() + "history.html",
             extension->GetChromeURLOverrides().find("history")->second.spec());
 }
@@ -237,11 +232,11 @@ TEST_F(ExtensionManifestTest, ChromeResourcesPermissionValidOnlyForComponents) {
   LoadAndExpectError("permission_chrome_resources_url.json",
       errors::kInvalidPermissionScheme);
   std::string error;
-  scoped_ptr<Extension> extension;
-  extension.reset(LoadExtensionWithLocation(
+  scoped_refptr<Extension> extension;
+  extension = LoadExtensionWithLocation(
       "permission_chrome_resources_url.json",
       Extension::COMPONENT,
-      &error));
+      &error);
   EXPECT_EQ("", error);
 }
 
@@ -260,8 +255,8 @@ TEST_F(ExtensionManifestTest, DevToolsExtensions) {
   CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kEnableExperimentalExtensionApis);
 
-  scoped_ptr<Extension> extension;
-  extension.reset(LoadAndExpectSuccess("devtools_extension.json"));
+  scoped_refptr<Extension> extension;
+  extension = LoadAndExpectSuccess("devtools_extension.json");
   EXPECT_EQ(extension->url().spec() + "devtools.html",
             extension->devtools_url().spec());
   *CommandLine::ForCurrentProcess() = old_command_line;
@@ -275,11 +270,10 @@ TEST_F(ExtensionManifestTest, DisallowHybridApps) {
 }
 
 TEST_F(ExtensionManifestTest, OptionsPageInApps) {
-  scoped_ptr<Extension> extension;
+  scoped_refptr<Extension> extension;
 
   // Allow options page with absolute URL in hosed apps.
-  extension.reset(
-      LoadAndExpectSuccess("hosted_app_absolute_options.json"));
+  extension = LoadAndExpectSuccess("hosted_app_absolute_options.json");
   EXPECT_STREQ("http",
                extension->options_url().scheme().c_str());
   EXPECT_STREQ("example.com",
@@ -313,10 +307,10 @@ TEST_F(ExtensionManifestTest, DisallowExtensionPermissions) {
     StringValue* p = new StringValue(name);
     permissions->Clear();
     permissions->Append(p);
-    std::string message_name = StringPrintf("permission-%s", name);
+    std::string message_name = base::StringPrintf("permission-%s", name);
     if (Extension::IsHostedAppPermission(name)) {
-      scoped_ptr<Extension> extension;
-      extension.reset(LoadAndExpectSuccess(manifest.get(), message_name));
+      scoped_refptr<Extension> extension;
+      extension = LoadAndExpectSuccess(manifest.get(), message_name);
     } else {
       LoadAndExpectError(manifest.get(), message_name,
                          errors::kInvalidPermission);
@@ -325,7 +319,7 @@ TEST_F(ExtensionManifestTest, DisallowExtensionPermissions) {
 }
 
 TEST_F(ExtensionManifestTest, NormalizeIconPaths) {
-  scoped_ptr<Extension> extension(
+  scoped_refptr<Extension> extension(
       LoadAndExpectSuccess("normalize_icon_paths.json"));
   EXPECT_EQ("16.png",
             extension->icons().Get(16, ExtensionIconSet::MATCH_EXACTLY));
@@ -338,3 +332,38 @@ TEST_F(ExtensionManifestTest, DisallowMultipleUISurfaces) {
   LoadAndExpectError("multiple_ui_surfaces_2.json", errors::kOneUISurfaceOnly);
   LoadAndExpectError("multiple_ui_surfaces_3.json", errors::kOneUISurfaceOnly);
 }
+
+TEST_F(ExtensionManifestTest, ParseHomepageURLs) {
+  scoped_refptr<Extension> extension(
+      LoadAndExpectSuccess("homepage_valid.json"));
+  LoadAndExpectError("homepage_empty.json",
+                     extension_manifest_errors::kInvalidHomepageURL);
+  LoadAndExpectError("homepage_invalid.json",
+                     extension_manifest_errors::kInvalidHomepageURL);
+}
+
+TEST_F(ExtensionManifestTest, GetHomepageURL) {
+  scoped_refptr<Extension> extension(
+      LoadAndExpectSuccess("homepage_valid.json"));
+  EXPECT_EQ(GURL("http://foo.com#bar"), extension->GetHomepageURL());
+
+  // The Google Gallery URL ends with the id, which depends on the path, which
+  // can be different in testing, so we just check the part before id.
+  extension = LoadAndExpectSuccess("homepage_google_hosted.json");
+  EXPECT_TRUE(StartsWithASCII(extension->GetHomepageURL().spec(),
+                              "https://chrome.google.com/extensions/detail/",
+                              false));
+
+  extension = LoadAndExpectSuccess("homepage_externally_hosted.json");
+  EXPECT_EQ(GURL(), extension->GetHomepageURL());
+}
+
+TEST_F(ExtensionManifestTest, DefaultPathForExtent) {
+  scoped_refptr<Extension> extension(
+      LoadAndExpectSuccess("default_path_for_extent.json"));
+
+  ASSERT_EQ(1u, extension->web_extent().patterns().size());
+  EXPECT_EQ("/*", extension->web_extent().patterns()[0].path());
+  EXPECT_TRUE(extension->web_extent().ContainsURL(
+      GURL("http://www.google.com/monkey")));
+}