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