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/main_document_handler.h"
  30 #include "xwalk/application/common/manifest_handlers/permissions_handler.h"
  31 #include "xwalk/application/common/permission_policy_manager.h"
  32 #include "content/public/common/url_constants.h"
  33 #include "url/url_util.h"
  34 #include "ui/base/l10n/l10n_util.h"
  35
  36 namespace keys = xwalk::application_manifest_keys;
  37 namespace widget_keys = xwalk::application_widget_keys;
  38 namespace errors = xwalk::application_manifest_errors;
  39
  40 namespace xwalk {
  41 namespace application {
  42
  43 // static
  44 scoped_refptr<ApplicationData> ApplicationData::Create(
  45     const base::FilePath& path,
  46     Manifest::SourceType source_type,
  47     const base::DictionaryValue& manifest_data,
  48     const std::string& explicit_id,
  49     std::string* error_message) {
  50   DCHECK(error_message);
  51   base::string16 error;
  52   scoped_ptr<xwalk::application::Manifest> manifest(
  53       new xwalk::application::Manifest(source_type,
  54                  scoped_ptr<base::DictionaryValue>(manifest_data.DeepCopy())));
  55
  56   if (!InitApplicationID(manifest.get(), path, explicit_id, &error)) {
  57     *error_message = base::UTF16ToUTF8(error);
  58     return NULL;
  59   }
  60
  61   std::vector<InstallWarning> install_warnings;
  62   if (!manifest->ValidateManifest(error_message, &install_warnings)) {
  63     return NULL;
  64   }
  65
  66   scoped_refptr<ApplicationData> application = new ApplicationData(path,
  67                                                            manifest.Pass());
  68   application->install_warnings_.swap(install_warnings);
  69
  70   if (!application->Init(&error)) {
  71     *error_message = base::UTF16ToUTF8(error);
  72     return NULL;
  73   }
  74
  75   return application;
  76 }
  77
  78 // static
  79 bool ApplicationData::IsIDValid(const std::string& id) {
  80   std::string temp = StringToLowerASCII(id);
  81
  82 #if defined(OS_TIZEN)
  83   // An ID with 10 characters is most likely a legacy Tizen ID.
  84   if (temp.size() == kLegacyTizenIdSize) {
  85     for (size_t i = 0; i < kLegacyTizenIdSize; ++i) {
  86       const char c = temp[i];
  87       const bool valid = (c >= '0' && c <= '9') || (c >= 'a' && c <= 'z');
  88       if (!valid)
  89         return false;
  90     }
  91
  92     return true;
  93   }
  94 #endif
  95
  96   // Verify that the id is legal.
  97   if (temp.size() != (kIdSize * 2))
  98     return false;
  99
 100   // We only support lowercase IDs, because IDs can be used as URL components
 101   // (where GURL will lowercase it).
 102   for (size_t i = 0; i < temp.size(); ++i)
 103     if (temp[i] < 'a' || temp[i] > 'p')
 104       return false;
 105
 106   return true;
 107 }
 108
 109 // static
 110 GURL ApplicationData::GetBaseURLFromApplicationId(
 111     const std::string& application_id) {
 112   return GURL(std::string(xwalk::application::kApplicationScheme) +
 113               content::kStandardSchemeSeparator + application_id + "/");
 114 }
 115
 116 ApplicationData::ManifestData* ApplicationData::GetManifestData(
 117         const std::string& key) const {
 118   DCHECK(finished_parsing_manifest_ || thread_checker_.CalledOnValidThread());
 119   ManifestDataMap::const_iterator iter = manifest_data_.find(key);
 120   if (iter != manifest_data_.end())
 121     return iter->second.get();
 122   return NULL;
 123 }
 124
 125 void ApplicationData::SetManifestData(const std::string& key,
 126                                       ApplicationData::ManifestData* data) {
 127   DCHECK(!finished_parsing_manifest_ && thread_checker_.CalledOnValidThread());
 128   manifest_data_[key] = linked_ptr<ManifestData>(data);
 129 }
 130
 131 Manifest::SourceType ApplicationData::GetSourceType() const {
 132   return manifest_->GetSourceType();
 133 }
 134
 135 const std::string& ApplicationData::ID() const {
 136   return manifest_->GetApplicationID();
 137 }
 138
 139 const std::string ApplicationData::VersionString() const {
 140   if (!version_->components().empty())
 141     return Version()->GetString();
 142
 143   return "";
 144 }
 145
 146 bool ApplicationData::IsPlatformApp() const {
 147   return manifest_->IsPackaged();
 148 }
 149
 150 bool ApplicationData::IsHostedApp() const {
 151   return GetManifest()->IsHosted();
 152 }
 153
 154 Manifest::PackageType ApplicationData::GetPackageType() const {
 155   return manifest_->GetPackageType();
 156 }
 157
 158 bool ApplicationData::HasMainDocument() const {
 159   MainDocumentInfo* main_info = ToMainDocumentInfo(
 160       GetManifestData(application_manifest_keys::kAppMainKey));
 161
 162   return main_info != NULL;
 163 }
 164
 165 // static
 166 bool ApplicationData::InitApplicationID(xwalk::application::Manifest* manifest,
 167                                 const base::FilePath& path,
 168                                 const std::string& explicit_id,
 169                                 base::string16* error) {
 170   std::string application_id;
 171 #if defined(OS_TIZEN)
 172   if (manifest->HasKey(keys::kTizenAppIdKey)) {
 173     if (!manifest->GetString(keys::kTizenAppIdKey, &application_id)) {
 174       NOTREACHED() << "Could not get Tizen application key";
 175       return false;
 176     }
 177   }
 178
 179   if (!application_id.empty()) {
 180     manifest->SetApplicationID(application_id);
 181     return true;
 182   }
 183 #endif
 184
 185   if (!explicit_id.empty()) {
 186     manifest->SetApplicationID(explicit_id);
 187     return true;
 188   }
 189
 190   application_id = GenerateIdForPath(path);
 191   if (application_id.empty()) {
 192     NOTREACHED() << "Could not create ID from path.";
 193     return false;
 194   }
 195   manifest->SetApplicationID(application_id);
 196   return true;
 197 }
 198
 199 ApplicationData::ApplicationData(const base::FilePath& path,
 200                      scoped_ptr<xwalk::application::Manifest> manifest)
 201     : manifest_version_(0),
 202       is_dirty_(false),
 203       manifest_(manifest.release()),
 204       finished_parsing_manifest_(false) {
 205   DCHECK(path.empty() || path.IsAbsolute());
 206   path_ = path;
 207 }
 208
 209 ApplicationData::~ApplicationData() {
 210 }
 211
 212 // static
 213 GURL ApplicationData::GetResourceURL(const GURL& application_url,
 214                                const std::string& relative_path) {
 215   DCHECK(application_url.SchemeIs(xwalk::application::kApplicationScheme));
 216   DCHECK_EQ("/", application_url.path());
 217
 218   std::string path = relative_path;
 219
 220   // If the relative path starts with "/", it is "absolute" relative to the
 221   // application base directory, but application_url is already specified to
 222   // refer to that base directory, so strip the leading "/" if present.
 223   if (relative_path.size() > 0 && relative_path[0] == '/')
 224     path = relative_path.substr(1);
 225
 226   GURL ret_val = GURL(application_url.spec() + path);
 227   DCHECK(StartsWithASCII(ret_val.spec(), application_url.spec(), false));
 228
 229   return ret_val;
 230 }
 231
 232 Manifest::Type ApplicationData::GetType() const {
 233   return manifest_->GetType();
 234 }
 235
 236 bool ApplicationData::Init(base::string16* error) {
 237   DCHECK(error);
 238
 239   if (!LoadName(error))
 240     return false;
 241   if (!LoadVersion(error))
 242       return false;
 243   if (!LoadDescription(error))
 244       return false;
 245   if (!LoadManifestVersion(error))
 246     return false;
 247
 248   application_url_ = ApplicationData::GetBaseURLFromApplicationId(ID());
 249
 250   ManifestHandlerRegistry* registry =
 251       ManifestHandlerRegistry::GetInstance(GetPackageType());
 252   if (!registry->ParseAppManifest(this, error))
 253     return false;
 254
 255   finished_parsing_manifest_ = true;
 256   return true;
 257 }
 258
 259 bool ApplicationData::LoadName(base::string16* error) {
 260   DCHECK(error);
 261   base::string16 localized_name;
 262   std::string name_key(GetNameKey(GetPackageType()));
 263
 264   if (!manifest_->GetString(name_key, &localized_name) &&
 265       manifest_->IsXPKPackaged()) {
 266     *error = base::ASCIIToUTF16(errors::kInvalidName);
 267     return false;
 268   }
 269   non_localized_name_ = base::UTF16ToUTF8(localized_name);
 270   base::i18n::AdjustStringForLocaleDirection(&localized_name);
 271   name_ = base::UTF16ToUTF8(localized_name);
 272   return true;
 273 }
 274
 275 bool ApplicationData::LoadVersion(base::string16* error) {
 276   DCHECK(error);
 277   std::string version_str;
 278   std::string version_key(GetVersionKey(GetPackageType()));
 279
 280   if (!manifest_->GetString(version_key, &version_str) &&
 281       manifest_->IsXPKPackaged()) {
 282     *error = base::ASCIIToUTF16(errors::kInvalidVersion);
 283     return false;
 284   }
 285   version_.reset(new base::Version(version_str));
 286   if (manifest_->IsXPKPackaged() &&
 287       (!version_->IsValid() || version_->components().size() > 4)) {
 288     *error = base::ASCIIToUTF16(errors::kInvalidVersion);
 289     return false;
 290   }
 291   return true;
 292 }
 293
 294 bool ApplicationData::LoadDescription(base::string16* error) {
 295   DCHECK(error);
 296   if (manifest_->HasKey(keys::kDescriptionKey) &&
 297       !manifest_->GetString(keys::kDescriptionKey, &description_) &&
 298       manifest_->IsXPKPackaged()) {
 299     *error = base::ASCIIToUTF16(errors::kInvalidDescription);
 300     return false;
 301   }
 302   return true;
 303 }
 304
 305 bool ApplicationData::LoadManifestVersion(base::string16* error) {
 306   DCHECK(error);
 307   // Get the original value out of the dictionary so that we can validate it
 308   // more strictly.
 309   if (manifest_->value()->HasKey(keys::kManifestVersionKey)) {
 310     int manifest_version = 1;
 311     if (!manifest_->GetInteger(keys::kManifestVersionKey, &manifest_version) ||
 312         manifest_version < 1) {
 313       if (manifest_->IsXPKPackaged()) {
 314         *error = base::ASCIIToUTF16(errors::kInvalidManifestVersion);
 315         return false;
 316       }
 317     }
 318   }
 319
 320   manifest_version_ = manifest_->GetManifestVersion();
 321   return true;
 322 }
 323
 324 void ApplicationData::SetEvents(const std::set<std::string>& events) {
 325   events_ = events;
 326   is_dirty_ = true;
 327 }
 328
 329 const std::set<std::string>& ApplicationData::GetEvents() const {
 330   return events_;
 331 }
 332
 333 StoredPermission ApplicationData::GetPermission(
 334     std::string& permission_name) const {
 335   StoredPermissionMap::const_iterator iter =
 336       permission_map_.find(permission_name);
 337   if (iter == permission_map_.end())
 338     return UNDEFINED_STORED_PERM;
 339   return iter->second;
 340 }
 341
 342 bool ApplicationData::SetPermission(const std::string& permission_name,
 343                                     StoredPermission perm) {
 344   if (perm != UNDEFINED_STORED_PERM) {
 345     permission_map_[permission_name] = perm;
 346     is_dirty_ = true;
 347     return true;
 348   }
 349   return false;
 350 }
 351
 352 void ApplicationData::ClearPermissions() {
 353   permission_map_.clear();
 354 }
 355
 356 PermissionSet ApplicationData::GetManifestPermissions() const {
 357   PermissionSet permissions;
 358   if (manifest_->value()->HasKey(keys::kPermissionsKey)) {
 359     const PermissionsInfo* perm_info = static_cast<PermissionsInfo*>(
 360                            GetManifestData(keys::kPermissionsKey));
 361     permissions = perm_info->GetAPIPermissions();
 362   }
 363   return permissions;
 364 }
 365
 366 #if defined(OS_TIZEN)
 367 bool ApplicationData::HasCSPDefined() const {
 368   return (manifest_->HasPath(widget_keys::kCSPKey) ||
 369           manifest_->HasPath(widget_keys::kCSPReportOnlyKey) ||
 370           manifest_->HasPath(widget_keys::kAllowNavigationKey));
 371 }
 372 #endif
 373
 374 }   // namespace application
 375 }   // namespace xwalk