src/xwalk/application/common/manifest_handlers/tizen_metadata_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/tizen_metadata_handler.h"
   6
   7 #include <map>
   8 #include <utility>
   9
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "base/values.h"
  12 #include "xwalk/application/common/application_manifest_constants.h"
  13
  14 namespace xwalk {
  15
  16 namespace keys = application_widget_keys;
  17
  18 typedef std::pair<std::string, std::string> MetaDataPair;
  19 typedef std::map<std::string, std::string> MetaDataMap;
  20 typedef std::map<std::string, std::string>::const_iterator MetaDataIter;
  21
  22 namespace {
  23
  24 MetaDataPair ParseMetaDataItem(const base::DictionaryValue* dict,
  25                                base::string16* error) {
  26   DCHECK(dict && dict->IsType(base::Value::TYPE_DICTIONARY));
  27   MetaDataPair result;
  28   if (!dict->GetString(keys::kTizenMetaDataNameKey, &result.first) ||
  29       !dict->GetString(keys::kTizenMetaDataValueKey, &result.second)) {
  30     *error = base::ASCIIToUTF16("Invalid key/value of tizen metaData.");
  31   }
  32
  33   return result;
  34 }
  35 }  // namespace
  36
  37 namespace application {
  38
  39 TizenMetaDataInfo::TizenMetaDataInfo() {}
  40
  41 TizenMetaDataInfo::~TizenMetaDataInfo() {}
  42
  43 bool TizenMetaDataInfo::HasKey(const std::string& key) const {
  44   return metadata_.find(key) != metadata_.end();
  45 }
  46
  47 std::string TizenMetaDataInfo::GetValue(const std::string& key) const {
  48   MetaDataIter it = metadata_.find(key);
  49   if (it != metadata_.end())
  50     return it->second;
  51   return std::string("");
  52 }
  53
  54 void TizenMetaDataInfo::SetValue(const std::string& key,
  55                                  const std::string& value) {
  56   metadata_.insert(MetaDataPair(key, value));
  57 }
  58
  59 TizenMetaDataHandler::TizenMetaDataHandler() {}
  60
  61 TizenMetaDataHandler::~TizenMetaDataHandler() {}
  62
  63 bool TizenMetaDataHandler::Parse(scoped_refptr<ApplicationData> application,
  64                                  base::string16* error) {
  65   scoped_ptr<TizenMetaDataInfo> metadata_info(new TizenMetaDataInfo);
  66   const Manifest* manifest = application->GetManifest();
  67   DCHECK(manifest);
  68
  69   base::Value* metadata_value = NULL;
  70   if (!manifest->Get(keys::kTizenMetaDataKey, &metadata_value)) {
  71     *error = base::ASCIIToUTF16("Failed to get value of tizen metaData");
  72   }
  73
  74   MetaDataPair metadata_item;
  75   if (metadata_value && metadata_value->IsType(base::Value::TYPE_DICTIONARY)) {
  76     base::DictionaryValue* dict;
  77     metadata_value->GetAsDictionary(&dict);
  78     metadata_item = ParseMetaDataItem(dict, error);
  79     metadata_info->SetValue(metadata_item.first, metadata_item.second);
  80   } else if (metadata_value && metadata_value->IsType(base::Value::TYPE_LIST)) {
  81     base::ListValue* list;
  82     metadata_value->GetAsList(&list);
  83
  84     for (base::ListValue::iterator it = list->begin();
  85          it != list->end(); ++it) {
  86       base::DictionaryValue* dict;
  87       (*it)->GetAsDictionary(&dict);
  88       metadata_item = ParseMetaDataItem(dict, error);
  89       metadata_info->SetValue(metadata_item.first, metadata_item.second);
  90     }
  91   }
  92
  93   application->SetManifestData(keys::kTizenMetaDataKey,
  94                                metadata_info.release());
  95   return true;
  96 }
  97
  98 std::vector<std::string> TizenMetaDataHandler::Keys() const {
  99   return std::vector<std::string>(1, keys::kTizenMetaDataKey);
 100 }
 101
 102 }  // namespace application
 103 }  // namespace xwalk