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

   1 // Copyright (c) 2014 Samsung Electronics Co., Ltd 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_app_control_handler.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "base/third_party/xdg_mime/xdgmime.h"
  10 #include "base/values.h"
  11 #include "xwalk/application/common/application_manifest_constants.h"
  12
  13 namespace xwalk {
  14
  15 namespace keys = application_widget_keys;
  16
  17 namespace application {
  18
  19 namespace {
  20
  21 void ParseAppControlEntryAndStore(const base::DictionaryValue& control_dict,
  22     AppControlInfoList* aplist) {
  23   std::string src;
  24   const base::DictionaryValue* src_dict;
  25   if (control_dict.GetDictionary(keys::kTizenApplicationAppControlSrcKey,
  26       &src_dict)) {
  27     src_dict->GetString(
  28         keys::kTizenApplicationAppControlChildNameAttrKey, &src);
  29   }
  30
  31   std::string operation;
  32   const base::DictionaryValue* operation_dict;
  33   if (control_dict.GetDictionary(
  34       keys::kTizenApplicationAppControlOperationKey,
  35       &operation_dict)) {
  36     operation_dict->GetString(
  37         keys::kTizenApplicationAppControlChildNameAttrKey, &operation);
  38   }
  39
  40   std::string uri;
  41   const base::DictionaryValue* uri_dict;
  42   if (control_dict.GetDictionary(keys::kTizenApplicationAppControlUriKey,
  43       &uri_dict)) {
  44     uri_dict->GetString(
  45         keys::kTizenApplicationAppControlChildNameAttrKey, &uri);
  46   }
  47
  48   std::string mime;
  49   const base::DictionaryValue* mime_dict;
  50   if (control_dict.GetDictionary(keys::kTizenApplicationAppControlMimeKey,
  51       &mime_dict)) {
  52     mime_dict->GetString(
  53         keys::kTizenApplicationAppControlChildNameAttrKey, &mime);
  54   }
  55
  56   aplist->controls.emplace_back(src, operation, uri, mime);
  57 }
  58
  59 }  // namespace
  60
  61 TizenAppControlHandler::TizenAppControlHandler() {
  62 }
  63
  64 TizenAppControlHandler::~TizenAppControlHandler() {
  65 }
  66
  67 bool TizenAppControlHandler::Parse(scoped_refptr<ApplicationData> application,
  68     base::string16* error) {
  69   const Manifest* manifest = application->GetManifest();
  70   scoped_ptr<AppControlInfoList> aplist(new AppControlInfoList());
  71   base::Value* value;
  72   manifest->Get(keys::kTizenApplicationAppControlsKey, &value);
  73
  74   if (value->GetType() == base::Value::TYPE_LIST) {
  75     // multiple entries
  76     const base::ListValue* list;
  77     value->GetAsList(&list);
  78     for (const auto& item : *list) {
  79       const base::DictionaryValue* control_dict;
  80       if (!item->GetAsDictionary(&control_dict)) {
  81         *error = base::ASCIIToUTF16("Parsing app-control element failed");
  82         return false;
  83       }
  84
  85       ParseAppControlEntryAndStore(*control_dict, aplist.get());
  86     }
  87   } else if (value->GetType() == base::Value::TYPE_DICTIONARY) {
  88     // single entry
  89     const base::DictionaryValue* dict;
  90     value->GetAsDictionary(&dict);
  91     ParseAppControlEntryAndStore(*dict, aplist.get());
  92   } else {
  93     *error = base::ASCIIToUTF16("Cannot parsing app-control element");
  94     return false;
  95   }
  96
  97   application->SetManifestData(
  98       keys::kTizenApplicationAppControlsKey,
  99       aplist.release());
 100   return true;
 101 }
 102
 103 bool TizenAppControlHandler::Validate(
 104     scoped_refptr<const ApplicationData> application,
 105     std::string* error) const {
 106   const AppControlInfoList* app_controls =
 107       static_cast<const AppControlInfoList*>(
 108           application->GetManifestData(keys::kTizenApplicationAppControlsKey));
 109
 110   for (const auto& item : app_controls->controls) {
 111     if (item.src().empty()) {
 112       *error = "The src child element of app-control element is obligatory";
 113       return false;
 114     }
 115
 116     const std::string& operation = item.operation();
 117     if (operation.empty()) {
 118       *error =
 119           "The operation child element of app-control element is obligatory";
 120       return false;
 121     }
 122     if (GURL(operation).spec().empty()) {
 123       *error =
 124           "The operation child element of app-control element is not valid url";
 125       return false;
 126     }
 127
 128     const std::string& uri = item.uri();
 129     if (!uri.empty() && GURL(uri).spec().empty()) {
 130       *error =
 131           "The url child element of app-control element is not valid url";
 132       return false;
 133     }
 134
 135     const std::string& mime = item.mime();
 136     if (!mime.empty() && !xdg_mime_is_valid_mime_type(mime.c_str())) {
 137       *error =
 138           "The mime child element of app-control "
 139           "element is not valid mime type";
 140       return false;
 141     }
 142   }
 143   return true;
 144 }
 145
 146 std::vector<std::string> TizenAppControlHandler::Keys() const {
 147   return std::vector<std::string>(1, keys::kTizenApplicationAppControlsKey);
 148 }
 149
 150 }  // namespace application
 151 }  // namespace xwalk