X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fconfiguration_parser%2Fwidget_parser.cpp;h=39b139cc72c62aa4d6be32bdaf0d1a6ed1ad2cef;hb=b69d75e416182d3c16417444f1f49e35bf94ffb5;hp=d740ac3f645a6b7477f44aae888920be7f6cf0f7;hpb=fd1c15588ac1d18fd5d6117fdb86016cd490e5be;p=framework%2Fweb%2Fwrt-installer.git diff --git a/src/configuration_parser/widget_parser.cpp b/src/configuration_parser/widget_parser.cpp old mode 100755 new mode 100644 index d740ac3..39b139c --- a/src/configuration_parser/widget_parser.cpp +++ b/src/configuration_parser/widget_parser.cpp @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - /** +/** * This file have been implemented in compliance with W3C WARP SPEC. * but there are some patent issue between W3C WARP SPEC and APPLE. * so if you want to use this file, refer to the README file in root directory @@ -68,7 +68,7 @@ Direction ParseDirAttribute(const XmlAttribute& attribute) } void UpdateTextWithDirectionMark(Direction direction, - DPL::String* text) + DPL::String* text) { Assert(text); switch (direction) { @@ -88,6 +88,7 @@ void UpdateTextWithDirectionMark(Direction direction, break; default: Assert(false); + break; } } } // namespace Unicode @@ -96,14 +97,13 @@ class InnerElementsParser : public ElementParser { public: virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) + const DPL::String& /*name*/) { return DPL::MakeDelegate(this, &InnerElementsParser::Other); } virtual void Accept(const Element& /*element*/) - { - } + {} virtual void Accept(const Text& text) { @@ -133,8 +133,7 @@ class InnerElementsParser : public ElementParser InnerElementsParser(ElementParserPtr parent) : m_parentParser(parent), m_textDirection(Unicode::EMPTY) - { - } + {} ElementParserPtr Other() { @@ -153,7 +152,7 @@ class NameParser : public ElementParser { public: virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) + const DPL::String& /*name*/) { return DPL::MakeDelegate(this, &NameParser::Other); } @@ -203,11 +202,10 @@ class NameParser : public ElementParser } NameParser(Unicode::Direction direction, - ConfigParserData& data) : + ConfigParserData& data) : m_data(data), m_textDirection(direction) - { - } + {} ElementParserPtr Other() { @@ -235,7 +233,7 @@ class AccessParser : public ElementParser }; virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) + const DPL::String& /*name*/) { return DPL::MakeDelegate(this, &AccessParser::Other); } @@ -251,8 +249,7 @@ class AccessParser : public ElementParser } virtual void Accept(const Text& /*text*/) - { - } + {} void AcceptWac(const XmlAttribute& attribute) { @@ -279,6 +276,7 @@ class AccessParser : public ElementParser break; default: LogError("Error in Access tag - unknown standard."); + break; } } @@ -295,10 +293,15 @@ class AccessParser : public ElementParser return; } + if(m_strIRIOrigin == L"*") //wildcard match means yes for subdomains + { + m_bSubDomainAccess = true; + } + ConfigParserData::AccessInfo accessInfo(m_strIRIOrigin, m_bSubDomainAccess); - std::pair ret = - m_data.accessInfoSet.insert(accessInfo); + //std::pair ret = + m_data.accessInfoSet.insert(accessInfo); } virtual void Verify() @@ -309,6 +312,7 @@ class AccessParser : public ElementParser break; default: LogError("Error in Access tag - unknown standard."); + break; } } @@ -318,8 +322,7 @@ class AccessParser : public ElementParser m_standardType(STANDARD_TYPE_NONE), m_network(false), m_data(data) - { - } + {} ElementParserPtr Other() { @@ -339,7 +342,7 @@ class DescriptionParser : public ElementParser { public: virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) + const DPL::String& /*name*/) { return DPL::MakeDelegate(this, &DescriptionParser::Other); } @@ -386,13 +389,12 @@ class DescriptionParser : public ElementParser } DescriptionParser(Unicode::Direction direction, - ConfigParserData& data) : + ConfigParserData& data) : m_data(data), m_lang(), m_description(), m_textDirection(direction) - { - } + {} private: ConfigParserData& m_data; @@ -405,17 +407,16 @@ class AuthorParser : public ElementParser { public: virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) + const DPL::String& /*name*/) { return DPL::MakeDelegate(this, &AuthorParser::Other); } AuthorParser(Unicode::Direction direction, - ConfigParserData& data) : + ConfigParserData& data) : m_data(data), m_textDirection(direction) - { - } + {} virtual void Accept(const Element& /*element*/) { @@ -482,18 +483,17 @@ class LicenseParser : public ElementParser { public: virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) + const DPL::String& /*name*/) { return DPL::MakeDelegate(this, &LicenseParser::Other); } LicenseParser(Unicode::Direction direction, - ConfigParserData& data) : + ConfigParserData& data) : m_data(data), m_ignore(true), m_textDirection(direction) - { - } + {} virtual void Accept(const Element& element) { @@ -561,19 +561,17 @@ class IconParser : public ElementParser public: virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) + const DPL::String& /*name*/) { return &IgnoringParser::Create; } IconParser(ConfigParserData& data) : ElementParser(), m_data(data) - { - } + {} virtual void Accept(const Element& /*element*/) - { - } + {} virtual void Accept(const XmlAttribute& attribute) { @@ -635,7 +633,8 @@ class IconParser : public ElementParser strtol(DPL::ToUTF8String(value).c_str(), &reterr, 10); if (errno != 0 || std::string(reterr) == DPL::ToUTF8String(value) || - valueInt <= 0) { + valueInt <= 0) + { return DPL::OptionalInt::Null; } else { return valueInt; @@ -645,7 +644,8 @@ class IconParser : public ElementParser } /** - * @brief delocalizePath removes locales folder from relative path if neccessary + * @brief delocalizePath removes locales folder from relative path if + * neccessary * @param source source string * * @throw BadSrcError if string is bad value of src attribute @@ -659,15 +659,11 @@ class IconParser : public ElementParser DPL::String result = source; - if(source.substr(0,index) == localeFolder) - { - size_t pos = result.find_first_of('/',index); - if(pos != std::string::npos && pos + 1 < source.size()) - { - result = result.substr(pos + 1,source.size()); - } - else - { + if (source.substr(0, index) == localeFolder) { + size_t pos = result.find_first_of('/', index); + if (pos != std::string::npos && pos + 1 < source.size()) { + result = result.substr(pos + 1, source.size()); + } else { Throw(BadSrcError); } } @@ -679,7 +675,7 @@ class ContentParser : public ElementParser { public: virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) + const DPL::String& /*name*/) { return &IgnoringParser::Create; } @@ -687,16 +683,13 @@ class ContentParser : public ElementParser ContentParser(ConfigParserData& data) : ElementParser(), m_data(data) - { - } + {} virtual void Accept(const Element& /*element*/) - { - } + {} virtual void Accept(const Text& /*text*/) - { - } + {} virtual void Accept(const XmlAttribute& attribute) { @@ -750,141 +743,11 @@ class ContentParser : public ElementParser ConfigParserData& m_data; }; -class FeatureParser : public ElementParser -{ - public: - struct ParamParser : public ElementParser - { - virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) - { - return &IgnoringParser::Create; - } - - virtual void Accept(const XmlAttribute& attribute) - { - if (attribute.name == L"name") { - m_name = attribute.value; - NormalizeString(m_name); - } else if (attribute.name == L"value") { - m_value = attribute.value; - NormalizeString(m_value); - } - } - - virtual void Accept(const Element& /*element*/) - { - } - - virtual void Accept(const Text& /*text*/) - { - ThrowMsg(Exception::ParseError, "param element must be empty"); - } - - virtual void Verify() - { - if (m_name.IsNull() || *m_name == L"") { - return; - } - if (m_value.IsNull() || *m_value == L"") { - return; - } - - ConfigParserData::Param param(*m_name); - param.value = *m_value; - - if (m_data.paramsList.find(param) == m_data.paramsList.end()) { - m_data.paramsList.insert(param); - } - } - - ParamParser(ConfigParserData::Feature& data) : - ElementParser(), - m_data(data) - { - } - - private: - DPL::OptionalString m_name; - DPL::OptionalString m_value; - ConfigParserData::Feature& m_data; - }; - - virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& name) - { - if (name == L"param") { - return DPL::MakeDelegate(this, &FeatureParser::OnParamElement); - } else { - return &IgnoringParser::Create; - } - } - - virtual void Accept(const Text& /*text*/) - { - } - - virtual void Accept(const Element& /*element*/) - { - } - - virtual void Accept(const XmlAttribute& attribute) - { - if (attribute.name == L"name") { - m_feature.name = attribute.value; - } else if (attribute.name == L"required") { - if (attribute.value == L"false") { - m_feature.required = false; - } else { - m_feature.required = true; - } - } - } - - virtual void Verify() - { - LibIri::Wrapper iri(DPL::ToUTF8String(m_feature.name).c_str()); - - if (m_feature.name != L"") { - if (iri.Validate()) { - if (m_data.featuresList.find(m_feature) == - m_data.featuresList.end()) { - m_data.featuresList.insert(m_feature); - } else { - LogDebug("Ignoring feature with name" << - DPL::ToUTF8String(m_feature.name)); - } - } else { - if (m_feature.required) { - //Throw only if required - ThrowMsg(Exception::ParseError, "invalid feature IRI"); - } - } - } - } - - ElementParserPtr OnParamElement() - { - return ElementParserPtr(new ParamParser(m_feature)); - } - - FeatureParser(ConfigParserData& data) : - ElementParser(), - m_data(data), - m_feature(L"") - { - } - - private: - ConfigParserData& m_data; - ConfigParserData::Feature m_feature; -}; - class PreferenceParser : public ElementParser { public: virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) + const DPL::String& /*name*/) { return &IgnoringParser::Create; } @@ -905,8 +768,7 @@ class PreferenceParser : public ElementParser } virtual void Accept(const Element& /*element*/) - { - } + {} virtual void Accept(const Text& /*text*/) { @@ -924,7 +786,8 @@ class PreferenceParser : public ElementParser ConfigParserData::Preference preference(*m_name, m_required); preference.value = m_value; if (m_data.preferencesList.find(preference) == - m_data.preferencesList.end()) { + m_data.preferencesList.end()) + { m_data.preferencesList.insert(preference); } } @@ -933,8 +796,7 @@ class PreferenceParser : public ElementParser ElementParser(), m_required(false), m_data(data) - { - } + {} private: DPL::OptionalString m_name; @@ -947,7 +809,7 @@ class LinkParser : public ElementParser { public: virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) + const DPL::String& /*name*/) { return &DenyAllParser::Create; } @@ -961,8 +823,9 @@ class LinkParser : public ElementParser ThrowMsg(Exception::ParseError, "rel attribute must have describedby value"); } - } else if (attribute.name == L"type") { - } else if (attribute.name == L"href") { + } else if (attribute.name == L"type") {} else if (attribute.name == + L"href") + { LogDebug("here is href"); m_href = attribute.value; } else { @@ -1011,8 +874,7 @@ class LinkParser : public ElementParser m_properNamespace(false), m_data(data), m_href(DPL::OptionalString::Null) - { - } + {} private: bool m_properNamespace; @@ -1024,18 +886,16 @@ class SettingParser : public ElementParser { public: virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) + const DPL::String& /*name*/) { return &IgnoringParser::Create; } virtual void Accept(const Text& /*text*/) - { - } + {} virtual void Accept(const Element& /*element*/) - { - } + {} virtual void Accept(const XmlAttribute& attribute) { @@ -1045,15 +905,13 @@ class SettingParser : public ElementParser } virtual void Verify() - { - } + {} SettingParser(ConfigParserData& data) : ElementParser(), m_data(data), m_setting(L"", L"") - { - } + {} private: ConfigParserData& m_data; @@ -1079,6 +937,10 @@ class AppServiceParser : public ElementParser m_scheme = attribute.value; } else if (attribute.name == L"mime") { m_mime = attribute.value; + } else if (attribute.name == L"disposition") { + if (attribute.value == L"inline") + m_disposition = + ConfigParserData::ServiceInfo::Disposition::INLINE; } } @@ -1087,7 +949,7 @@ class AppServiceParser : public ElementParser LogWarning("namespace for app service = " << element.ns); if (element.ns == ConfigurationNamespace::W3CWidgetNamespaceName) { ThrowMsg(Exception::ParseError, - "Wrong xml namespace for widget element"); + "Wrong xml namespace for widget element"); } } @@ -1110,37 +972,47 @@ class AppServiceParser : public ElementParser NormalizeString(m_scheme); NormalizeString(m_mime); + // exception + DPL::String ignoreUri(L"file"); + + if (!m_scheme.IsNull() && *m_scheme == ignoreUri) + { + LogInfo("exception : '" << *m_scheme << "' scheme will be ignored."); + m_scheme = DPL::OptionalString::Null; + } + // verify duplicate element DPL::String wildString(L"*/*"); DPL::String nullString(L""); ConfigParserData::ServiceInfo serviceInfo( - m_src.IsNull() ? nullString:*m_src, - m_operation.IsNull() ? nullString:*m_operation, - m_scheme.IsNull() ? nullString:*m_scheme, - m_mime.IsNull() ? nullString:*m_mime); + m_src.IsNull() ? nullString : *m_src, + m_operation.IsNull() ? nullString : *m_operation, + m_scheme.IsNull() ? nullString : *m_scheme, + m_mime.IsNull() ? nullString : *m_mime, + m_disposition); FOREACH(iterator, m_data.appServiceList) { if (iterator->m_operation == serviceInfo.m_operation && // check scheme (iterator->m_scheme == serviceInfo.m_scheme || - // check input scheme is "*/*" case - (iterator->m_scheme == wildString && - serviceInfo.m_scheme != nullString) || - // check iterator scheme is "*/*" case - (serviceInfo.m_scheme == wildString && - iterator->m_scheme != nullString)) && + // check input scheme is "*/*" case + (iterator->m_scheme == wildString && + serviceInfo.m_scheme != nullString) || + // check iterator scheme is "*/*" case + (serviceInfo.m_scheme == wildString && + iterator->m_scheme != nullString)) && (iterator->m_mime == serviceInfo.m_mime || - // check input mime is "*/*" case - (iterator->m_mime == wildString && - serviceInfo.m_mime != nullString) || - // check iterator mime is "*/*" case - (serviceInfo.m_mime == wildString && - iterator->m_mime != nullString))) + // check input mime is "*/*" case + (iterator->m_mime == wildString && + serviceInfo.m_mime != nullString) || + // check iterator mime is "*/*" case + (serviceInfo.m_mime == wildString && + iterator->m_mime != nullString))) { ThrowMsg(Exception::ParseError, - "service operation is duplicated " + - DPL::ToUTF8String(*m_operation)); + "service operation is duplicated " + + DPL::ToUTF8String(*m_operation)); } } m_data.appServiceList.push_back(serviceInfo); @@ -1152,307 +1024,294 @@ class AppServiceParser : public ElementParser m_operation(DPL::OptionalString::Null), m_scheme(DPL::OptionalString::Null), m_mime(DPL::OptionalString::Null), + m_disposition(ConfigParserData::ServiceInfo::Disposition::WINDOW), m_data(data) - { - } + {} private: DPL::OptionalString m_src; DPL::OptionalString m_operation; DPL::OptionalString m_scheme; DPL::OptionalString m_mime; + ConfigParserData::ServiceInfo::Disposition m_disposition; ConfigParserData& m_data; }; class AppControlParser : public ElementParser { public: - struct SourceParser : public ElementParser - { - public: - virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) - { - return &IgnoringParser::Create; - } - - virtual void Accept(const Text& /*text*/) - { - } - - virtual void Accept(const Element& /*element*/) - { - } - - virtual void Accept(const XmlAttribute& attribute) - { - if (attribute.name == L"name") { - if (attribute.value.size() > 0) { - m_value = attribute.value; - NormalizeString(m_value); - } - } - } - - virtual void Verify() - { - if (m_value.IsNull() || *m_value== L"") { - return; - } - - m_data.m_src = *m_value; - } - - SourceParser(ConfigParserData::AppControlInfo& data) : - ElementParser(), - m_properNamespace(false), - m_data(data) - { - } - - private: - bool m_properNamespace; - DPL::OptionalString m_value; - ConfigParserData::AppControlInfo& m_data; - }; - - struct OperationParser : public ElementParser - { - public: - virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) - { - return &IgnoringParser::Create; - } - - virtual void Accept(const Text& /*text*/) - { - } - - virtual void Accept(const Element& /*element*/) - { - } - - virtual void Accept(const XmlAttribute& attribute) - { - if (attribute.name == L"name") { - if (attribute.value.size() > 0) { - m_value = attribute.value; - NormalizeString(m_value); - } - } - } - - virtual void Verify() - { - if (m_value.IsNull() || *m_value== L"") { - return; - } - - m_data.m_operation = *m_value; - } - - OperationParser(ConfigParserData::AppControlInfo& data) : - ElementParser(), - m_properNamespace(false), - m_data(data) - { - } - - private: - bool m_properNamespace; - DPL::OptionalString m_value; - ConfigParserData::AppControlInfo& m_data; - }; - - struct UriParser : public ElementParser - { - public: - virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) - { - return &IgnoringParser::Create; - } - - virtual void Accept(const Text& /*text*/) - { - } - - virtual void Accept(const Element& /*element*/) - { - } - - virtual void Accept(const XmlAttribute& attribute) - { - if (attribute.name == L"name") { - if (attribute.value.size() > 0) { - m_value = attribute.value; - NormalizeString(m_value); - } - } - } - - virtual void Verify() - { - if (m_value.IsNull() || *m_value == L"") { - return; - } - - DPL::String wildString(L"*/*"); - if ((m_data.m_uriList.find(wildString) == - m_data.m_uriList.end()) - && (m_data.m_uriList.find(*m_value) == - m_data.m_uriList.end())) { - - m_data.m_uriList.insert(*m_value); - } else { - LogDebug("Ignoring uri with name" << - DPL::ToUTF8String(*m_value)); - } - } - - UriParser(ConfigParserData::AppControlInfo& data) : - ElementParser(), - m_properNamespace(false), - m_data(data) - { - } - - private: - bool m_properNamespace; - DPL::OptionalString m_value; - ConfigParserData::AppControlInfo& m_data; - }; - - struct MimeParser : public ElementParser - { - public: - virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) - { - return &IgnoringParser::Create; - } - - virtual void Accept(const Text& /*text*/) - { - } - - virtual void Accept(const Element& /*element*/) - { - } - - virtual void Accept(const XmlAttribute& attribute) - { - if (attribute.name == L"name") { - if (attribute.value.size() > 0) { - m_value = attribute.value; - NormalizeString(m_value); - } - } - } - - virtual void Verify() - { - if (m_value.IsNull() || *m_value == L"") { - return; - } - - DPL::String wildString(L"*/*"); - if ((m_data.m_mimeList.find(wildString) == - m_data.m_mimeList.end()) - && (m_data.m_mimeList.find(*m_value) == - m_data.m_mimeList.end())) { - m_data.m_mimeList.insert(*m_value); - } else { - LogDebug("Ignoring mime with name" << - DPL::ToUTF8String(*m_value)); - } - } - - MimeParser(ConfigParserData::AppControlInfo& data) : - ElementParser(), - m_properNamespace(false), - m_data(data) - { - } - - private: - bool m_properNamespace; - DPL::OptionalString m_value; - ConfigParserData::AppControlInfo& m_data; - }; - - virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& name) + struct SourceParser : public ElementParser { - if (name == L"src") { - return DPL::MakeDelegate(this, &AppControlParser::OnSourceElement); - } else if (name == L"operation") { - return DPL::MakeDelegate(this, &AppControlParser::OnOperationElement); - } else if (name == L"uri") { - return DPL::MakeDelegate(this, &AppControlParser::OnUriElement); - } else if (name == L"mime") { - return DPL::MakeDelegate(this, &AppControlParser::OnMimeElement); - } else { + public: + virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, + const DPL::String& /*name*/) + { return &IgnoringParser::Create; } - } - virtual void Accept(const XmlAttribute& attribute) - { - } + virtual void Accept(const Text& /*text*/) + {} - virtual void Accept(const Element& element) - { - LogWarning("namespace for app service = " << element.ns); - if (element.ns == ConfigurationNamespace::W3CWidgetNamespaceName) { - ThrowMsg(Exception::ParseError, - "Wrong xml namespace for widget element"); + virtual void Accept(const Element& /*element*/) + {} + + virtual void Accept(const XmlAttribute& attribute) + { + if (attribute.name == L"name") { + if (attribute.value.size() > 0) { + m_value = attribute.value; + NormalizeString(m_value); + } + } } - } - virtual void Accept(const Text& /*text*/) - { - ThrowMsg(Exception::ParseError, "param element must be empty"); - } + virtual void Verify() + { + if (m_value.IsNull() || *m_value == L"") { + return; + } - virtual void Verify() - { - if (m_appControl.m_src == L""){ - LogWarning("service element must have src element"); - return; + m_data.m_src = *m_value; } - if (m_appControl.m_operation == L""){ - LogWarning("service element must have operation element"); - return; + SourceParser(ConfigParserData::AppControlInfo& data) : + ElementParser(), + m_properNamespace(false), + m_data(data) + {} + + private: + bool m_properNamespace; + DPL::OptionalString m_value; + ConfigParserData::AppControlInfo& m_data; + }; + + struct OperationParser : public ElementParser + { + public: + virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, + const DPL::String& /*name*/) + { + return &IgnoringParser::Create; } - FOREACH(iterator, m_data.appControlList) { - if (iterator->m_src == m_appControl.m_src && - iterator->m_operation == m_appControl.m_operation ) - { - ThrowMsg(Exception::ParseError, - "app control element is duplicated " + - DPL::ToUTF8String(m_appControl.m_src) + ", " + - DPL::ToUTF8String(m_appControl.m_operation)); + virtual void Accept(const Text& /*text*/) + {} + + virtual void Accept(const Element& /*element*/) + {} + + virtual void Accept(const XmlAttribute& attribute) + { + if (attribute.name == L"name") { + if (attribute.value.size() > 0) { + m_value = attribute.value; + NormalizeString(m_value); + } } } - m_data.appControlList.push_back(m_appControl); - } - ElementParserPtr OnSourceElement() - { - return ElementParserPtr(new SourceParser(m_appControl)); - } + virtual void Verify() + { + if (m_value.IsNull() || *m_value == L"") { + return; + } - ElementParserPtr OnOperationElement() - { - return ElementParserPtr(new OperationParser(m_appControl)); - } + m_data.m_operation = *m_value; + } - ElementParserPtr OnUriElement() - { + OperationParser(ConfigParserData::AppControlInfo& data) : + ElementParser(), + m_properNamespace(false), + m_data(data) + {} + + private: + bool m_properNamespace; + DPL::OptionalString m_value; + ConfigParserData::AppControlInfo& m_data; + }; + + struct UriParser : public ElementParser + { + public: + virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, + const DPL::String& /*name*/) + { + return &IgnoringParser::Create; + } + + virtual void Accept(const Text& /*text*/) + {} + + virtual void Accept(const Element& /*element*/) + {} + + virtual void Accept(const XmlAttribute& attribute) + { + if (attribute.name == L"name") { + if (attribute.value.size() > 0) { + m_value = attribute.value; + NormalizeString(m_value); + } + } + } + + virtual void Verify() + { + // exception + DPL::String ignoreUri(L"file"); + + if (!m_value.IsNull() && *m_value == ignoreUri) + { + LogInfo("exception : '" << *m_value << "' scheme will be ignored."); + m_value = DPL::OptionalString::Null; + } + + if (m_value.IsNull() || *m_value == L"") { + return; + } + + DPL::String wildString(L"*/*"); + if ((m_data.m_uriList.find(wildString) == m_data.m_uriList.end()) + && (m_data.m_uriList.find(*m_value) == m_data.m_uriList.end())) + { + m_data.m_uriList.insert(*m_value); + } else { + LogDebug("Ignoring uri with name" << + DPL::ToUTF8String(*m_value)); + } + } + + UriParser(ConfigParserData::AppControlInfo& data) : + ElementParser(), + m_properNamespace(false), + m_data(data) + {} + + private: + bool m_properNamespace; + DPL::OptionalString m_value; + ConfigParserData::AppControlInfo& m_data; + }; + + struct MimeParser : public ElementParser + { + public: + virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, + const DPL::String& /*name*/) + { + return &IgnoringParser::Create; + } + + virtual void Accept(const Text& /*text*/) + {} + + virtual void Accept(const Element& /*element*/) + {} + + virtual void Accept(const XmlAttribute& attribute) + { + if (attribute.name == L"name") { + if (attribute.value.size() > 0) { + m_value = attribute.value; + NormalizeString(m_value); + } + } + } + + virtual void Verify() + { + if (m_value.IsNull() || *m_value == L"") { + return; + } + + DPL::String wildString(L"*/*"); + if ((m_data.m_mimeList.find(wildString) == + m_data.m_mimeList.end()) + && (m_data.m_mimeList.find(*m_value) == + m_data.m_mimeList.end())) + { + m_data.m_mimeList.insert(*m_value); + } else { + LogDebug("Ignoring mime with name" << + DPL::ToUTF8String(*m_value)); + } + } + + MimeParser(ConfigParserData::AppControlInfo& data) : + ElementParser(), + m_properNamespace(false), + m_data(data) + {} + + private: + bool m_properNamespace; + DPL::OptionalString m_value; + ConfigParserData::AppControlInfo& m_data; + }; + + virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, + const DPL::String& name) + { + if (name == L"src") { + return DPL::MakeDelegate(this, &AppControlParser::OnSourceElement); + } else if (name == L"operation") { + return DPL::MakeDelegate(this, + &AppControlParser::OnOperationElement); + } else if (name == L"uri") { + return DPL::MakeDelegate(this, &AppControlParser::OnUriElement); + } else if (name == L"mime") { + return DPL::MakeDelegate(this, &AppControlParser::OnMimeElement); + } else { + return &IgnoringParser::Create; + } + } + + virtual void Accept(const XmlAttribute& /*attribute*/) + {} + + virtual void Accept(const Element& element) + { + LogWarning("namespace for app service = " << element.ns); + if (element.ns == ConfigurationNamespace::W3CWidgetNamespaceName) { + ThrowMsg(Exception::ParseError, + "Wrong xml namespace for widget element"); + } + } + + virtual void Accept(const Text& /*text*/) + { + ThrowMsg(Exception::ParseError, "param element must be empty"); + } + + virtual void Verify() + { + if (m_appControl.m_src == L"") { + LogWarning("service element must have src element"); + return; + } + + if (m_appControl.m_operation == L"") { + LogWarning("service element must have operation element"); + return; + } + + m_data.appControlList.push_back(m_appControl); + } + + ElementParserPtr OnSourceElement() + { + return ElementParserPtr(new SourceParser(m_appControl)); + } + + ElementParserPtr OnOperationElement() + { + return ElementParserPtr(new OperationParser(m_appControl)); + } + + ElementParserPtr OnUriElement() + { return ElementParserPtr(new UriParser(m_appControl)); } @@ -1460,13 +1319,12 @@ class AppControlParser : public ElementParser { return ElementParserPtr(new MimeParser(m_appControl)); } - + AppControlParser(ConfigParserData& data) : ElementParser(), m_data(data), m_appControl(L"") - { - } + {} private: ConfigParserData& m_data; @@ -1477,12 +1335,12 @@ class ApplicationParser : public ElementParser { public: virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) + const DPL::String& /*name*/) { return &IgnoringParser::Create; } - virtual void Accept(const Text& text) + virtual void Accept(const Text& /*text*/) { if (m_properNamespace) { LogDebug("text"); @@ -1506,6 +1364,9 @@ class ApplicationParser : public ElementParser LogDebug("attribute"); if (attribute.name == L"id") { m_id = attribute.value; + NormalizeAndTrimSpaceString(m_id); + } else if (attribute.name == L"package") { + m_package = attribute.value; } else if (attribute.name == L"required_version") { m_version = attribute.value; NormalizeString(m_version); @@ -1520,18 +1381,22 @@ class ApplicationParser : public ElementParser virtual void Verify() { - if(!m_id) { + if (!m_id) { ThrowMsg(Exception::ParseError, "application element must have id attribute"); } - if(!m_version) { + if (!!m_package) { + m_data.tizenPkgId = m_package; + } + + if (!m_version) { ThrowMsg(Exception::ParseError, "application element must have required_version attribute"); } //TODO check if id and version format is right - m_data.tizenId = m_id; + m_data.tizenAppId = m_id; m_data.tizenMinVersionRequired = m_version; } @@ -1541,12 +1406,12 @@ class ApplicationParser : public ElementParser m_id(DPL::OptionalString::Null), m_version(DPL::OptionalString::Null), m_properNamespace(false) - { - } + {} private: ConfigParserData& m_data; DPL::OptionalString m_id; + DPL::OptionalString m_package; DPL::OptionalString m_version; bool m_properNamespace; }; @@ -1569,18 +1434,17 @@ class SplashParser : public ElementParser } } - virtual void Accept(const Element& element) - { - } + virtual void Accept(const Element& /*element*/) + {} virtual void Accept(const Text& /*text*/) - { - } + {} virtual void Verify() { if (m_src.IsNull()) { - LogWarning("src attribute of splash element is mandatory - ignoring"); + LogWarning( + "src attribute of splash element is mandatory - ignoring"); return; } @@ -1590,8 +1454,7 @@ class SplashParser : public ElementParser SplashParser(ConfigParserData& data) : ElementParser(), m_data(data) - { - } + {} private: DPL::OptionalString m_src; @@ -1617,17 +1480,16 @@ class BackgroundParser : public ElementParser } virtual void Accept(const Element& /*element*/) - { - } + {} virtual void Accept(const Text& /*text*/) - { - } + {} virtual void Verify() { if (m_src.IsNull()) { - LogWarning("src attribute of background element is mandatory - ignoring"); + LogWarning( + "src attribute of background element is mandatory - ignoring"); return; } @@ -1636,8 +1498,7 @@ class BackgroundParser : public ElementParser explicit BackgroundParser(ConfigParserData& data) : m_data(data) - { - } + {} private: DPL::OptionalString m_src; @@ -1648,14 +1509,13 @@ class PrivilegeParser : public ElementParser { public: virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& name) + const DPL::String& /*name*/) { return &IgnoringParser::Create; } virtual void Accept(const Text& /*text*/) - { - } + {} virtual void Accept(const Element& element) { @@ -1675,7 +1535,6 @@ class PrivilegeParser : public ElementParser m_privilege.name = attribute.value; } } - m_feature.required = false; } virtual void Verify() @@ -1685,11 +1544,12 @@ class PrivilegeParser : public ElementParser if (m_feature.name != L"") { if (iri.Validate()) { if (m_data.featuresList.find(m_feature) == - m_data.featuresList.end()) { + m_data.featuresList.end()) + { m_data.featuresList.insert(m_feature); } else { LogDebug("Ignoring feature with name" << - DPL::ToUTF8String(m_feature.name)); + DPL::ToUTF8String(m_feature.name)); } } } @@ -1700,7 +1560,8 @@ class PrivilegeParser : public ElementParser if (m_privilege.name != L"") { if (iriPrivilege.Validate()) { if (m_data.privilegeList.find(m_privilege) == - m_data.privilegeList.end()) { + m_data.privilegeList.end()) + { m_data.privilegeList.insert(m_privilege); } else { LogDebug("Ignoring privilege with name" << @@ -1716,8 +1577,7 @@ class PrivilegeParser : public ElementParser m_feature(L""), m_privilege(L""), m_properNamespace(false) - { - } + {} private: ConfigParserData& m_data; @@ -1745,56 +1605,54 @@ class CategoryParser : public ElementParser } virtual void Accept(const Element& /*element*/) - { - } + {} virtual void Accept(const Text& /*text*/) - { - } + {} virtual void Verify() { if (m_name.IsNull()) { - LogWarning("name attribute of category element is mandatory - ignoring"); + LogWarning( + "name attribute of category element is mandatory - ignoring"); return; } if (m_data.categoryList.find(*m_name) == - m_data.categoryList.end()) { + m_data.categoryList.end()) + { m_data.categoryList.insert(*m_name); } } explicit CategoryParser(ConfigParserData& data) : m_data(data) - { - } + {} private: DPL::OptionalString m_name; ConfigParserData& m_data; }; -class LiveboxParser : public ElementParser +class AppWidgetParser : public ElementParser { - public: + public: struct BoxLabelParser : public ElementParser { virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) + const DPL::String& /*name*/) { return &IgnoringParser::Create; } - virtual void Accept(const XmlAttribute& attribute) - { - } + virtual void Accept(const XmlAttribute& /*attribute*/) + {} virtual void Accept(const Element& element) { if (element.ns == - ConfigurationNamespace::TizenWebAppNamespaceName) + ConfigurationNamespace::TizenWebAppNamespaceName) { m_properNamespace = true; } @@ -1802,8 +1660,9 @@ class LiveboxParser : public ElementParser virtual void Accept(const Text& text) { - if(m_properNamespace) + if (m_properNamespace) { m_label = text.value; + } } virtual void Verify() @@ -1815,10 +1674,9 @@ class LiveboxParser : public ElementParser ElementParser(), m_properNamespace(false), m_data(data) - { - } + {} - private: + private: DPL::String m_label; bool m_properNamespace; ConfigParserData::LiveboxInfo& m_data; @@ -1827,14 +1685,14 @@ class LiveboxParser : public ElementParser struct BoxIconParser : public ElementParser { virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) + const DPL::String& /*name*/) { return &IgnoringParser::Create; } virtual void Accept(const XmlAttribute& attribute) { - if(m_properNamespace) { + if (m_properNamespace) { if (attribute.name == L"src") { m_icon = attribute.value; } @@ -1844,15 +1702,14 @@ class LiveboxParser : public ElementParser virtual void Accept(const Element& element) { if (element.ns == - ConfigurationNamespace::TizenWebAppNamespaceName) + ConfigurationNamespace::TizenWebAppNamespaceName) { m_properNamespace = true; } } virtual void Accept(const Text& /*text*/) - { - } + {} virtual void Verify() { @@ -1863,10 +1720,9 @@ class LiveboxParser : public ElementParser ElementParser(), m_properNamespace(false), m_data(data) - { - } + {} - private: + private: DPL::String m_icon; bool m_properNamespace; ConfigParserData::LiveboxInfo& m_data; @@ -1877,14 +1733,14 @@ class LiveboxParser : public ElementParser struct BoxSizeParser : public ElementParser { virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& /*name*/) + const DPL::String& /*name*/) { return &IgnoringParser::Create; } virtual void Accept(const XmlAttribute& attribute) { - if(m_properNamespace) { + if (m_properNamespace) { if (attribute.name == L"preview") { m_preview = attribute.value; } @@ -1894,7 +1750,7 @@ class LiveboxParser : public ElementParser virtual void Accept(const Element& element) { if (element.ns == - ConfigurationNamespace::TizenWebAppNamespaceName) + ConfigurationNamespace::TizenWebAppNamespaceName) { m_properNamespace = true; } @@ -1902,8 +1758,9 @@ class LiveboxParser : public ElementParser virtual void Accept(const Text& text) { - if(m_properNamespace) + if (m_properNamespace) { m_size = text.value; + } } virtual void Verify() @@ -1914,13 +1771,14 @@ class LiveboxParser : public ElementParser m_data.m_boxSize.push_back(boxSize); } - explicit BoxSizeParser(ConfigParserData::LiveboxInfo::BoxContentInfo& data) : + explicit BoxSizeParser( + ConfigParserData::LiveboxInfo::BoxContentInfo& data) : ElementParser(), + m_properNamespace(false), m_data(data) - { - } + {} - private: + private: DPL::String m_size; DPL::String m_preview; bool m_properNamespace; @@ -1930,14 +1788,14 @@ class LiveboxParser : public ElementParser struct PdParser : public ElementParser { virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& name) + const DPL::String& /*name*/) { return &IgnoringParser::Create; } virtual void Accept(const XmlAttribute& attribute) { - if(m_properNamespace) { + if (m_properNamespace) { if (attribute.name == L"src") { m_src = attribute.value; } else if (attribute.name == L"width") { @@ -1951,15 +1809,14 @@ class LiveboxParser : public ElementParser virtual void Accept(const Element& element) { if (element.ns == - ConfigurationNamespace::TizenWebAppNamespaceName) + ConfigurationNamespace::TizenWebAppNamespaceName) { m_properNamespace = true; } } virtual void Accept(const Text& /*text*/) - { - } + {} virtual void Verify() { @@ -1968,14 +1825,14 @@ class LiveboxParser : public ElementParser m_data.m_pdHeight = m_height; } - explicit PdParser(ConfigParserData::LiveboxInfo::BoxContentInfo& data) : + explicit PdParser( + ConfigParserData::LiveboxInfo::BoxContentInfo& data) : ElementParser(), m_properNamespace(false), m_data(data) - { - } + {} - private: + private: DPL::String m_src; DPL::String m_width; DPL::String m_height; @@ -1985,37 +1842,50 @@ class LiveboxParser : public ElementParser }; virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& name) + const DPL::String& name) { if (name == L"box-size") { - return DPL::MakeDelegate(this, &LiveboxParser::BoxContentParser::OnBoxSizeElement); + return DPL::MakeDelegate( + this, + &AppWidgetParser::BoxContentParser:: + OnBoxSizeElement); } else if (name == L"pd") { - return DPL::MakeDelegate(this, &LiveboxParser::BoxContentParser::OnPdElement); - } else{ - ThrowMsg(Exception::ParseError, "No element parser for name: " << name); + return DPL::MakeDelegate( + this, + &AppWidgetParser::BoxContentParser:: + OnPdElement); + } else { + ThrowMsg(Exception::ParseError, + "No element parser for name: " << name); } } virtual void Accept(const XmlAttribute& attribute) { if (m_properNamespace) { - if (attribute.name == L"src") + if (attribute.name == L"src") { m_box.m_boxSrc = attribute.value; + } + if (attribute.name == L"mouse-event") { + m_box.m_boxMouseEvent = attribute.value; + } + if (attribute.name == L"touch-effect") { + m_box.m_boxTouchEffect = attribute.value; + } } } virtual void Accept(const Element& element) { if (element.ns == - ConfigurationNamespace::TizenWebAppNamespaceName) + ConfigurationNamespace::TizenWebAppNamespaceName) { m_properNamespace = true; } } virtual void Accept(const Text& /*text*/) - { - } + {} virtual void Verify() { @@ -2026,8 +1896,7 @@ class LiveboxParser : public ElementParser ElementParser(), m_properNamespace(false), m_data(data) - { - } + {} ElementParserPtr OnBoxSizeElement() { @@ -2039,7 +1908,7 @@ class LiveboxParser : public ElementParser return ElementParserPtr(new PdParser(m_box)); } - private: + private: DPL::String m_src; bool m_properNamespace; ConfigParserData::LiveboxInfo& m_data; @@ -2047,14 +1916,14 @@ class LiveboxParser : public ElementParser }; virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, - const DPL::String& name) + const DPL::String& name) { if (name == L"box-label") { - return DPL::MakeDelegate(this, &LiveboxParser::OnBoxLabelElement); + return DPL::MakeDelegate(this, &AppWidgetParser::OnBoxLabelElement); } else if (name == L"box-icon") { - return DPL::MakeDelegate(this, &LiveboxParser::OnBoxIconElement); - } else if (name == L"box-content") { - return DPL::MakeDelegate(this, &LiveboxParser::OnBoxContentElement); + return DPL::MakeDelegate(this, &AppWidgetParser::OnBoxIconElement); + } else if (name == L"box-content") { + return DPL::MakeDelegate(this, &AppWidgetParser::OnBoxContentElement); } else { return &IgnoringParser::Create; } @@ -2071,6 +1940,8 @@ class LiveboxParser : public ElementParser m_autoLaunch = attribute.value; } else if (attribute.name == L"update-period") { m_updatePeriod = attribute.value; + } else if (attribute.name == L"type") { + m_type = attribute.value; } } } @@ -2078,15 +1949,14 @@ class LiveboxParser : public ElementParser virtual void Accept(const Element& element) { if (element.ns == - ConfigurationNamespace::TizenWebAppNamespaceName) + ConfigurationNamespace::TizenWebAppNamespaceName) { m_properNamespace = true; } } virtual void Accept(const Text& /*text*/) - { - } + {} virtual void Verify() { @@ -2094,11 +1964,12 @@ class LiveboxParser : public ElementParser m_livebox.m_primary = m_primary; m_livebox.m_autoLaunch = m_autoLaunch; m_livebox.m_updatePeriod = m_updatePeriod; + m_livebox.m_type = m_type; m_data.m_livebox.push_back(m_livebox); } - explicit LiveboxParser(ConfigParserData& data) : + explicit AppWidgetParser(ConfigParserData& data) : ElementParser(), m_data(data), m_properNamespace(false) @@ -2128,13 +1999,376 @@ class LiveboxParser : public ElementParser DPL::String m_primary; DPL::String m_autoLaunch; DPL::String m_updatePeriod; + DPL::String m_type; bool m_properNamespace; +}; + +class CspParser : public ElementParser +{ + public: + virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, + const DPL::String& /*name*/) + { + return &IgnoringParser::Create; + } + + CspParser(ConfigParserData& data) : + ElementParser(), + m_data(data), + m_properNamespace(false) + {} + + virtual void Accept(const Element& element) + { + if (element.ns == ConfigurationNamespace::TizenWebAppNamespaceName) { + m_properNamespace = true; + } + } + virtual void Accept(const XmlAttribute& /*attribute*/) + {} + + virtual void Accept(const Text& text) + { + if (m_properNamespace) { + m_policy = text.value; + } + } + + virtual void Verify() + { + if (!m_policy.IsNull()) { + m_data.cspPolicy = *m_policy; + } + } + + private: + ConfigParserData& m_data; + bool m_properNamespace; + DPL::OptionalString m_policy; }; +class CspReportOnlyParser : public ElementParser +{ + public: + virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, + const DPL::String& /*name*/) + { + return &IgnoringParser::Create; + } + + CspReportOnlyParser(ConfigParserData& data) : + ElementParser(), + m_data(data), + m_properNamespace(false) + {} + + virtual void Accept(const Element& element) + { + if (element.ns == ConfigurationNamespace::TizenWebAppNamespaceName) { + m_properNamespace = true; + } + } + + virtual void Accept(const XmlAttribute& /*attribute*/) + {} + + virtual void Accept(const Text& text) + { + if (m_properNamespace) { + m_policy = text.value; + } + } + + virtual void Verify() + { + if (!m_policy.IsNull()) { + m_data.cspPolicyReportOnly = *m_policy; + } + } -ElementParser::ActionFunc WidgetParser::GetElementParser(const DPL::String& /*ns*/, - const DPL::String& name) + private: + ConfigParserData& m_data; + bool m_properNamespace; + DPL::OptionalString m_policy; +}; + +class AccountParser : public ElementParser +{ + public: + struct AccountProviderParser : public ElementParser + { + public: + + struct IconParser : public ElementParser + { + public: + virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, + const DPL::String& /*name*/) + { + return &IgnoringParser::Create; + } + + virtual void Accept(const Text& text) + { + if (text.value == L"") { + return; + } + m_value = text.value; + } + + virtual void Accept(const Element& /*element*/) + {} + + virtual void Accept(const XmlAttribute& attribute) + { + if (attribute.name == L"section") { + if (attribute.value == L"account") { + m_type = ConfigParserData::IconSectionType::DefaultIcon; + } else if (attribute.value == L"account-small") { + m_type = ConfigParserData::IconSectionType::SmallIcon; + } + } + } + + virtual void Verify() + { + if (m_value.IsNull() || *m_value == L"") { + return; + } + + std::pair icon; + icon.first = m_type; + icon.second = *m_value; + + m_data.m_iconSet.insert(icon); + } + + IconParser(ConfigParserData::AccountProvider& data) : + ElementParser(), + m_properNamespace(false), + m_type(ConfigParserData::DefaultIcon), + m_data(data) + {} + + private: + bool m_properNamespace; + ConfigParserData::IconSectionType m_type; + ConfigParserData::AccountProvider& m_data; + DPL::OptionalString m_value; + }; + + struct DisplayNameParser : public ElementParser + { + public: + virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, + const DPL::String& /*name*/) + { + return &IgnoringParser::Create; + } + + virtual void Accept(const Text& text) + { + if (text.value == L"") { + return; + } + m_value = text.value; + } + + virtual void Accept(const Element& element) + { + m_lang = element.lang; + m_value= L""; + } + + virtual void Accept(const XmlAttribute& /*attribute*/) + {} + + virtual void Verify() + { + if (m_value.IsNull() || *m_value == L"") { + return; + } + + std::pair name; + name.first = *m_lang; + name.second = *m_value; + + m_data.m_displayNameSet.insert(name); + } + + DisplayNameParser(ConfigParserData::AccountProvider& data) : + ElementParser(), + m_properNamespace(false), + m_data(data) + {} + + private: + bool m_properNamespace; + DPL::OptionalString m_lang; + DPL::OptionalString m_value; + ConfigParserData::AccountProvider& m_data; + }; + + struct CapabilityParser : public ElementParser + { + public: + virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, + const DPL::String& /*name*/) + { + return &IgnoringParser::Create; + } + + virtual void Accept(const Text& text) + { + if (text.value == L"") { + return; + } + m_value = text.value; + } + + virtual void Accept(const Element& /*element*/) + {} + + virtual void Accept(const XmlAttribute& /*attribute*/) + {} + + virtual void Verify() + { + if (m_value.IsNull() || *m_value == L"") { + return; + } + m_data.m_capabilityList.push_back(*m_value); + } + + CapabilityParser(ConfigParserData::AccountProvider& data) : + ElementParser(), + m_properNamespace(false), + m_data(data) + {} + + private: + bool m_properNamespace; + DPL::OptionalString m_value; + ConfigParserData::AccountProvider& m_data; + }; + virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, + const DPL::String& name) + { + if (name == L"icon") { + return DPL::MakeDelegate(this, &AccountProviderParser::OnIconElement); + } else if (name == L"display-name") { + return DPL::MakeDelegate(this, + &AccountProviderParser::OnDisplayNameElement); + } else if (name == L"capability") { + return DPL::MakeDelegate(this, &AccountProviderParser::OnCapabilityElement); + } else { + return &IgnoringParser::Create; + } + } + + virtual void Accept(const Text& /*text*/) + {} + + virtual void Accept(const Element& /*element*/) + {} + + virtual void Accept(const XmlAttribute& attribute) + { + if (attribute.name == L"multiple-accounts-support") { + if (attribute.value == L"") { + return; + } + + if (attribute.value == L"ture") { + m_multiSupport = true; + } + } + } + + virtual void Verify() + { + m_data.m_multiAccountSupport = m_multiSupport; + } + + ElementParserPtr OnIconElement() + { + return ElementParserPtr(new IconParser(m_data)); + } + + ElementParserPtr OnDisplayNameElement() + { + return ElementParserPtr(new DisplayNameParser(m_data)); + } + + ElementParserPtr OnCapabilityElement() + { + return ElementParserPtr(new CapabilityParser(m_data)); + } + + AccountProviderParser(ConfigParserData::AccountProvider& data) : + ElementParser(), + m_properNamespace(false), + m_multiSupport(false), + m_data(data) + {} + + private: + bool m_properNamespace; + bool m_multiSupport; + ConfigParserData::AccountProvider& m_data; + }; + + virtual ActionFunc GetElementParser(const DPL::String& /*ns*/, + const DPL::String& name) + { + if (name == L"account-provider") { + return DPL::MakeDelegate(this, &AccountParser::OnProviderElement); + } else { + return &IgnoringParser::Create; + } + } + + virtual void Accept(const Element& element) + { + if (element.ns == ConfigurationNamespace::TizenWebAppNamespaceName) { + m_properNamespace = true; + } + } + + virtual void Accept(const XmlAttribute& /*attribute*/) + {} + + virtual void Accept(const Text& /*text*/) + {} + + virtual void Verify() + {} + + ElementParserPtr OnProviderElement() + { + return ElementParserPtr(new AccountProviderParser(m_account)); + } + + AccountParser(ConfigParserData& data) : + ElementParser(), + m_data(data), + m_account(data.accountProvider), + m_properNamespace(false), + m_multiSupport(false) + {} + + private: + ConfigParserData& m_data; + ConfigParserData::AccountProvider& m_account; + bool m_properNamespace; + bool m_multiSupport; +}; + +ElementParser::ActionFunc WidgetParser::GetElementParser( + const DPL::String& /*ns*/, + const DPL::String& + name) { FuncMap::const_iterator it = m_map.find(name); if (it != m_map.end()) { @@ -2158,25 +2392,41 @@ WidgetParser::WidgetParser(ConfigParserData& data) : m_map[L"icon"] = DPL::MakeDelegate(this, &WidgetParser::OnIconElement); m_map[L"content"] = DPL::MakeDelegate(this, &WidgetParser::OnContentElement); - m_map[L"feature"] = - DPL::MakeDelegate(this, &WidgetParser::OnFeatureElement); m_map[L"preference"] = DPL::MakeDelegate(this, &WidgetParser::OnPreferenceElement); m_map[L"link"] = DPL::MakeDelegate(this, &WidgetParser::OnLinkElement); m_map[L"setting"] = DPL::MakeDelegate(this, &WidgetParser::OnSettingElement); // TODO: appservice will be removed - m_map[L"appservice"] = DPL::MakeDelegate(this, &WidgetParser::OnAppServiceElement); - m_map[L"application"] = DPL::MakeDelegate(this, &WidgetParser::OnApplicationElement); + m_map[L"appservice"] = DPL::MakeDelegate(this, + &WidgetParser::OnAppServiceElement); + m_map[L"application"] = DPL::MakeDelegate( + this, + &WidgetParser:: + OnApplicationElement); m_map[L"splash"] = DPL::MakeDelegate(this, &WidgetParser::OnSplashElement); - m_map[L"background"] = DPL::MakeDelegate(this, &WidgetParser::OnBackgroundElement); - m_map[L"privilege"] = DPL::MakeDelegate(this, &WidgetParser::OnPrivilegeElement); - m_map[L"app-control"] = DPL::MakeDelegate(this, - &WidgetParser::OnAppControlElement); + m_map[L"background"] = DPL::MakeDelegate(this, + &WidgetParser::OnBackgroundElement); + m_map[L"privilege"] = DPL::MakeDelegate(this, + &WidgetParser::OnPrivilegeElement); + m_map[L"app-control"] = DPL::MakeDelegate( + this, + &WidgetParser:: + OnAppControlElement); m_map[L"category"] = DPL::MakeDelegate(this, - &WidgetParser::OnCategoryElement); - m_map[L"livebox"] = DPL::MakeDelegate(this, &WidgetParser::OnLiveboxElement); - + &WidgetParser::OnCategoryElement); + m_map[L"app-widget"] = DPL::MakeDelegate(this, &WidgetParser::OnAppWidgetElement); +#ifdef CSP_ENABLED + m_map[L"content-security-policy"] = DPL::MakeDelegate( + this, + &WidgetParser:: + OnCspElement); + m_map[L"content-security-policy-report-only"] = DPL::MakeDelegate( + this, + &WidgetParser:: + OnCspReportOnlyElement); +#endif + m_map[L"account"] = DPL::MakeDelegate(this, &WidgetParser::OnAccountElement); } ElementParserPtr WidgetParser::OnNameElement() @@ -2214,11 +2464,6 @@ ElementParserPtr WidgetParser::OnContentElement() return ElementParserPtr(new ContentParser(m_data)); } -ElementParserPtr WidgetParser::OnFeatureElement() -{ - return ElementParserPtr(new FeatureParser(m_data)); -} - ElementParserPtr WidgetParser::OnPreferenceElement() { return ElementParserPtr(new PreferenceParser(m_data)); @@ -2269,9 +2514,24 @@ ElementParserPtr WidgetParser::OnCategoryElement() return ElementParserPtr(new CategoryParser(m_data)); } -ElementParserPtr WidgetParser::OnLiveboxElement() +ElementParserPtr WidgetParser::OnAppWidgetElement() { - return ElementParserPtr(new LiveboxParser(m_data)); + return ElementParserPtr(new AppWidgetParser(m_data)); +} + +ElementParserPtr WidgetParser::OnCspElement() +{ + return ElementParserPtr(new CspParser(m_data)); +} + +ElementParserPtr WidgetParser::OnCspReportOnlyElement() +{ + return ElementParserPtr(new CspReportOnlyParser(m_data)); +} + +ElementParserPtr WidgetParser::OnAccountElement() +{ + return ElementParserPtr(new AccountParser(m_data)); } void WidgetParser::Accept(const Element& element) @@ -2364,26 +2624,27 @@ void WidgetParser::Accept(const XmlAttribute& attribute) m_defaultlocale = attribute.value; NormalizeString(m_defaultlocale); if (!LanguageSubtagRstTreeSingleton::Instance().ValidateLanguageTag( - DPL::ToUTF8String(*m_defaultlocale))) { + DPL::ToUTF8String(*m_defaultlocale))) + { LogWarning("Language tag: " << m_defaultlocale << " is not valid"); m_defaultlocale = DPL::OptionalString::Null; - } - else + } else { LogDebug("Default Locale Found " << m_defaultlocale); + } } else { LogWarning("Ignoring subsequent default locale"); } - //Any other value consider as a namespace definition + //Any other value consider as a namespace definition } else if (attribute.name == L"xmlns" || attribute.prefix == L"xmlns") { LogInfo("Namespace domain: " << attribute.name); LogInfo("Namespace value: " << attribute.value); m_nameSpaces[attribute.name] = attribute.value; } else { LogError("Unknown attirbute: namespace=" << attribute.ns << - ", name=" << attribute.name << - ", value=" << attribute.value); + ", name=" << attribute.name << + ", value=" << attribute.value); } } @@ -2392,7 +2653,8 @@ void WidgetParser::Verify() FOREACH(mode, m_windowModes) { if (L"windowed" == *mode || L"floating" == *mode || L"fullscreen" == *mode || L"maximized" == *mode || - L"minimized" == *mode) { + L"minimized" == *mode) + { m_data.windowModes.insert(*mode); } }