Home | History | Annotate | Download | only in manifest_handlers 
      1 // Copyright 2013 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/common/extensions/manifest_handlers/app_launch_info.h"
      6 
      7 #include "base/command_line.h"
      8 #include "base/lazy_instance.h"
      9 #include "base/memory/scoped_ptr.h"
     10 #include "base/strings/utf_string_conversions.h"
     11 #include "base/values.h"
     12 #include "chrome/common/chrome_switches.h"
     13 #include "chrome/common/extensions/extension_constants.h"
     14 #include "chrome/common/url_constants.h"
     15 #include "components/cloud_devices/common/cloud_devices_urls.h"
     16 #include "extensions/common/error_utils.h"
     17 #include "extensions/common/manifest_constants.h"
     18 
     19 namespace extensions {
     20 
     21 namespace keys = manifest_keys;
     22 namespace values = manifest_values;
     23 namespace errors = manifest_errors;
     24 
     25 namespace {
     26 
     27 bool ReadLaunchDimension(const extensions::Manifest* manifest,
     28                          const char* key,
     29                          int* target,
     30                          bool is_valid_container,
     31                          base::string16* error) {
     32   const base::Value* temp = NULL;
     33   if (manifest->Get(key, &temp)) {
     34     if (!is_valid_container) {
     35       *error = ErrorUtils::FormatErrorMessageUTF16(
     36           errors::kInvalidLaunchValueContainer,
     37           key);
     38       return false;
     39     }
     40     if (!temp->GetAsInteger(target) || *target < 0) {
     41       *target = 0;
     42       *error = ErrorUtils::FormatErrorMessageUTF16(
     43           errors::kInvalidLaunchValue,
     44           key);
     45       return false;
     46     }
     47   }
     48   return true;
     49 }
     50 
     51 static base::LazyInstance<AppLaunchInfo> g_empty_app_launch_info =
     52     LAZY_INSTANCE_INITIALIZER;
     53 
     54 const AppLaunchInfo& GetAppLaunchInfo(const Extension* extension) {
     55   AppLaunchInfo* info = static_cast<AppLaunchInfo*>(
     56       extension->GetManifestData(keys::kLaunch));
     57   return info ? *info : g_empty_app_launch_info.Get();
     58 }
     59 
     60 }  // namespace
     61 
     62 AppLaunchInfo::AppLaunchInfo()
     63     : launch_container_(LAUNCH_CONTAINER_TAB),
     64       launch_width_(0),
     65       launch_height_(0) {
     66 }
     67 
     68 AppLaunchInfo::~AppLaunchInfo() {
     69 }
     70 
     71 // static
     72 const std::string& AppLaunchInfo::GetLaunchLocalPath(
     73     const Extension* extension) {
     74   return GetAppLaunchInfo(extension).launch_local_path_;
     75 }
     76 
     77 // static
     78 const GURL& AppLaunchInfo::GetLaunchWebURL(
     79     const Extension* extension) {
     80   return GetAppLaunchInfo(extension).launch_web_url_;
     81 }
     82 
     83 // static
     84 extensions::LaunchContainer AppLaunchInfo::GetLaunchContainer(
     85     const Extension* extension) {
     86   return GetAppLaunchInfo(extension).launch_container_;
     87 }
     88 
     89 // static
     90 int AppLaunchInfo::GetLaunchWidth(const Extension* extension) {
     91   return GetAppLaunchInfo(extension).launch_width_;
     92 }
     93 
     94 // static
     95 int AppLaunchInfo::GetLaunchHeight(const Extension* extension) {
     96   return GetAppLaunchInfo(extension).launch_height_;
     97 }
     98 
     99 // static
    100 GURL AppLaunchInfo::GetFullLaunchURL(const Extension* extension) {
    101   const AppLaunchInfo& info = GetAppLaunchInfo(extension);
    102   if (info.launch_local_path_.empty())
    103     return info.launch_web_url_;
    104   else
    105     return extension->url().Resolve(info.launch_local_path_);
    106 }
    107 
    108 bool AppLaunchInfo::Parse(Extension* extension, base::string16* error) {
    109   if (!LoadLaunchURL(extension, error) ||
    110       !LoadLaunchContainer(extension, error))
    111     return false;
    112   return true;
    113 }
    114 
    115 bool AppLaunchInfo::LoadLaunchURL(Extension* extension, base::string16* error) {
    116   const base::Value* temp = NULL;
    117 
    118   // Launch URL can be either local (to chrome-extension:// root) or an absolute
    119   // web URL.
    120   if (extension->manifest()->Get(keys::kLaunchLocalPath, &temp)) {
    121     if (extension->manifest()->Get(keys::kLaunchWebURL, NULL)) {
    122       *error = base::ASCIIToUTF16(errors::kLaunchPathAndURLAreExclusive);
    123       return false;
    124     }
    125 
    126     if (extension->manifest()->Get(keys::kWebURLs, NULL)) {
    127       *error = base::ASCIIToUTF16(errors::kLaunchPathAndExtentAreExclusive);
    128       return false;
    129     }
    130 
    131     std::string launch_path;
    132     if (!temp->GetAsString(&launch_path)) {
    133       *error = ErrorUtils::FormatErrorMessageUTF16(
    134           errors::kInvalidLaunchValue,
    135           keys::kLaunchLocalPath);
    136       return false;
    137     }
    138 
    139     // Ensure the launch path is a valid relative URL.
    140     GURL resolved = extension->url().Resolve(launch_path);
    141     if (!resolved.is_valid() || resolved.GetOrigin() != extension->url()) {
    142       *error = ErrorUtils::FormatErrorMessageUTF16(
    143           errors::kInvalidLaunchValue,
    144           keys::kLaunchLocalPath);
    145       return false;
    146     }
    147 
    148     launch_local_path_ = launch_path;
    149   } else if (extension->manifest()->Get(keys::kLaunchWebURL, &temp)) {
    150     std::string launch_url;
    151     if (!temp->GetAsString(&launch_url)) {
    152       *error = ErrorUtils::FormatErrorMessageUTF16(
    153           errors::kInvalidLaunchValue,
    154           keys::kLaunchWebURL);
    155       return false;
    156     }
    157 
    158     // Ensure the launch web URL is a valid absolute URL and web extent scheme.
    159     GURL url(launch_url);
    160     URLPattern pattern(Extension::kValidWebExtentSchemes);
    161     if (!url.is_valid() || !pattern.SetScheme(url.scheme())) {
    162       *error = ErrorUtils::FormatErrorMessageUTF16(
    163           errors::kInvalidLaunchValue,
    164           keys::kLaunchWebURL);
    165       return false;
    166     }
    167 
    168     launch_web_url_ = url;
    169   } else if (extension->is_legacy_packaged_app()) {
    170     *error = base::ASCIIToUTF16(errors::kLaunchURLRequired);
    171     return false;
    172   }
    173 
    174   // For the Chrome component app, override launch url to new tab.
    175   if (extension->id() == extension_misc::kChromeAppId) {
    176     launch_web_url_ = GURL(chrome::kChromeUINewTabURL);
    177     return true;
    178   }
    179 
    180   // If there is no extent, we default the extent based on the launch URL.
    181   if (extension->web_extent().is_empty() && !launch_web_url_.is_empty()) {
    182     URLPattern pattern(Extension::kValidWebExtentSchemes);
    183     if (!pattern.SetScheme("*")) {
    184       *error = ErrorUtils::FormatErrorMessageUTF16(
    185           errors::kInvalidLaunchValue,
    186           keys::kLaunchWebURL);
    187       return false;
    188     }
    189     pattern.SetHost(launch_web_url_.host());
    190     pattern.SetPath("/*");
    191     extension->AddWebExtentPattern(pattern);
    192   }
    193 
    194   // In order for the --apps-gallery-url switch to work with the gallery
    195   // process isolation, we must insert any provided value into the component
    196   // app's launch url and web extent.
    197   if (extension->id() == extension_misc::kWebStoreAppId) {
    198     std::string gallery_url_str = CommandLine::ForCurrentProcess()->
    199         GetSwitchValueASCII(switches::kAppsGalleryURL);
    200 
    201     // Empty string means option was not used.
    202     if (!gallery_url_str.empty()) {
    203       GURL gallery_url(gallery_url_str);
    204       OverrideLaunchURL(extension, gallery_url);
    205     }
    206   } else if (extension->id() == extension_misc::kCloudPrintAppId) {
    207     // In order for the --cloud-print-service switch to work, we must update
    208     // the launch URL and web extent.
    209     GURL url =
    210         cloud_devices::GetCloudPrintRelativeURL("enable_chrome_connector");
    211     if (!url.is_empty()) {
    212       OverrideLaunchURL(extension, url);
    213     }
    214   }
    215 
    216   return true;
    217 }
    218 
    219 bool AppLaunchInfo::LoadLaunchContainer(Extension* extension,
    220                                         base::string16* error) {
    221   const base::Value* tmp_launcher_container = NULL;
    222   if (!extension->manifest()->Get(keys::kLaunchContainer,
    223                                   &tmp_launcher_container))
    224     return true;
    225 
    226   std::string launch_container_string;
    227   if (!tmp_launcher_container->GetAsString(&launch_container_string)) {
    228     *error = base::ASCIIToUTF16(errors::kInvalidLaunchContainer);
    229     return false;
    230   }
    231 
    232   if (launch_container_string == values::kLaunchContainerPanel) {
    233     launch_container_ = LAUNCH_CONTAINER_PANEL;
    234   } else if (launch_container_string == values::kLaunchContainerTab) {
    235     launch_container_ = LAUNCH_CONTAINER_TAB;
    236   } else {
    237     *error = base::ASCIIToUTF16(errors::kInvalidLaunchContainer);
    238     return false;
    239   }
    240 
    241   bool can_specify_initial_size = launch_container_ == LAUNCH_CONTAINER_PANEL;
    242 
    243   // Validate the container width if present.
    244   if (!ReadLaunchDimension(extension->manifest(),
    245                            keys::kLaunchWidth,
    246                            &launch_width_,
    247                            can_specify_initial_size,
    248                            error)) {
    249     return false;
    250   }
    251 
    252   // Validate container height if present.
    253   if (!ReadLaunchDimension(extension->manifest(),
    254                            keys::kLaunchHeight,
    255                            &launch_height_,
    256                            can_specify_initial_size,
    257                            error)) {
    258     return false;
    259   }
    260 
    261   return true;
    262 }
    263 
    264 void AppLaunchInfo::OverrideLaunchURL(Extension* extension,
    265                                       GURL override_url) {
    266   if (!override_url.is_valid()) {
    267     DLOG(WARNING) << "Invalid override url given for " << extension->name();
    268     return;
    269   }
    270   if (override_url.has_port()) {
    271     DLOG(WARNING) << "Override URL passed for " << extension->name()
    272                   << " should not contain a port.  Removing it.";
    273 
    274     GURL::Replacements remove_port;
    275     remove_port.ClearPort();
    276     override_url = override_url.ReplaceComponents(remove_port);
    277   }
    278 
    279   launch_web_url_ = override_url;
    280 
    281   URLPattern pattern(Extension::kValidWebExtentSchemes);
    282   URLPattern::ParseResult result = pattern.Parse(override_url.spec());
    283   DCHECK_EQ(result, URLPattern::PARSE_SUCCESS);
    284   pattern.SetPath(pattern.path() + '*');
    285   extension->AddWebExtentPattern(pattern);
    286 }
    287 
    288 AppLaunchManifestHandler::AppLaunchManifestHandler() {
    289 }
    290 
    291 AppLaunchManifestHandler::~AppLaunchManifestHandler() {
    292 }
    293 
    294 bool AppLaunchManifestHandler::Parse(Extension* extension,
    295                                      base::string16* error) {
    296   scoped_ptr<AppLaunchInfo> info(new AppLaunchInfo);
    297   if (!info->Parse(extension, error))
    298     return false;
    299   extension->SetManifestData(keys::kLaunch, info.release());
    300   return true;
    301 }
    302 
    303 bool AppLaunchManifestHandler::AlwaysParseForType(Manifest::Type type) const {
    304   return type == Manifest::TYPE_LEGACY_PACKAGED_APP;
    305 }
    306 
    307 const std::vector<std::string> AppLaunchManifestHandler::Keys() const {
    308   static const char* keys[] = {
    309     keys::kLaunchLocalPath,
    310     keys::kLaunchWebURL,
    311     keys::kLaunchContainer,
    312     keys::kLaunchHeight,
    313     keys::kLaunchWidth
    314   };
    315   return std::vector<std::string>(keys, keys + arraysize(keys));
    316 }
    317 
    318 }  // namespace extensions
    319