Use manifest for streamlined hosted app creation for title and URL.

chrome/browser/extensions/bookmark_app_helper_unittest.cc

 // Copyright 2014 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/browser/extensions/bookmark_app_helper.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_base.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/web_contents_tester.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_icon_set.h"
 #include "extensions/common/manifest_handlers/icons_handler.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/skia_util.h"
 
 namespace {
 
 const char kAppUrl[] = "http://www.chromium.org";
 const char kAppTitle[] = "Test title";
+const char kAppShortName[] = "Test short name";
 const char kAlternativeAppTitle[] = "Different test title";
 const char kAppDescription[] = "Test description";
 
 const int kIconSizeTiny = extension_misc::EXTENSION_ICON_BITTY;
 const int kIconSizeSmall = extension_misc::EXTENSION_ICON_SMALL;
 const int kIconSizeMedium = extension_misc::EXTENSION_ICON_MEDIUM;
 const int kIconSizeLarge = extension_misc::EXTENSION_ICON_LARGE;
 
 class BookmarkAppHelperTest : public testing::Test {
  public:
@@ skipping 85 matching lines @@
                         content::WebContents* contents)
       : BookmarkAppHelper(service, web_app_info, contents) {}
 
   virtual ~TestBookmarkAppHelper() {}
 
   void CreationComplete(const extensions::Extension* extension,
                         const WebApplicationInfo& web_app_info) {
     extension_ = extension;
   }
 
+  void CompleteGetManifest(const content::Manifest& manifest) {
+    BookmarkAppHelper::OnDidGetManifest(manifest);
+  }
+
   void CompleteIconDownload(
       bool success,
       const std::map<GURL, std::vector<SkBitmap> >& bitmaps) {
     BookmarkAppHelper::OnIconsDownloaded(success, bitmaps);
   }
 
   const Extension* extension() { return extension_; }
 
  private:
   const Extension* extension_;
@@ skipping 26 matching lines @@
   EXPECT_EQ(1u, service_->extensions()->size());
   EXPECT_TRUE(extension->from_bookmark());
   EXPECT_EQ(kAppTitle, extension->name());
   EXPECT_EQ(kAppDescription, extension->description());
   EXPECT_EQ(GURL(kAppUrl), AppLaunchInfo::GetLaunchWebURL(extension));
   EXPECT_FALSE(
       IconsInfo::GetIconResource(
           extension, kIconSizeSmall, ExtensionIconSet::MATCH_EXACTLY).empty());
 }
 
+TEST_F(BookmarkAppHelperExtensionServiceTest, CreateBookmarkAppWithManifest) {
+  WebApplicationInfo web_app_info;

[calamity, 2014/10/23 02:46:24]

Maybe also supply a url and name here to ensure they're overwritten by the
manifest. (This is what will happen in the real world, right?)

[benwells, 2014/10/23 03:50:09]

OK, I did this in the UpdateWebAppInfoFromManifest test.

+
+  scoped_ptr<content::WebContents> contents(
+      content::WebContentsTester::CreateTestWebContents(profile_.get(), NULL));
+  TestBookmarkAppHelper helper(service_, web_app_info, contents.get());
+  helper.Create(base::Bind(&TestBookmarkAppHelper::CreationComplete,
+                           base::Unretained(&helper)));
+
+  content::Manifest manifest;
+  manifest.start_url = GURL(kAppUrl);
+  manifest.name = base::NullableString16(base::UTF8ToUTF16(kAppTitle), false);
+  helper.CompleteGetManifest(manifest);
+
+  std::map<GURL, std::vector<SkBitmap> > icon_map;
+  helper.CompleteIconDownload(true, icon_map);
+
+  base::RunLoop().RunUntilIdle();
+  EXPECT_TRUE(helper.extension());
+  const Extension* extension =
+      service_->GetInstalledExtension(helper.extension()->id());
+  EXPECT_TRUE(extension);
+  EXPECT_EQ(1u, service_->extensions()->size());
+  EXPECT_TRUE(extension->from_bookmark());
+  EXPECT_EQ(kAppTitle, extension->name());
+  EXPECT_EQ(GURL(kAppUrl), AppLaunchInfo::GetLaunchWebURL(extension));
+}
+
 TEST_F(BookmarkAppHelperExtensionServiceTest, CreateBookmarkAppNoContents) {
   WebApplicationInfo web_app_info;
   web_app_info.app_url = GURL(kAppUrl);
   web_app_info.title = base::UTF8ToUTF16(kAppTitle);
   web_app_info.description = base::UTF8ToUTF16(kAppDescription);
   web_app_info.icons.push_back(
       CreateIconInfoWithBitmap(kIconSizeTiny, SK_ColorRED));
 
   TestBookmarkAppHelper helper(service_, web_app_info, NULL);
   helper.Create(base::Bind(&TestBookmarkAppHelper::CreationComplete,
@@ skipping 91 matching lines @@
   EXPECT_EQ(1u, registry()->enabled_extensions().size());
   base::RunLoop run_loop;
   extensions::GetWebApplicationInfoFromApp(
       profile_.get(),
       service_->extensions()->begin()->get(),
       base::Bind(
           &ValidateWebApplicationInfo, run_loop.QuitClosure(), web_app_info));
   run_loop.Run();
 }
 
+TEST_F(BookmarkAppHelperTest, UpdateWebAppInfoFromManifest) {
+  WebApplicationInfo web_app_info;
+  content::Manifest manifest;
+  manifest.start_url = GURL(kAppUrl);
+  manifest.short_name = base::NullableString16(base::UTF8ToUTF16(kAppShortName),
+                                               false);
+
+  BookmarkAppHelper::UpdateWebAppInfoFromManifest(manifest, &web_app_info);
+  EXPECT_EQ(base::UTF8ToUTF16(kAppShortName), web_app_info.title);
+  EXPECT_EQ(GURL(kAppUrl), web_app_info.app_url);
+
+  // Test that |manifest.name| takes priority over |manifest.short_name|
+  manifest.name = base::NullableString16(base::UTF8ToUTF16(kAppTitle), false);
+  BookmarkAppHelper::UpdateWebAppInfoFromManifest(manifest, &web_app_info);
+  EXPECT_EQ(base::UTF8ToUTF16(kAppTitle), web_app_info.title);
+}
+
 TEST_F(BookmarkAppHelperTest, ConstrainBitmapsToSizes) {
   std::set<int> desired_sizes;
   desired_sizes.insert(16);
   desired_sizes.insert(32);
   desired_sizes.insert(128);
   desired_sizes.insert(256);
 
   {
     std::vector<SkBitmap> bitmaps;
     bitmaps.push_back(CreateSquareBitmapWithColor(16, SK_ColorRED));
@@ skipping 27 matching lines @@
 }
 
 TEST_F(BookmarkAppHelperTest, IsValidBookmarkAppUrl) {
   EXPECT_TRUE(IsValidBookmarkAppUrl(GURL("https://www.chromium.org")));
   EXPECT_TRUE(IsValidBookmarkAppUrl(GURL("http://www.chromium.org/path")));
   EXPECT_FALSE(IsValidBookmarkAppUrl(GURL("ftp://www.chromium.org")));
   EXPECT_FALSE(IsValidBookmarkAppUrl(GURL("chrome://flags")));
 }
 
 }  // namespace extensions