1 // Copyright (c) 2014 Intel Corporation. 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.
5 #include "xwalk/application/common/manifest_handlers/widget_handler.h"
11 #include "base/strings/utf_string_conversions.h"
12 #include "base/strings/stringprintf.h"
13 #include "base/strings/string_split.h"
14 #include "xwalk/application/common/application_manifest_constants.h"
18 namespace keys = application_widget_keys;
21 // Below key names are readable from Javascript widget interface.
22 const char kAuthor[] = "author";
23 const char kDecription[] = "description";
24 const char kName[] = "name";
25 const char kShortName[] = "shortName";
26 const char kVersion[] = "version";
27 const char kID[] = "id";
28 const char kAuthorEmail[] = "authorEmail";
29 const char kAuthorHref[] = "authorHref";
30 const char kHeight[] = "height";
31 const char kWidth[] = "width";
32 const char kPreferences[] = "preferences";
34 // Child keys inside 'preferences' key.
35 const char kPreferencesName[] = "name";
36 const char kPreferencesValue[] = "value";
37 const char kPreferencesReadonly[] = "readonly";
39 typedef std::map<std::string, std::string> KeyMap;
40 typedef std::map<std::string, std::string>::const_iterator KeyMapIterator;
41 typedef std::pair<std::string, std::string> KeyPair;
43 const KeyMap& GetWidgetKeyPairs() {
46 map.insert(KeyPair(keys::kAuthorKey, kAuthor));
47 map.insert(KeyPair(keys::kDescriptionKey, kDecription));
48 map.insert(KeyPair(keys::kNameKey, kName));
49 map.insert(KeyPair(keys::kShortNameKey, kShortName));
50 map.insert(KeyPair(keys::kVersionKey, kVersion));
51 map.insert(KeyPair(keys::kIDKey, kID));
52 map.insert(KeyPair(keys::kAuthorEmailKey, kAuthorEmail));
53 map.insert(KeyPair(keys::kAuthorHrefKey, kAuthorHref));
54 map.insert(KeyPair(keys::kHeightKey, kHeight));
55 map.insert(KeyPair(keys::kWidthKey, kWidth));
61 bool ParsePreferenceItem(const base::DictionaryValue* in_value,
62 base::DictionaryValue* out_value,
63 std::set<std::string>* used) {
64 DCHECK(in_value && in_value->IsType(base::Value::TYPE_DICTIONARY));
66 std::string pref_name;
67 std::string pref_value;
68 std::string pref_readonly;
69 if (in_value->GetString(keys::kPreferencesNameKey, &pref_name)
70 && used->find(pref_name) == used->end()) {
71 out_value->SetString(kPreferencesName, pref_name);
72 used->insert(pref_name);
77 if (in_value->GetString(keys::kPreferencesValueKey, &pref_value))
78 out_value->SetString(kPreferencesValue, pref_value);
80 if (in_value->GetString(keys::kPreferencesReadonlyKey, &pref_readonly))
81 out_value->SetBoolean(kPreferencesReadonly, pref_readonly == "true");
87 namespace application {
89 WidgetInfo::WidgetInfo()
90 : value_(new base::DictionaryValue) {}
92 WidgetInfo::~WidgetInfo() {}
94 void WidgetInfo::SetString(const std::string& key, const std::string& value) {
95 value_->SetString(key, value);
98 void WidgetInfo::Set(const std::string& key, base::Value* value) {
99 value_->Set(key, value);
102 void WidgetInfo::SetName(const std::string& name) {
103 value_->SetString(kName, name);
106 void WidgetInfo::SetShortName(const std::string& short_name) {
107 value_->SetString(kShortName, short_name);
110 void WidgetInfo::SetDescription(const std::string& description) {
111 value_->SetString(kDecription, description);
114 WidgetHandler::WidgetHandler() {}
116 WidgetHandler::~WidgetHandler() {}
118 bool WidgetHandler::Parse(scoped_refptr<ApplicationData> application,
119 base::string16* error) {
120 scoped_ptr<WidgetInfo> widget_info(new WidgetInfo);
121 const Manifest* manifest = application->GetManifest();
124 const KeyMap& map = GetWidgetKeyPairs();
126 for (KeyMapIterator iter = map.begin(); iter != map.end(); ++iter) {
128 bool result = manifest->GetString(iter->first, &string);
129 if (result && !string.empty() && iter->first == keys::kAuthorHrefKey &&
130 !GURL(string).is_valid())
131 // When authorhref is an invalid URI, reset it an empty string.
133 widget_info->SetString(iter->second, result ? string : "");
136 base::Value* pref_value = NULL;
137 manifest->Get(keys::kPreferencesKey, &pref_value);
139 std::set<std::string> preference_names_used;
140 if (pref_value && pref_value->IsType(base::Value::TYPE_DICTIONARY)) {
141 base::DictionaryValue* preferences = new base::DictionaryValue;
142 base::DictionaryValue* dict;
143 pref_value->GetAsDictionary(&dict);
144 if (ParsePreferenceItem(dict, preferences, &preference_names_used))
145 widget_info->Set(kPreferences, preferences);
146 } else if (pref_value && pref_value->IsType(base::Value::TYPE_LIST)) {
147 base::ListValue* preferences = new base::ListValue;
148 base::ListValue* list;
149 pref_value->GetAsList(&list);
151 for (base::ListValue::iterator it = list->begin();
152 it != list->end(); ++it) {
153 base::DictionaryValue* pref = new base::DictionaryValue;
154 base::DictionaryValue* dict;
155 (*it)->GetAsDictionary(&dict);
156 if (ParsePreferenceItem(dict, pref, &preference_names_used))
157 preferences->Append(pref);
159 widget_info->Set(kPreferences, preferences);
162 application->SetManifestData(keys::kWidgetKey, widget_info.release());
166 bool WidgetHandler::Validate(
167 scoped_refptr<const ApplicationData> application,
168 std::string* error) const {
169 const Manifest* manifest = application->GetManifest();
171 std::string ns_value;
172 manifest->GetString(keys::kWidgetNamespaceKey, &ns_value);
173 if (base::strcasecmp(keys::kWidgetNamespacePrefix, ns_value.c_str()) != 0) {
174 *error = std::string("The widget namespace is invalid.");
180 bool WidgetHandler::AlwaysParseForType(Manifest::Type type) const {
184 std::vector<std::string> WidgetHandler::Keys() const {
185 return std::vector<std::string>(1, keys::kWidgetKey);
188 } // namespace application