#include "xwalk/application/common/manifest.h"
#include "xwalk/application/common/manifest_handler.h"
#include "xwalk/application/common/manifest_handlers/main_document_handler.h"
+#include "xwalk/application/common/manifest_handlers/permissions_handler.h"
+#include "xwalk/application/common/permission_policy_manager.h"
#include "content/public/common/url_constants.h"
#include "url/url_util.h"
#include "ui/base/l10n/l10n_util.h"
-#if defined(OS_TIZEN_MOBILE)
-#include "xwalk/tizen/appcore_context.h"
-#endif
-
namespace keys = xwalk::application_manifest_keys;
+namespace widget_keys = xwalk::application_widget_keys;
namespace errors = xwalk::application_manifest_errors;
namespace xwalk {
// static
scoped_refptr<ApplicationData> ApplicationData::Create(
- const base::FilePath& path,
- Manifest::SourceType source_type,
- const DictionaryValue& manifest_data,
- const std::string& explicit_id,
- std::string* error_message) {
+ const base::FilePath& path,
+ Manifest::SourceType source_type,
+ const base::DictionaryValue& manifest_data,
+ const std::string& explicit_id,
+ std::string* error_message) {
DCHECK(error_message);
- string16 error;
+ base::string16 error;
scoped_ptr<xwalk::application::Manifest> manifest(
new xwalk::application::Manifest(source_type,
- scoped_ptr<DictionaryValue>(manifest_data.DeepCopy())));
+ scoped_ptr<base::DictionaryValue>(manifest_data.DeepCopy())));
if (!InitApplicationID(manifest.get(), path, explicit_id, &error)) {
- *error_message = UTF16ToUTF8(error);
+ *error_message = base::UTF16ToUTF8(error);
return NULL;
}
application->install_warnings_.swap(install_warnings);
if (!application->Init(&error)) {
- *error_message = UTF16ToUTF8(error);
+ *error_message = base::UTF16ToUTF8(error);
return NULL;
}
}
const std::string ApplicationData::VersionString() const {
- return Version()->GetString();
+ if (!version_->components().empty())
+ return Version()->GetString();
+
+ return "";
}
bool ApplicationData::IsPlatformApp() const {
return GetManifest()->IsHosted();
}
+Manifest::PackageType ApplicationData::GetPackageType() const {
+ return manifest_->GetPackageType();
+}
+
bool ApplicationData::HasMainDocument() const {
MainDocumentInfo* main_info = ToMainDocumentInfo(
GetManifestData(application_manifest_keys::kAppMainKey));
bool ApplicationData::InitApplicationID(xwalk::application::Manifest* manifest,
const base::FilePath& path,
const std::string& explicit_id,
- string16* error) {
+ base::string16* error) {
std::string application_id;
#if defined(OS_TIZEN)
if (manifest->HasKey(keys::kTizenAppIdKey)) {
return manifest_->GetType();
}
-bool ApplicationData::Init(string16* error) {
+bool ApplicationData::Init(base::string16* error) {
DCHECK(error);
if (!LoadName(error))
application_url_ = ApplicationData::GetBaseURLFromApplicationId(ID());
- if (!ManifestHandlerRegistry::GetInstance()->ParseAppManifest(this, error))
+ ManifestHandlerRegistry* registry =
+ ManifestHandlerRegistry::GetInstance(GetPackageType());
+ if (!registry->ParseAppManifest(this, error))
return false;
finished_parsing_manifest_ = true;
-#if defined(OS_TIZEN_MOBILE)
- appcore_context_ = tizen::AppcoreContext::Create();
-#endif
return true;
}
-bool ApplicationData::LoadName(string16* error) {
+bool ApplicationData::LoadName(base::string16* error) {
DCHECK(error);
- string16 localized_name;
- if (!manifest_->GetString(keys::kNameKey, &localized_name)) {
- *error = ASCIIToUTF16(errors::kInvalidName);
+ base::string16 localized_name;
+ std::string name_key(GetNameKey(GetPackageType()));
+
+ if (!manifest_->GetString(name_key, &localized_name) &&
+ manifest_->IsXPKPackaged()) {
+ *error = base::ASCIIToUTF16(errors::kInvalidName);
return false;
}
- non_localized_name_ = UTF16ToUTF8(localized_name);
+ non_localized_name_ = base::UTF16ToUTF8(localized_name);
base::i18n::AdjustStringForLocaleDirection(&localized_name);
- name_ = UTF16ToUTF8(localized_name);
+ name_ = base::UTF16ToUTF8(localized_name);
return true;
}
-bool ApplicationData::LoadVersion(string16* error) {
+bool ApplicationData::LoadVersion(base::string16* error) {
DCHECK(error);
std::string version_str;
- if (!manifest_->GetString(keys::kVersionKey, &version_str)) {
- *error = ASCIIToUTF16(errors::kInvalidVersion);
+ std::string version_key(GetVersionKey(GetPackageType()));
+
+ if (!manifest_->GetString(version_key, &version_str) &&
+ manifest_->IsXPKPackaged()) {
+ *error = base::ASCIIToUTF16(errors::kInvalidVersion);
return false;
}
version_.reset(new base::Version(version_str));
- if (!version_->IsValid() || version_->components().size() > 4) {
- *error = ASCIIToUTF16(errors::kInvalidVersion);
+ if (manifest_->IsXPKPackaged() &&
+ (!version_->IsValid() || version_->components().size() > 4)) {
+ *error = base::ASCIIToUTF16(errors::kInvalidVersion);
return false;
}
return true;
}
-bool ApplicationData::LoadDescription(string16* error) {
+bool ApplicationData::LoadDescription(base::string16* error) {
DCHECK(error);
if (manifest_->HasKey(keys::kDescriptionKey) &&
- !manifest_->GetString(keys::kDescriptionKey, &description_)) {
- *error = ASCIIToUTF16(errors::kInvalidDescription);
+ !manifest_->GetString(keys::kDescriptionKey, &description_) &&
+ manifest_->IsXPKPackaged()) {
+ *error = base::ASCIIToUTF16(errors::kInvalidDescription);
return false;
}
return true;
}
-bool ApplicationData::LoadManifestVersion(string16* error) {
+bool ApplicationData::LoadManifestVersion(base::string16* error) {
DCHECK(error);
// Get the original value out of the dictionary so that we can validate it
// more strictly.
int manifest_version = 1;
if (!manifest_->GetInteger(keys::kManifestVersionKey, &manifest_version) ||
manifest_version < 1) {
- *error = ASCIIToUTF16(errors::kInvalidManifestVersion);
- return false;
+ if (manifest_->IsXPKPackaged()) {
+ *error = base::ASCIIToUTF16(errors::kInvalidManifestVersion);
+ return false;
+ }
}
}
return events_;
}
+StoredPermission ApplicationData::GetPermission(
+ std::string& permission_name) const {
+ StoredPermissionMap::const_iterator iter =
+ permission_map_.find(permission_name);
+ if (iter == permission_map_.end())
+ return UNDEFINED_STORED_PERM;
+ return iter->second;
+}
+
+bool ApplicationData::SetPermission(const std::string& permission_name,
+ StoredPermission perm) {
+ if (perm != UNDEFINED_STORED_PERM) {
+ permission_map_[permission_name] = perm;
+ is_dirty_ = true;
+ return true;
+ }
+ return false;
+}
+
+void ApplicationData::ClearPermissions() {
+ permission_map_.clear();
+}
+
+PermissionSet ApplicationData::GetManifestPermissions() const {
+ PermissionSet permissions;
+ if (manifest_->value()->HasKey(keys::kPermissionsKey)) {
+ const PermissionsInfo* perm_info = static_cast<PermissionsInfo*>(
+ GetManifestData(keys::kPermissionsKey));
+ permissions = perm_info->GetAPIPermissions();
+ }
+ return permissions;
+}
+
+#if defined(OS_TIZEN)
+bool ApplicationData::HasCSPDefined() const {
+ return (manifest_->HasPath(widget_keys::kCSPKey) ||
+ manifest_->HasPath(widget_keys::kCSPReportOnlyKey) ||
+ manifest_->HasPath(widget_keys::kAllowNavigationKey));
+}
+#endif
+
+bool ApplicationData::SetApplicationLocale(const std::string& locale,
+ base::string16* error) {
+ manifest_->SetSystemLocale(locale);
+ if (!LoadName(error))
+ return false;
+ if (!LoadDescription(error))
+ return false;
+ return true;
+}
+
} // namespace application
} // namespace xwalk
projects / platform / framework / web / crosswalk.git / blobdiff