src/xwalk/application/common/manifest_handlers/widget_handler.cc

   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.
   4
   5 #include "xwalk/application/common/manifest_handlers/widget_handler.h"
   6
   7 #include <map>
   8 #include <utility>
   9 #include <vector>
  10
  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"
  15
  16 namespace xwalk {
  17
  18 namespace keys = application_widget_keys;
  19
  20 namespace {
  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";
  33
  34 // Child keys inside 'preferences' key.
  35 const char kPreferencesName[] = "name";
  36 const char kPreferencesValue[] = "value";
  37 const char kPreferencesReadonly[] = "readonly";
  38
  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;
  42
  43 const KeyMap& GetWidgetKeyPairs() {
  44   static KeyMap map;
  45   if (map.empty()) {
  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));
  56   }
  57
  58   return map;
  59 }
  60
  61 void ParsePreferenceItem(const base::DictionaryValue* in_value,
  62                          base::DictionaryValue* out_value) {
  63   DCHECK(in_value && in_value->IsType(base::Value::TYPE_DICTIONARY));
  64
  65   std::string pref_name;
  66   std::string pref_value;
  67   std::string pref_readonly;
  68   if (in_value->GetString(keys::kPreferencesNameKey, &pref_name))
  69     out_value->SetString(kPreferencesName, pref_name);
  70
  71   if (in_value->GetString(keys::kPreferencesValueKey, &pref_value))
  72     out_value->SetString(kPreferencesValue, pref_value);
  73
  74   if (in_value->GetString(keys::kPreferencesReadonlyKey, &pref_readonly)) {
  75       out_value->SetBoolean(kPreferencesReadonly, pref_readonly == "true");
  76   }
  77 }
  78
  79 }  // namespace
  80
  81 namespace application {
  82
  83 WidgetInfo::WidgetInfo()
  84     : value_(new base::DictionaryValue) {}
  85
  86 WidgetInfo::~WidgetInfo() {}
  87
  88 void WidgetInfo::SetString(const std::string& key, const std::string& value) {
  89   value_->SetString(key, value);
  90 }
  91
  92 void WidgetInfo::Set(const std::string& key, base::Value* value) {
  93   value_->Set(key, value);
  94 }
  95
  96 void WidgetInfo::SetName(const std::string& name) {
  97   value_->SetString(kName, name);
  98 }
  99
 100 void WidgetInfo::SetShortName(const std::string& short_name) {
 101   value_->SetString(kShortName, short_name);
 102 }
 103
 104 void WidgetInfo::SetDescription(const std::string& description) {
 105   value_->SetString(kDecription, description);
 106 }
 107
 108 WidgetHandler::WidgetHandler() {}
 109
 110 WidgetHandler::~WidgetHandler() {}
 111
 112 bool WidgetHandler::Parse(scoped_refptr<ApplicationData> application,
 113                           base::string16* error) {
 114   scoped_ptr<WidgetInfo> widget_info(new WidgetInfo);
 115   const Manifest* manifest = application->GetManifest();
 116   DCHECK(manifest);
 117
 118   const KeyMap& map = GetWidgetKeyPairs();
 119
 120   for (KeyMapIterator iter = map.begin(); iter != map.end(); ++iter) {
 121     std::string string;
 122     manifest->GetString(iter->first, &string);
 123     widget_info->SetString(iter->second, string);
 124   }
 125
 126   base::Value* pref_value = NULL;
 127   manifest->Get(keys::kPreferencesKey, &pref_value);
 128
 129   if (pref_value && pref_value->IsType(base::Value::TYPE_DICTIONARY)) {
 130     base::DictionaryValue* preferences = new base::DictionaryValue;
 131     base::DictionaryValue* dict;
 132     pref_value->GetAsDictionary(&dict);
 133     ParsePreferenceItem(dict, preferences);
 134     widget_info->Set(kPreferences, preferences);
 135   } else if (pref_value && pref_value->IsType(base::Value::TYPE_LIST)) {
 136     base::ListValue* preferences = new base::ListValue;
 137     base::ListValue* list;
 138     pref_value->GetAsList(&list);
 139
 140     for (base::ListValue::iterator it = list->begin();
 141          it != list->end(); ++it) {
 142       base::DictionaryValue* pref = new base::DictionaryValue;
 143       base::DictionaryValue* dict;
 144       (*it)->GetAsDictionary(&dict);
 145       ParsePreferenceItem(dict, pref);
 146       preferences->Append(pref);
 147     }
 148     widget_info->Set(kPreferences, preferences);
 149   }
 150
 151   application->SetManifestData(keys::kWidgetKey, widget_info.release());
 152   return true;
 153 }
 154
 155 bool WidgetHandler::AlwaysParseForType(Manifest::Type type) const {
 156   return true;
 157 }
 158
 159 std::vector<std::string> WidgetHandler::Keys() const {
 160   return std::vector<std::string>(1, keys::kWidgetKey);
 161 }
 162
 163 }  // namespace application
 164 }  // namespace xwalk