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

chrome/browser/extensions/bookmark_app_helper.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 <cctype>
 
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/crx_installer.h"
@@ skipping 99 matching lines @@
     web_app_info.icons.push_back(icon_info);
   }
   callback.Run(web_app_info);
 }
 
 }  // namespace
 
 namespace extensions {
 
 // static
+void BookmarkAppHelper::UpdateWebAppInfoFromManifest(
+    const content::Manifest& manifest,
+    WebApplicationInfo* web_app_info) {
+  if (!manifest.short_name.is_null())
+    web_app_info->title = manifest.short_name.string();
+
+  // Give the full length name priority.
+  if (!manifest.name.is_null())
+    web_app_info->title = manifest.name.string();
+
+  // Set the url based on the manifest value, if any.
+  if (manifest.start_url.is_valid())
+    web_app_info->app_url = manifest.start_url;
+}
+
+// static
 std::map<int, SkBitmap> BookmarkAppHelper::ConstrainBitmapsToSizes(
     const std::vector<SkBitmap>& bitmaps,
     const std::set<int>& sizes) {
   std::map<int, SkBitmap> output_bitmaps;
   std::map<int, SkBitmap> ordered_bitmaps;
   for (std::vector<SkBitmap>::const_iterator it = bitmaps.begin();
        it != bitmaps.end();
        ++it) {
     DCHECK(it->width() == it->height());
     ordered_bitmaps[it->width()] = *it;
@@ skipping 33 matching lines @@
 
   gfx::ImageSkia icon_image(
       new GeneratedIconImageSource(letter, color, output_size),
       gfx::Size(output_size, output_size));
   icon_image.bitmap()->deepCopyTo(&(*bitmaps)[output_size]);
 }
 
 BookmarkAppHelper::BookmarkAppHelper(ExtensionService* service,
                                      WebApplicationInfo web_app_info,
                                      content::WebContents* contents)
-    : web_app_info_(web_app_info),
+    : contents_(contents),
+      web_app_info_(web_app_info),
       crx_installer_(extensions::CrxInstaller::CreateSilent(service)) {
   registrar_.Add(this,
                  extensions::NOTIFICATION_CRX_INSTALLER_DONE,
                  content::Source<CrxInstaller>(crx_installer_.get()));
 
   registrar_.Add(this,
                  extensions::NOTIFICATION_EXTENSION_INSTALL_ERROR,
                  content::Source<CrxInstaller>(crx_installer_.get()));
 
   crx_installer_->set_error_on_unsupported_requirements(true);
@@ skipping 16 matching lines @@
                             web_app_info_icon_urls,
                             base::Bind(&BookmarkAppHelper::OnIconsDownloaded,
                                        base::Unretained(this))));
 }
 
 BookmarkAppHelper::~BookmarkAppHelper() {}
 
 void BookmarkAppHelper::Create(const CreateBookmarkAppCallback& callback) {
   callback_ = callback;
 
-  if (favicon_downloader_.get())
-    favicon_downloader_->Start();
-  else
+  if (contents_) {
+    contents_->GetManifest(base::Bind(&BookmarkAppHelper::OnDidGetManifest,
+                                     base::Unretained(this)));
+  } else {
     OnIconsDownloaded(true, std::map<GURL, std::vector<SkBitmap> >());
+  }
+}
+
+void BookmarkAppHelper::OnDidGetManifest(const content::Manifest& manifest) {
+  if (contents_->IsBeingDestroyed())
+    return;
+
+  UpdateWebAppInfoFromManifest(manifest, &web_app_info_);
+
+  DCHECK(favicon_downloader_.get());
+  favicon_downloader_->Start();
 }
 
 void BookmarkAppHelper::OnIconsDownloaded(
     bool success,
     const std::map<GURL, std::vector<SkBitmap> >& bitmaps) {
   // The tab has navigated away during the icon download. Cancel the bookmark
   // app creation.
   if (!success) {
     favicon_downloader_.reset();
     callback_.Run(NULL, web_app_info_);
@@ skipping 164 matching lines @@
       extension, info_list, base::Bind(&OnIconsLoaded, web_app_info, callback));
 }
 
 bool IsValidBookmarkAppUrl(const GURL& url) {
   URLPattern origin_only_pattern(Extension::kValidWebExtentSchemes);
   origin_only_pattern.SetMatchAllURLs(true);
   return url.is_valid() && origin_only_pattern.MatchesURL(url);
 }
 
 }  // namespace extensions