src/xwalk/application/common/application_data.cc

   1 // Copyright (c) 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 "xwalk/application/common/application_data.h"
   6
   7 #include "base/base64.h"
   8 #include "base/basictypes.h"
   9 #include "base/command_line.h"
  10 #include "base/file_util.h"
  11 #include "base/files/file_path.h"
  12 #include "base/i18n/rtl.h"
  13 #include "base/logging.h"
  14 #include "base/memory/singleton.h"
  15 #include "base/stl_util.h"
  16 #include "base/strings/string16.h"
  17 #include "base/strings/string_util.h"
  18 #include "base/strings/stringprintf.h"
  19 #include "base/strings/string_number_conversions.h"
  20 #include "base/strings/string_piece.h"
  21 #include "base/strings/utf_string_conversions.h"
  22 #include "base/values.h"
  23 #include "base/version.h"
  24 #include "xwalk/application/common/application_manifest_constants.h"
  25 #include "xwalk/application/common/id_util.h"
  26 #include "xwalk/application/common/constants.h"
  27 #include "xwalk/application/common/manifest.h"
  28 #include "xwalk/application/common/manifest_handler.h"
  29 #include "xwalk/application/common/manifest_handlers/permissions_handler.h"
  30 #include "xwalk/application/common/manifest_handlers/widget_handler.h"
  31 #include "xwalk/application/common/manifest_handlers/tizen_application_handler.h"
  32 #include "xwalk/application/common/permission_policy_manager.h"
  33 #include "content/public/common/url_constants.h"
  34 #include "url/url_util.h"
  35 #include "ui/base/l10n/l10n_util.h"
  36
  37 namespace keys = xwalk::application_manifest_keys;
  38 namespace widget_keys = xwalk::application_widget_keys;
  39 namespace errors = xwalk::application_manifest_errors;
  40
  41 namespace xwalk {
  42 namespace application {
  43
  44 // static
  45 scoped_refptr<ApplicationData> ApplicationData::Create(
  46     const base::FilePath& path, const std::string& explicit_id,
  47     SourceType source_type, scoped_ptr<Manifest> manifest,
  48     std::string* error_message) {
  49   DCHECK(error_message);
  50   base::string16 error;
  51   if (!manifest->ValidateManifest(error_message))
  52     return NULL;
  53
  54   scoped_refptr<ApplicationData> app_data =
  55       new ApplicationData(path, source_type, manifest.Pass());
  56   if (!app_data->Init(explicit_id, &error)) {
  57     *error_message = base::UTF16ToUTF8(error);
  58     return NULL;
  59   }
  60
  61   ManifestHandlerRegistry* registry =
  62       ManifestHandlerRegistry::GetInstance(app_data->manifest_type());
  63
  64   if (!registry->ValidateAppManifest(app_data, error_message))
  65     return NULL;
  66
  67   return app_data;
  68 }
  69
  70 // static
  71 GURL ApplicationData::GetBaseURLFromApplicationId(
  72     const std::string& application_id) {
  73   return GURL(std::string(kApplicationScheme) +
  74       url::kStandardSchemeSeparator + application_id + "/");
  75 }
  76
  77 ApplicationData::ManifestData* ApplicationData::GetManifestData(
  78         const std::string& key) const {
  79   DCHECK(finished_parsing_manifest_ || thread_checker_.CalledOnValidThread());
  80   ManifestDataMap::const_iterator iter = manifest_data_.find(key);
  81   if (iter != manifest_data_.end())
  82     return iter->second.get();
  83   return NULL;
  84 }
  85
  86 void ApplicationData::SetManifestData(const std::string& key,
  87                                       ApplicationData::ManifestData* data) {
  88   DCHECK(!finished_parsing_manifest_ && thread_checker_.CalledOnValidThread());
  89   manifest_data_[key] = linked_ptr<ManifestData>(data);
  90 }
  91
  92 #if defined(OS_TIZEN)
  93 std::string ApplicationData::GetPackageID() const {
  94   return AppIdToPkgId(application_id_);
  95 }
  96 #endif
  97
  98 const std::string ApplicationData::VersionString() const {
  99   if (!version_->components().empty())
 100     return Version()->GetString();
 101
 102   return "";
 103 }
 104
 105 bool ApplicationData::IsHostedApp() const {
 106   bool hosted = source_type_ == EXTERNAL_URL;
 107 #if defined(OS_TIZEN)
 108   if (manifest_->HasPath(widget_keys::kContentNamespace)) {
 109     std::string ns;
 110     if (manifest_->GetString(widget_keys::kContentNamespace, &ns) &&
 111         ns == kTizenNamespacePrefix)
 112       hosted = true;
 113   }
 114 #endif
 115   return hosted;
 116 }
 117
 118 ApplicationData::ApplicationData(const base::FilePath& path,
 119   SourceType source_type, scoped_ptr<Manifest> manifest)
 120     : manifest_version_(0),
 121       path_(path),
 122       manifest_(manifest.release()),
 123       finished_parsing_manifest_(false),
 124       source_type_(source_type) {
 125   DCHECK(path_.empty() || path_.IsAbsolute());
 126 }
 127
 128 ApplicationData::~ApplicationData() {
 129 }
 130
 131 // static
 132 GURL ApplicationData::GetResourceURL(const GURL& application_url,
 133                                const std::string& relative_path) {
 134   DCHECK(application_url.SchemeIs(kApplicationScheme));
 135   DCHECK_EQ("/", application_url.path());
 136
 137   std::string path = relative_path;
 138
 139   // If the relative path starts with "/", it is "absolute" relative to the
 140   // application base directory, but application_url is already specified to
 141   // refer to that base directory, so strip the leading "/" if present.
 142   if (relative_path.size() > 0 && relative_path[0] == '/')
 143     path = relative_path.substr(1);
 144
 145   GURL ret_val = GURL(application_url.spec() + path);
 146   DCHECK(StartsWithASCII(ret_val.spec(), application_url.spec(), false));
 147
 148   return ret_val;
 149 }
 150
 151 GURL ApplicationData::GetResourceURL(const std::string& relative_path) const {
 152   if (!base::PathExists(path_.Append(relative_path))) {
 153     LOG(ERROR) << "The path does not exist in the application directory: "
 154                << relative_path;
 155     return GURL();
 156   }
 157
 158   return GetResourceURL(URL(), relative_path);
 159 }
 160
 161 bool ApplicationData::Init(const std::string& explicit_id,
 162                            base::string16* error) {
 163   DCHECK(error);
 164   ManifestHandlerRegistry* registry =
 165       ManifestHandlerRegistry::GetInstance(manifest_type());
 166   if (!registry->ParseAppManifest(this, error))
 167     return false;
 168
 169   if (!LoadID(explicit_id, error))
 170     return false;
 171   if (!LoadName(error))
 172     return false;
 173   if (!LoadVersion(error))
 174     return false;
 175   if (!LoadDescription(error))
 176     return false;
 177
 178   application_url_ = ApplicationData::GetBaseURLFromApplicationId(ID());
 179
 180   finished_parsing_manifest_ = true;
 181   return true;
 182 }
 183
 184 bool ApplicationData::LoadID(const std::string& explicit_id,
 185                              base::string16* error) {
 186   std::string application_id;
 187 #if defined(OS_TIZEN)
 188   if (manifest_type() == Manifest::TYPE_WIDGET) {
 189     const TizenApplicationInfo* tizen_app_info =
 190         static_cast<TizenApplicationInfo*>(GetManifestData(
 191             widget_keys::kTizenApplicationKey));
 192     CHECK(tizen_app_info);
 193     application_id = tizen_app_info->id();
 194   } else if (manifest_->HasKey(keys::kTizenAppIdKey)) {
 195     if (!manifest_->GetString(keys::kTizenAppIdKey, &application_id)) {
 196       NOTREACHED() << "Could not get Tizen application key";
 197       return false;
 198     }
 199   }
 200
 201   if (!application_id.empty()) {
 202     application_id_ = application_id;
 203     return true;
 204   }
 205 #endif
 206
 207   if (!explicit_id.empty()) {
 208     application_id_ = explicit_id;
 209     return true;
 210   }
 211
 212   application_id = GenerateIdForPath(path_);
 213   if (application_id.empty()) {
 214     NOTREACHED() << "Could not create ID from path.";
 215     return false;
 216   }
 217   application_id_ = application_id;
 218   return true;
 219 }
 220
 221 bool ApplicationData::LoadName(base::string16* error) {
 222   DCHECK(error);
 223   base::string16 localized_name;
 224   std::string name_key(GetNameKey(manifest_type()));
 225
 226   if (!manifest_->GetString(name_key, &localized_name) &&
 227       manifest_type() == Manifest::TYPE_MANIFEST) {
 228     *error = base::ASCIIToUTF16(errors::kInvalidName);
 229     return false;
 230   }
 231   non_localized_name_ = base::UTF16ToUTF8(localized_name);
 232   base::i18n::AdjustStringForLocaleDirection(&localized_name);
 233   name_ = base::UTF16ToUTF8(localized_name);
 234   return true;
 235 }
 236
 237 bool ApplicationData::LoadVersion(base::string16* error) {
 238   DCHECK(error);
 239   std::string version_str;
 240
 241   version_.reset(new base::Version());
 242
 243   if (manifest_type() == Manifest::TYPE_WIDGET) {
 244     bool ok = manifest_->GetString(widget_keys::kVersionKey, &version_str);
 245     if (!ok) {
 246       *error = base::ASCIIToUTF16(errors::kInvalidVersion);
 247       return true;
 248     }
 249
 250     version_.reset(new base::Version(version_str));
 251     return true;
 252   }
 253
 254   // W3C Manifest (XPK and hosted):
 255
 256   bool hasDeprecatedKey = manifest_->HasKey(keys::kDeprecatedVersionKey);
 257   bool hasKey = manifest_->HasKey(keys::kXWalkVersionKey);
 258
 259   if (!hasKey && !hasDeprecatedKey) {
 260     // xwalk_version is optional.
 261     return true;
 262   }
 263
 264   bool ok = false;
 265   if (hasKey) {
 266     if (hasDeprecatedKey) {
 267       LOG(WARNING) << "Deprecated key '" << keys::kDeprecatedVersionKey
 268           << "' found in addition to '" << keys::kXWalkVersionKey
 269           << "'. Consider removing.";
 270     }
 271     ok = manifest_->GetString(keys::kXWalkVersionKey, &version_str);
 272   }
 273
 274   if (!hasKey && hasDeprecatedKey) {
 275     LOG(WARNING) << "Deprecated key '" << keys::kDeprecatedVersionKey
 276         << "' found. Please migrate to using '" << keys::kXWalkVersionKey
 277         << "' instead.";
 278     ok = manifest_->GetString(keys::kDeprecatedVersionKey, &version_str);
 279   }
 280
 281   version_.reset(new base::Version(version_str));
 282
 283   if (!ok || !version_->IsValid() || version_->components().size() > 4) {
 284     *error = base::ASCIIToUTF16(errors::kInvalidVersion);
 285     version_.reset(new base::Version());
 286     return false;
 287   }
 288
 289   return ok;
 290 }
 291
 292 bool ApplicationData::LoadDescription(base::string16* error) {
 293   DCHECK(error);
 294   // FIXME: Better to assert on use from Widget.
 295   if (manifest_type() != Manifest::TYPE_MANIFEST)
 296     return true;  // No error.
 297
 298   bool hasDeprecatedKey = manifest_->HasKey(keys::kDeprecatedDescriptionKey);
 299   bool hasKey = manifest_->HasKey(keys::kXWalkDescriptionKey);
 300
 301   if (hasKey) {
 302     if (hasDeprecatedKey) {
 303       LOG(WARNING) << "Deprecated key '" << keys::kDeprecatedDescriptionKey
 304           << "' found in addition to '" << keys::kXWalkDescriptionKey
 305           << "'. Consider removing.";
 306     }
 307     bool ok = manifest_->GetString(keys::kXWalkDescriptionKey, &description_);
 308     if (!ok)
 309       *error = base::ASCIIToUTF16(errors::kInvalidDescription);
 310     return ok;
 311   }
 312
 313   if (hasDeprecatedKey) {
 314     LOG(WARNING) << "Deprecated key '" << keys::kDeprecatedDescriptionKey
 315         << "' found. Please migrate to using '" << keys::kXWalkDescriptionKey
 316         << "' instead.";
 317     bool ok = manifest_->GetString(
 318         keys::kDeprecatedDescriptionKey, &description_);
 319     if (!ok)
 320       *error = base::ASCIIToUTF16(errors::kInvalidDescription);
 321     return ok;
 322   }
 323
 324   // No error but also no description found.
 325   return true;
 326 }
 327
 328 StoredPermission ApplicationData::GetPermission(
 329     const std::string& permission_name) const {
 330   StoredPermissionMap::const_iterator iter =
 331       permission_map_.find(permission_name);
 332   if (iter == permission_map_.end())
 333     return UNDEFINED_STORED_PERM;
 334   return iter->second;
 335 }
 336
 337 bool ApplicationData::SetPermission(const std::string& permission_name,
 338                                     StoredPermission perm) {
 339   if (perm != UNDEFINED_STORED_PERM) {
 340     permission_map_[permission_name] = perm;
 341     return true;
 342   }
 343   return false;
 344 }
 345
 346 void ApplicationData::ClearPermissions() {
 347   permission_map_.clear();
 348 }
 349
 350 PermissionSet ApplicationData::GetManifestPermissions() const {
 351   PermissionSet permissions;
 352   if (manifest_->value()->HasKey(keys::kPermissionsKey)) {
 353     const PermissionsInfo* perm_info = static_cast<PermissionsInfo*>(
 354                            GetManifestData(keys::kPermissionsKey));
 355     permissions = perm_info->GetAPIPermissions();
 356   }
 357   return permissions;
 358 }
 359
 360 bool ApplicationData::HasCSPDefined() const {
 361 #if defined(OS_TIZEN)
 362   return  manifest_->HasPath(GetCSPKey(manifest_type())) ||
 363           manifest_->HasPath(widget_keys::kCSPReportOnlyKey) ||
 364           manifest_->HasPath(widget_keys::kAllowNavigationKey);
 365 #else
 366   return manifest_->HasPath(GetCSPKey(manifest_type()));
 367 #endif
 368 }
 369
 370 bool ApplicationData::SetApplicationLocale(const std::string& locale,
 371                                            base::string16* error) {
 372   DCHECK(thread_checker_.CalledOnValidThread());
 373   manifest_->SetSystemLocale(locale);
 374   if (!LoadName(error))
 375     return false;
 376   if (!LoadDescription(error))
 377     return false;
 378
 379   // Only update when the package is wgt and we have parsed the widget handler,
 380   // otherwise we can not get widget_info.
 381   if (WidgetInfo* widget_info = static_cast<WidgetInfo*>(
 382           GetManifestData(widget_keys::kWidgetKey))) {
 383     std::string string_value;
 384     if (manifest_->GetString(widget_keys::kNameKey, &string_value))
 385       widget_info->SetName(string_value);
 386     if (manifest_->GetString(widget_keys::kShortNameKey, &string_value))
 387       widget_info->SetShortName(string_value);
 388     if (manifest_->GetString(widget_keys::kDescriptionKey, &string_value))
 389       widget_info->SetDescription(string_value);
 390   }
 391   return true;
 392 }
 393
 394 }   // namespace application
 395 }   // namespace xwalk