chrome/browser/web_applications/web_app.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/web_applications/web_app.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/command_line.h"
  10 #include "base/files/file_util.h"
  11 #include "base/i18n/file_util_icu.h"
  12 #include "base/prefs/pref_service.h"
  13 #include "base/strings/string_util.h"
  14 #include "base/strings/utf_string_conversions.h"
  15 #include "base/threading/thread.h"
  16 #include "chrome/browser/browser_process.h"
  17 #include "chrome/browser/extensions/extension_ui_util.h"
  18 #include "chrome/browser/profiles/profile.h"
  19 #include "chrome/browser/profiles/profile_manager.h"
  20 #include "chrome/common/chrome_constants.h"
  21 #include "chrome/common/chrome_switches.h"
  22 #include "chrome/common/chrome_version_info.h"
  23 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
  24 #include "chrome/common/pref_names.h"
  25 #include "content/public/browser/browser_thread.h"
  26 #include "extensions/browser/extension_registry.h"
  27 #include "extensions/browser/image_loader.h"
  28 #include "extensions/common/constants.h"
  29 #include "extensions/common/extension.h"
  30 #include "extensions/common/extension_set.h"
  31 #include "extensions/common/manifest_handlers/icons_handler.h"
  32 #include "extensions/grit/extensions_browser_resources.h"
  33 #include "skia/ext/image_operations.h"
  34 #include "third_party/skia/include/core/SkBitmap.h"
  35 #include "ui/base/resource/resource_bundle.h"
  36 #include "ui/gfx/image/image.h"
  37 #include "ui/gfx/image/image_family.h"
  38 #include "ui/gfx/image/image_skia.h"
  39 #include "url/url_constants.h"
  40
  41 #if defined(OS_WIN)
  42 #include "ui/gfx/icon_util.h"
  43 #endif
  44
  45 #if defined(TOOLKIT_VIEWS)
  46 #include "chrome/browser/extensions/tab_helper.h"
  47 #include "chrome/browser/favicon/favicon_tab_helper.h"
  48 #endif
  49
  50 using content::BrowserThread;
  51
  52 namespace {
  53
  54 #if defined(OS_MACOSX)
  55 const int kDesiredSizes[] = {16, 32, 128, 256, 512};
  56 const size_t kNumDesiredSizes = arraysize(kDesiredSizes);
  57 #elif defined(OS_LINUX)
  58 // Linux supports icons of any size. FreeDesktop Icon Theme Specification states
  59 // that "Minimally you should install a 48x48 icon in the hicolor theme."
  60 const int kDesiredSizes[] = {16, 32, 48, 128, 256, 512};
  61 const size_t kNumDesiredSizes = arraysize(kDesiredSizes);
  62 #elif defined(OS_WIN)
  63 const int* kDesiredSizes = IconUtil::kIconDimensions;
  64 const size_t kNumDesiredSizes = IconUtil::kNumIconDimensions;
  65 #else
  66 const int kDesiredSizes[] = {32};
  67 const size_t kNumDesiredSizes = arraysize(kDesiredSizes);
  68 #endif
  69
  70 #if defined(TOOLKIT_VIEWS)
  71 // Predicator for sorting images from largest to smallest.
  72 bool IconPrecedes(const WebApplicationInfo::IconInfo& left,
  73                   const WebApplicationInfo::IconInfo& right) {
  74   return left.width < right.width;
  75 }
  76 #endif
  77
  78 base::FilePath GetShortcutDataDir(const web_app::ShortcutInfo& shortcut_info) {
  79   return web_app::GetWebAppDataDirectory(shortcut_info.profile_path,
  80                                          shortcut_info.extension_id,
  81                                          shortcut_info.url);
  82 }
  83
  84 void UpdateAllShortcutsForShortcutInfo(
  85     const base::string16& old_app_title,
  86     const web_app::ShortcutInfo& shortcut_info,
  87     const extensions::FileHandlersInfo& file_handlers_info) {
  88   BrowserThread::PostTask(
  89       BrowserThread::FILE,
  90       FROM_HERE,
  91       base::Bind(&web_app::internals::UpdatePlatformShortcuts,
  92                  GetShortcutDataDir(shortcut_info),
  93                  old_app_title, shortcut_info, file_handlers_info));
  94 }
  95
  96 void OnImageLoaded(web_app::ShortcutInfo shortcut_info,
  97                    extensions::FileHandlersInfo file_handlers_info,
  98                    web_app::InfoCallback callback,
  99                    const gfx::ImageFamily& image_family) {
 100   // If the image failed to load (e.g. if the resource being loaded was empty)
 101   // use the standard application icon.
 102   if (image_family.empty()) {
 103     gfx::Image default_icon =
 104         ResourceBundle::GetSharedInstance().GetImageNamed(IDR_APP_DEFAULT_ICON);
 105     int size = kDesiredSizes[kNumDesiredSizes - 1];
 106     SkBitmap bmp = skia::ImageOperations::Resize(
 107           *default_icon.ToSkBitmap(), skia::ImageOperations::RESIZE_BEST,
 108           size, size);
 109     gfx::ImageSkia image_skia = gfx::ImageSkia::CreateFrom1xBitmap(bmp);
 110     // We are on the UI thread, and this image is needed from the FILE thread,
 111     // for creating shortcut icon files.
 112     image_skia.MakeThreadSafe();
 113     shortcut_info.favicon.Add(gfx::Image(image_skia));
 114   } else {
 115     shortcut_info.favicon = image_family;
 116   }
 117
 118   callback.Run(shortcut_info, file_handlers_info);
 119 }
 120
 121 void IgnoreFileHandlersInfo(
 122     const web_app::ShortcutInfoCallback& shortcut_info_callback,
 123     const web_app::ShortcutInfo& shortcut_info,
 124     const extensions::FileHandlersInfo& file_handlers_info) {
 125   shortcut_info_callback.Run(shortcut_info);
 126 }
 127
 128 void ScheduleCreatePlatformShortcut(
 129     web_app::ShortcutCreationReason reason,
 130     const web_app::ShortcutLocations& locations,
 131     const web_app::ShortcutInfo& shortcut_info,
 132     const extensions::FileHandlersInfo& file_handlers_info) {
 133   BrowserThread::PostTask(
 134       BrowserThread::FILE, FROM_HERE,
 135       base::Bind(
 136           base::IgnoreResult(&web_app::internals::CreatePlatformShortcuts),
 137           GetShortcutDataDir(shortcut_info), shortcut_info, file_handlers_info,
 138           locations, reason));
 139 }
 140
 141 }  // namespace
 142
 143 namespace web_app {
 144
 145 // The following string is used to build the directory name for
 146 // shortcuts to chrome applications (the kind which are installed
 147 // from a CRX).  Application shortcuts to URLs use the {host}_{path}
 148 // for the name of this directory.  Hosts can't include an underscore.
 149 // By starting this string with an underscore, we ensure that there
 150 // are no naming conflicts.
 151 static const char kCrxAppPrefix[] = "_crx_";
 152
 153 namespace internals {
 154
 155 base::FilePath GetSanitizedFileName(const base::string16& name) {
 156 #if defined(OS_WIN)
 157   base::string16 file_name = name;
 158 #else
 159   std::string file_name = base::UTF16ToUTF8(name);
 160 #endif
 161   base::i18n::ReplaceIllegalCharactersInPath(&file_name, '_');
 162   return base::FilePath(file_name);
 163 }
 164
 165 }  // namespace internals
 166
 167 ShortcutInfo::ShortcutInfo()
 168     : is_platform_app(false) {
 169 }
 170
 171 ShortcutInfo::~ShortcutInfo() {}
 172
 173 ShortcutLocations::ShortcutLocations()
 174     : on_desktop(false),
 175       applications_menu_location(APP_MENU_LOCATION_NONE),
 176       in_quick_launch_bar(false) {
 177 }
 178
 179 #if defined(TOOLKIT_VIEWS)
 180 void GetShortcutInfoForTab(content::WebContents* web_contents,
 181                            ShortcutInfo* info) {
 182   DCHECK(info);  // Must provide a valid info.
 183
 184   const FaviconTabHelper* favicon_tab_helper =
 185       FaviconTabHelper::FromWebContents(web_contents);
 186   const extensions::TabHelper* extensions_tab_helper =
 187       extensions::TabHelper::FromWebContents(web_contents);
 188   const WebApplicationInfo& app_info = extensions_tab_helper->web_app_info();
 189
 190   info->url = app_info.app_url.is_empty() ? web_contents->GetURL() :
 191                                             app_info.app_url;
 192   info->title = app_info.title.empty() ?
 193       (web_contents->GetTitle().empty() ? base::UTF8ToUTF16(info->url.spec()) :
 194                                           web_contents->GetTitle()) :
 195       app_info.title;
 196   info->description = app_info.description;
 197   info->favicon.Add(favicon_tab_helper->GetFavicon());
 198
 199   Profile* profile =
 200       Profile::FromBrowserContext(web_contents->GetBrowserContext());
 201   info->profile_path = profile->GetPath();
 202 }
 203 #endif
 204
 205 #if !defined(OS_WIN)
 206 void UpdateShortcutForTabContents(content::WebContents* web_contents) {}
 207 #endif
 208
 209 ShortcutInfo ShortcutInfoForExtensionAndProfile(
 210     const extensions::Extension* app, Profile* profile) {
 211   ShortcutInfo shortcut_info;
 212   shortcut_info.extension_id = app->id();
 213   shortcut_info.is_platform_app = app->is_platform_app();
 214   shortcut_info.url = extensions::AppLaunchInfo::GetLaunchWebURL(app);
 215   shortcut_info.title = base::UTF8ToUTF16(app->name());
 216   shortcut_info.description = base::UTF8ToUTF16(app->description());
 217   shortcut_info.extension_path = app->path();
 218   shortcut_info.profile_path = profile->GetPath();
 219   shortcut_info.profile_name =
 220       profile->GetPrefs()->GetString(prefs::kProfileName);
 221   shortcut_info.version_for_display = app->GetVersionForDisplay();
 222   return shortcut_info;
 223 }
 224
 225 void GetInfoForApp(const extensions::Extension* extension,
 226                    Profile* profile,
 227                    const InfoCallback& callback) {
 228   web_app::ShortcutInfo shortcut_info =
 229       web_app::ShortcutInfoForExtensionAndProfile(extension, profile);
 230   const std::vector<extensions::FileHandlerInfo>* file_handlers =
 231       extensions::FileHandlers::GetFileHandlers(extension);
 232   extensions::FileHandlersInfo file_handlers_info =
 233       file_handlers ? *file_handlers : extensions::FileHandlersInfo();
 234
 235   std::vector<extensions::ImageLoader::ImageRepresentation> info_list;
 236   for (size_t i = 0; i < kNumDesiredSizes; ++i) {
 237     int size = kDesiredSizes[i];
 238     extensions::ExtensionResource resource =
 239         extensions::IconsInfo::GetIconResource(
 240             extension, size, ExtensionIconSet::MATCH_EXACTLY);
 241     if (!resource.empty()) {
 242       info_list.push_back(extensions::ImageLoader::ImageRepresentation(
 243           resource,
 244           extensions::ImageLoader::ImageRepresentation::ALWAYS_RESIZE,
 245           gfx::Size(size, size),
 246           ui::SCALE_FACTOR_100P));
 247     }
 248   }
 249
 250   if (info_list.empty()) {
 251     size_t i = kNumDesiredSizes - 1;
 252     int size = kDesiredSizes[i];
 253
 254     // If there is no icon at the desired sizes, we will resize what we can get.
 255     // Making a large icon smaller is preferred to making a small icon larger,
 256     // so look for a larger icon first:
 257     extensions::ExtensionResource resource =
 258         extensions::IconsInfo::GetIconResource(
 259             extension, size, ExtensionIconSet::MATCH_BIGGER);
 260     if (resource.empty()) {
 261       resource = extensions::IconsInfo::GetIconResource(
 262           extension, size, ExtensionIconSet::MATCH_SMALLER);
 263     }
 264     info_list.push_back(extensions::ImageLoader::ImageRepresentation(
 265         resource,
 266         extensions::ImageLoader::ImageRepresentation::ALWAYS_RESIZE,
 267         gfx::Size(size, size),
 268         ui::SCALE_FACTOR_100P));
 269   }
 270
 271   // |info_list| may still be empty at this point, in which case
 272   // LoadImageFamilyAsync will call the OnImageLoaded callback with an empty
 273   // image and exit immediately.
 274   extensions::ImageLoader::Get(profile)->LoadImageFamilyAsync(
 275       extension,
 276       info_list,
 277       base::Bind(&OnImageLoaded, shortcut_info, file_handlers_info, callback));
 278 }
 279
 280 void GetShortcutInfoForApp(const extensions::Extension* extension,
 281                            Profile* profile,
 282                            const ShortcutInfoCallback& callback) {
 283   GetInfoForApp(
 284       extension, profile, base::Bind(&IgnoreFileHandlersInfo, callback));
 285 }
 286
 287 bool ShouldCreateShortcutFor(web_app::ShortcutCreationReason reason,
 288                              Profile* profile,
 289                              const extensions::Extension* extension) {
 290   // Shortcuts should never be created for component apps, or for apps that
 291   // cannot be shown in the launcher.
 292   if (extension->location() == extensions::Manifest::COMPONENT ||
 293       !extensions::ui_util::CanDisplayInAppLauncher(extension, profile)) {
 294     return false;
 295   }
 296
 297   // Otherwise, always create shortcuts for v2 packaged apps.
 298   if (extension->is_platform_app())
 299     return true;
 300
 301 #if defined(OS_MACOSX)
 302   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
 303           switches::kDisableHostedAppShimCreation)) {
 304     return extension->is_hosted_app();
 305   }
 306
 307   return false;
 308 #else
 309   // For other platforms, allow shortcut creation if it was explicitly
 310   // requested by the user (i.e. is not automatic).
 311   return reason == SHORTCUT_CREATION_BY_USER;
 312 #endif
 313 }
 314
 315 base::FilePath GetWebAppDataDirectory(const base::FilePath& profile_path,
 316                                       const std::string& extension_id,
 317                                       const GURL& url) {
 318   DCHECK(!profile_path.empty());
 319   base::FilePath app_data_dir(profile_path.Append(chrome::kWebAppDirname));
 320
 321   if (!extension_id.empty()) {
 322     return app_data_dir.AppendASCII(
 323         GenerateApplicationNameFromExtensionId(extension_id));
 324   }
 325
 326   std::string host(url.host());
 327   std::string scheme(url.has_scheme() ? url.scheme() : "http");
 328   std::string port(url.has_port() ? url.port() : "80");
 329   std::string scheme_port(scheme + "_" + port);
 330
 331 #if defined(OS_WIN)
 332   base::FilePath::StringType host_path(base::UTF8ToUTF16(host));
 333   base::FilePath::StringType scheme_port_path(base::UTF8ToUTF16(scheme_port));
 334 #elif defined(OS_POSIX)
 335   base::FilePath::StringType host_path(host);
 336   base::FilePath::StringType scheme_port_path(scheme_port);
 337 #endif
 338
 339   return app_data_dir.Append(host_path).Append(scheme_port_path);
 340 }
 341
 342 base::FilePath GetWebAppDataDirectory(const base::FilePath& profile_path,
 343                                       const extensions::Extension& extension) {
 344   return GetWebAppDataDirectory(
 345       profile_path,
 346       extension.id(),
 347       GURL(extensions::AppLaunchInfo::GetLaunchWebURL(&extension)));
 348 }
 349
 350 std::string GenerateApplicationNameFromInfo(const ShortcutInfo& shortcut_info) {
 351   if (!shortcut_info.extension_id.empty())
 352     return GenerateApplicationNameFromExtensionId(shortcut_info.extension_id);
 353   else
 354     return GenerateApplicationNameFromURL(shortcut_info.url);
 355 }
 356
 357 std::string GenerateApplicationNameFromURL(const GURL& url) {
 358   std::string t;
 359   t.append(url.host());
 360   t.append("_");
 361   t.append(url.path());
 362   return t;
 363 }
 364
 365 std::string GenerateApplicationNameFromExtensionId(const std::string& id) {
 366   std::string t(kCrxAppPrefix);
 367   t.append(id);
 368   return t;
 369 }
 370
 371 std::string GetExtensionIdFromApplicationName(const std::string& app_name) {
 372   std::string prefix(kCrxAppPrefix);
 373   if (app_name.substr(0, prefix.length()) != prefix)
 374     return std::string();
 375   return app_name.substr(prefix.length());
 376 }
 377
 378 void CreateShortcutsWithInfo(
 379     ShortcutCreationReason reason,
 380     const ShortcutLocations& locations,
 381     const ShortcutInfo& shortcut_info,
 382     const extensions::FileHandlersInfo& file_handlers_info) {
 383   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 384
 385   // If the shortcut is for an application shortcut with the new bookmark app
 386   // flow disabled, there will be no corresponding extension.
 387   if (!shortcut_info.extension_id.empty()) {
 388     // It's possible for the extension to be deleted before we get here.
 389     // For example, creating a hosted app from a website. Double check that
 390     // it still exists.
 391     Profile* profile = g_browser_process->profile_manager()->GetProfileByPath(
 392         shortcut_info.profile_path);
 393     if (!profile)
 394       return;
 395
 396     extensions::ExtensionRegistry* registry =
 397         extensions::ExtensionRegistry::Get(profile);
 398     const extensions::Extension* extension = registry->GetExtensionById(
 399         shortcut_info.extension_id, extensions::ExtensionRegistry::EVERYTHING);
 400     if (!extension)
 401       return;
 402   }
 403
 404   ScheduleCreatePlatformShortcut(reason, locations, shortcut_info,
 405                                  file_handlers_info);
 406 }
 407
 408 void CreateNonAppShortcut(const ShortcutLocations& locations,
 409                           const ShortcutInfo& shortcut_info) {
 410   ScheduleCreatePlatformShortcut(SHORTCUT_CREATION_AUTOMATED, locations,
 411                                  shortcut_info, extensions::FileHandlersInfo());
 412 }
 413
 414 void CreateShortcuts(ShortcutCreationReason reason,
 415                      const ShortcutLocations& locations,
 416                      Profile* profile,
 417                      const extensions::Extension* app) {
 418   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 419
 420   if (!ShouldCreateShortcutFor(reason, profile, app))
 421     return;
 422
 423   GetInfoForApp(
 424       app, profile, base::Bind(&CreateShortcutsWithInfo, reason, locations));
 425 }
 426
 427 void DeleteAllShortcuts(Profile* profile, const extensions::Extension* app) {
 428   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 429
 430   ShortcutInfo shortcut_info =
 431       ShortcutInfoForExtensionAndProfile(app, profile);
 432   BrowserThread::PostTask(
 433       BrowserThread::FILE,
 434       FROM_HERE,
 435       base::Bind(&web_app::internals::DeletePlatformShortcuts,
 436                  GetShortcutDataDir(shortcut_info), shortcut_info));
 437 }
 438
 439 void UpdateAllShortcuts(const base::string16& old_app_title,
 440                         Profile* profile,
 441                         const extensions::Extension* app) {
 442   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 443
 444   GetInfoForApp(app,
 445                 profile,
 446                 base::Bind(&UpdateAllShortcutsForShortcutInfo, old_app_title));
 447 }
 448
 449 bool IsValidUrl(const GURL& url) {
 450   static const char* const kValidUrlSchemes[] = {
 451       url::kFileScheme,
 452       url::kFileSystemScheme,
 453       url::kFtpScheme,
 454       url::kHttpScheme,
 455       url::kHttpsScheme,
 456       extensions::kExtensionScheme,
 457   };
 458
 459   for (size_t i = 0; i < arraysize(kValidUrlSchemes); ++i) {
 460     if (url.SchemeIs(kValidUrlSchemes[i]))
 461       return true;
 462   }
 463
 464   return false;
 465 }
 466
 467 #if defined(TOOLKIT_VIEWS)
 468 void GetIconsInfo(const WebApplicationInfo& app_info,
 469                   IconInfoList* icons) {
 470   DCHECK(icons);
 471
 472   icons->clear();
 473   for (size_t i = 0; i < app_info.icons.size(); ++i) {
 474     // We only take square shaped icons (i.e. width == height).
 475     if (app_info.icons[i].width == app_info.icons[i].height) {
 476       icons->push_back(app_info.icons[i]);
 477     }
 478   }
 479
 480   std::sort(icons->begin(), icons->end(), &IconPrecedes);
 481 }
 482 #endif
 483
 484 #if defined(OS_LINUX)
 485 std::string GetWMClassFromAppName(std::string app_name) {
 486   base::i18n::ReplaceIllegalCharactersInPath(&app_name, '_');
 487   base::TrimString(app_name, "_", &app_name);
 488   return app_name;
 489 }
 490 #endif
 491
 492 }  // namespace web_app