src/xwalk/application/common/manifest_handlers/tizen_application_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_application_handler.h"
   6
   7 #include <map>
   8 #include <utility>
   9
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "base/strings/string_split.h"
  12 #include "third_party/re2/re2/re2.h"
  13 #include "xwalk/application/common/application_manifest_constants.h"
  14
  15 namespace xwalk {
  16
  17 namespace keys = application_widget_keys;
  18
  19 namespace application {
  20
  21 TizenApplicationInfo::TizenApplicationInfo() {
  22 }
  23
  24 TizenApplicationInfo::~TizenApplicationInfo() {
  25 }
  26
  27 TizenApplicationHandler::TizenApplicationHandler() {}
  28
  29 TizenApplicationHandler::~TizenApplicationHandler() {}
  30
  31 bool TizenApplicationHandler::Parse(scoped_refptr<ApplicationData> application,
  32                                     base::string16* error) {
  33   scoped_ptr<TizenApplicationInfo> app_info(new TizenApplicationInfo);
  34   const Manifest* manifest = application->GetManifest();
  35   DCHECK(manifest);
  36
  37   base::Value* app_value = NULL;
  38   manifest->Get(keys::kTizenApplicationKey, &app_value);
  39   // Find an application element with tizen namespace
  40   base::DictionaryValue* app_dict;
  41   std::string value;
  42   bool find = false;
  43   if (app_value && app_value->IsType(base::Value::TYPE_DICTIONARY)) {
  44     app_value->GetAsDictionary(&app_dict);
  45     find = app_dict->GetString(keys::kNamespaceKey, &value);
  46     find = find && (value == kTizenNamespacePrefix);
  47   } else if (app_value && app_value->IsType(base::Value::TYPE_LIST)) {
  48     base::ListValue* list;
  49     app_value->GetAsList(&list);
  50     for (base::ListValue::iterator it = list->begin();
  51          it != list->end(); ++it) {
  52       (*it)->GetAsDictionary(&app_dict);
  53       find = app_dict->GetString(keys::kNamespaceKey, &value);
  54       find = find && (value == kTizenNamespacePrefix);
  55       if (find)
  56         break;
  57     }
  58   }
  59
  60   if (!find) {
  61     *error = base::ASCIIToUTF16(
  62         "Cannot find application element with tizen namespace"
  63         " or the tizen namespace prefix is incorrect.\n");
  64     return false;
  65   }
  66   if (app_dict->GetString(keys::kTizenApplicationIdKey, &value))
  67     app_info->set_id(value);
  68   if (app_dict->GetString(keys::kTizenApplicationPackageKey, &value))
  69     app_info->set_package(value);
  70   if (app_dict->GetString(keys::kTizenApplicationRequiredVersionKey, &value))
  71     app_info->set_required_version(value);
  72
  73   application->SetManifestData(keys::kTizenApplicationKey,
  74                                app_info.release());
  75   return true;
  76 }
  77
  78 bool TizenApplicationHandler::Validate(
  79     scoped_refptr<const ApplicationData> application,
  80     std::string* error) const {
  81   const TizenApplicationInfo* app_info =
  82       static_cast<const TizenApplicationInfo*>(
  83           application->GetManifestData(keys::kTizenApplicationKey));
  84
  85   const char kIdPattern[] = "\\A[0-9a-zA-Z]{10}[.][0-9a-zA-Z]{1,52}\\z";
  86   const char kPackagePattern[] = "\\A[0-9a-zA-Z]{10}\\z";
  87   if (!RE2::PartialMatch(app_info->id(), kIdPattern)) {
  88     *error = std::string("The id property of application element"
  89                          " does not match the format\n");
  90     return false;
  91   }
  92   if (!RE2::PartialMatch(app_info->package(), kPackagePattern)) {
  93     *error = std::string("The package property of application element"
  94                          " does not match the format\n");
  95     return false;
  96   }
  97   if (app_info->id().find(app_info->package()) != 0) {
  98     *error = std::string("The application element property id"
  99                          " does not start with package.\n");
 100     return false;
 101   }
 102   // TODO(hongzhang): We need a version map (Tizen API version
 103   // to Crosswalk API version) for checking required_version
 104   if (app_info->required_version().empty()) {
 105     *error = std::string("The required_version property of application"
 106                          " element does not exist.\n");
 107     return false;
 108   }
 109
 110   return true;
 111 }
 112
 113 std::vector<std::string> TizenApplicationHandler::Keys() const {
 114   return std::vector<std::string>(1, keys::kTizenApplicationKey);
 115 }
 116
 117 bool TizenApplicationHandler::AlwaysParseForType(Manifest::Type type) const {
 118   return true;
 119 }
 120
 121 }  // namespace application
 122 }  // namespace xwalk