Create bookmark apps at the end of the process.

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/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/favicon_downloader.h"
+#include "chrome/browser/extensions/launch_util.h"
 #include "chrome/browser/extensions/tab_helper.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/app_list/app_list_service.h"
+#include "chrome/browser/ui/app_list/app_list_util.h"
+#include "chrome/browser/ui/browser_finder.h"
+#include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/ui/host_desktop.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
+#include "chrome/common/url_constants.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
+#include "extensions/browser/extension_system.h"
 #include "extensions/browser/image_loader.h"
 #include "extensions/browser/notification_types.h"
+#include "extensions/browser/pref_names.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_handlers/icons_handler.h"
 #include "extensions/common/url_pattern.h"
 #include "grit/platform_locale_settings.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "skia/ext/image_operations.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_analysis.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/image/canvas_image_source.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_family.h"
 
+#if defined(OS_MACOSX)
+#include "base/command_line.h"
+#include "chrome/browser/web_applications/web_app_mac.h"
+#include "chrome/common/chrome_switches.h"
+#endif
+
+#if defined(USE_ASH)
+#include "chrome/browser/ui/ash/launcher/chrome_launcher_controller.h"
+#endif
+
 namespace {
 
 // Overlays a shortcut icon over the bottom left corner of a given image.
 class GeneratedIconImageSource : public gfx::CanvasImageSource {
  public:
   explicit GeneratedIconImageSource(char letter, SkColor color, int output_size)
       : gfx::CanvasImageSource(gfx::Size(output_size, output_size), false),
         letter_(letter),
         color_(color),
         output_size_(output_size) {}
@@ skipping 160 matching lines @@
   // Do nothing if there is already an icon of |output_size|.
   if (bitmaps->count(output_size))
     return;
 
   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,
+BookmarkAppHelper::BookmarkAppHelper(Profile* profile,
                                      WebApplicationInfo web_app_info,
                                      content::WebContents* contents)
-    : contents_(contents),
+    : profile_(profile),
+      contents_(contents),
       web_app_info_(web_app_info),
-      crx_installer_(extensions::CrxInstaller::CreateSilent(service)) {
+      crx_installer_(extensions::CrxInstaller::CreateSilent(
+          ExtensionSystem::Get(profile)->extension_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 35 matching lines @@
   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_);
+    callback_.Run(nullptr, web_app_info_);
     return;
   }
 
   std::vector<SkBitmap> downloaded_icons;
   for (FaviconDownloader::FaviconMap::const_iterator map_it = bitmaps.begin();
        map_it != bitmaps.end();
        ++map_it) {
     for (std::vector<SkBitmap>::const_iterator bitmap_it =
              map_it->second.begin();
          bitmap_it != map_it->second.end();
@@ skipping 35 matching lines @@
 
   std::map<int, SkBitmap> generated_icons;
   // Icons are always generated, replacing the icons that were downloaded. This
   // is done so that the icons are consistent across machines.
   // TODO(benwells): Use blob sync once it is available to sync the downloaded
   // icons, and then only generate when there are required sizes missing.
   GenerateIcons(generate_sizes, web_app_info_.app_url,
                 web_app_info_.generated_icon_color, &generated_icons);
 
   ReplaceWebAppIcons(generated_icons, &web_app_info_);
+  favicon_downloader_.reset();
 
-  // Install the app.
-  crx_installer_->InstallWebApp(web_app_info_);
-  favicon_downloader_.reset();
+  if (!contents_) {
+    // The web contents can be null in tests.
+    OnBubbleCompleted(true, web_app_info_);
+    return;
+  }
+
+  Browser* browser = chrome::FindBrowserWithWebContents(contents_);
+  if (!browser) {
+    // The browser can be null in tests.
+    OnBubbleCompleted(true, web_app_info_);
+    return;
+  }
+  browser->window()->ShowBookmarkAppBubble(
+      web_app_info_, base::Bind(&BookmarkAppHelper::OnBubbleCompleted,
+                                base::Unretained(this)));
+}
+
+void BookmarkAppHelper::OnBubbleCompleted(
+    bool user_accepted,
+    const WebApplicationInfo& web_app_info) {
+  if (user_accepted) {
+    web_app_info_ = web_app_info;
+    crx_installer_->InstallWebApp(web_app_info_);
+  } else {
+    callback_.Run(nullptr, web_app_info_);
+  }
+}
+
+void BookmarkAppHelper::FinishInstallation(const Extension* extension) {
+  // Set the default 'open as' preference for use next time the dialog is
+  // shown.
+  extensions::LaunchType launch_type = web_app_info_.open_as_window
+                                           ? extensions::LAUNCH_TYPE_WINDOW
+                                           : extensions::LAUNCH_TYPE_REGULAR;
+  profile_->GetPrefs()->SetInteger(
+      extensions::pref_names::kBookmarkAppCreationLaunchType, launch_type);
+
+  // Set the launcher type for the app.
+  extensions::SetLaunchType(profile_, extension->id(), launch_type);
+
+  if (!contents_) {
+    // The web contents can be null in tests.
+    callback_.Run(extension, web_app_info_);
+    return;
+  }
+
+  Browser* browser = chrome::FindBrowserWithWebContents(contents_);
+  if (!browser) {
+    // The browser can be null in tests.
+    callback_.Run(extension, web_app_info_);
+    return;
+  }
+
+  // Pin the app to the shelf on Ash.
+  chrome::HostDesktopType desktop = browser->host_desktop_type();
+#if defined(USE_ASH)
+  if (desktop == chrome::HOST_DESKTOP_TYPE_ASH)
+    ChromeLauncherController::instance()->PinAppWithID(extension->id());
+#endif
+
+  // Show the newly installed app in the app launcher, in finder (on Mac) or
+  // chrome://apps.
+  Profile* current_profile = profile_->GetOriginalProfile();
+  if (IsAppLauncherEnabled()) {
+    AppListService::Get(desktop)
+        ->ShowForAppInstall(current_profile, extension->id(), false);
+#if defined(OS_MACOSX)
+  } else if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+                 switches::kEnableHostedAppShimCreation)) {
+    web_app::RevealAppShimInFinderForApp(profile_, extension);
+#endif
+  } else {
+    chrome::NavigateParams params(current_profile,
+                                  GURL(chrome::kChromeUIAppsURL),
+                                  ui::PAGE_TRANSITION_LINK);
+    params.disposition = SINGLETON_TAB;
+    chrome::Navigate(&params);
+
+    content::NotificationService::current()->Notify(
+        chrome::NOTIFICATION_APP_INSTALLED_TO_NTP,
+        content::Source<content::WebContents>(params.target_contents),
+        content::Details<const std::string>(&extension->id()));
+  }
+
+  callback_.Run(extension, web_app_info_);
 }
 
 void BookmarkAppHelper::Observe(int type,
                                 const content::NotificationSource& source,
                                 const content::NotificationDetails& details) {
   switch (type) {
     case extensions::NOTIFICATION_CRX_INSTALLER_DONE: {
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
       DCHECK(extension);
       DCHECK_EQ(AppLaunchInfo::GetLaunchWebURL(extension),
                 web_app_info_.app_url);
-      callback_.Run(extension, web_app_info_);
+      FinishInstallation(extension);
       break;
     }
     case extensions::NOTIFICATION_EXTENSION_INSTALL_ERROR:
-      callback_.Run(NULL, web_app_info_);
+      callback_.Run(nullptr, web_app_info_);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 void CreateOrUpdateBookmarkApp(ExtensionService* service,
                                WebApplicationInfo* web_app_info) {
   scoped_refptr<extensions::CrxInstaller> installer(
@@ skipping 42 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