Home | History | Annotate | Download | only in common 
      1 // Copyright 2014 The Chromium Authors. 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 "extensions/common/extension_messages.h"
      6 
      7 #include "content/public/common/common_param_traits.h"
      8 #include "extensions/common/extension.h"
      9 #include "extensions/common/manifest.h"
     10 #include "extensions/common/manifest_handler.h"
     11 #include "extensions/common/permissions/permissions_data.h"
     12 #include "extensions/common/permissions/permissions_info.h"
     13 
     14 using extensions::APIPermission;
     15 using extensions::APIPermissionInfo;
     16 using extensions::APIPermissionSet;
     17 using extensions::Extension;
     18 using extensions::Manifest;
     19 using extensions::ManifestHandler;
     20 using extensions::ManifestPermission;
     21 using extensions::ManifestPermissionSet;
     22 using extensions::PermissionSet;
     23 using extensions::URLPatternSet;
     24 
     25 ExtensionMsg_PermissionSetStruct::ExtensionMsg_PermissionSetStruct() {
     26 }
     27 
     28 ExtensionMsg_PermissionSetStruct::ExtensionMsg_PermissionSetStruct(
     29     const PermissionSet& permissions)
     30     : apis(permissions.apis()),
     31       manifest_permissions(permissions.manifest_permissions()),
     32       explicit_hosts(permissions.explicit_hosts()),
     33       scriptable_hosts(permissions.scriptable_hosts()) {
     34 }
     35 
     36 ExtensionMsg_PermissionSetStruct::~ExtensionMsg_PermissionSetStruct() {
     37 }
     38 
     39 scoped_refptr<const PermissionSet>
     40 ExtensionMsg_PermissionSetStruct::ToPermissionSet() const {
     41   return new PermissionSet(
     42       apis, manifest_permissions, explicit_hosts, scriptable_hosts);
     43 }
     44 
     45 ExtensionMsg_Loaded_Params::ExtensionMsg_Loaded_Params()
     46     : location(Manifest::INVALID_LOCATION),
     47       creation_flags(Extension::NO_FLAGS) {}
     48 
     49 ExtensionMsg_Loaded_Params::~ExtensionMsg_Loaded_Params() {}
     50 
     51 ExtensionMsg_Loaded_Params::ExtensionMsg_Loaded_Params(
     52     const Extension* extension)
     53     : manifest(extension->manifest()->value()->DeepCopy()),
     54       location(extension->location()),
     55       path(extension->path()),
     56       active_permissions(*extension->permissions_data()->active_permissions()),
     57       withheld_permissions(
     58           *extension->permissions_data()->withheld_permissions()),
     59       id(extension->id()),
     60       creation_flags(extension->creation_flags()) {
     61 }
     62 
     63 scoped_refptr<Extension> ExtensionMsg_Loaded_Params::ConvertToExtension(
     64     std::string* error) const {
     65   scoped_refptr<Extension> extension =
     66       Extension::Create(path, location, *manifest, creation_flags, error);
     67   if (extension.get()) {
     68     extension->permissions_data()->SetPermissions(
     69         active_permissions.ToPermissionSet(),
     70         withheld_permissions.ToPermissionSet());
     71   }
     72   return extension;
     73 }
     74 
     75 namespace IPC {
     76 
     77 template <>
     78 struct ParamTraits<Manifest::Location> {
     79   typedef Manifest::Location param_type;
     80   static void Write(Message* m, const param_type& p) {
     81     int val = static_cast<int>(p);
     82     WriteParam(m, val);
     83   }
     84   static bool Read(const Message* m, PickleIterator* iter, param_type* p) {
     85     int val = 0;
     86     if (!ReadParam(m, iter, &val) ||
     87         val < Manifest::INVALID_LOCATION ||
     88         val >= Manifest::NUM_LOCATIONS)
     89       return false;
     90     *p = static_cast<param_type>(val);
     91     return true;
     92   }
     93   static void Log(const param_type& p, std::string* l) {
     94     ParamTraits<int>::Log(static_cast<int>(p), l);
     95   }
     96 };
     97 
     98 void ParamTraits<URLPattern>::Write(Message* m, const param_type& p) {
     99   WriteParam(m, p.valid_schemes());
    100   WriteParam(m, p.GetAsString());
    101 }
    102 
    103 bool ParamTraits<URLPattern>::Read(const Message* m, PickleIterator* iter,
    104                                    param_type* p) {
    105   int valid_schemes;
    106   std::string spec;
    107   if (!ReadParam(m, iter, &valid_schemes) ||
    108       !ReadParam(m, iter, &spec))
    109     return false;
    110 
    111   // TODO(jstritar): We don't want the URLPattern to fail parsing when the
    112   // scheme is invalid. Instead, the pattern should parse but it should not
    113   // match the invalid patterns. We get around this by setting the valid
    114   // schemes after parsing the pattern. Update these method calls once we can
    115   // ignore scheme validation with URLPattern parse options. crbug.com/90544
    116   p->SetValidSchemes(URLPattern::SCHEME_ALL);
    117   URLPattern::ParseResult result = p->Parse(spec);
    118   p->SetValidSchemes(valid_schemes);
    119   return URLPattern::PARSE_SUCCESS == result;
    120 }
    121 
    122 void ParamTraits<URLPattern>::Log(const param_type& p, std::string* l) {
    123   LogParam(p.GetAsString(), l);
    124 }
    125 
    126 void ParamTraits<URLPatternSet>::Write(Message* m, const param_type& p) {
    127   WriteParam(m, p.patterns());
    128 }
    129 
    130 bool ParamTraits<URLPatternSet>::Read(const Message* m, PickleIterator* iter,
    131                                         param_type* p) {
    132   std::set<URLPattern> patterns;
    133   if (!ReadParam(m, iter, &patterns))
    134     return false;
    135 
    136   for (std::set<URLPattern>::iterator i = patterns.begin();
    137        i != patterns.end(); ++i)
    138     p->AddPattern(*i);
    139   return true;
    140 }
    141 
    142 void ParamTraits<URLPatternSet>::Log(const param_type& p, std::string* l) {
    143   LogParam(p.patterns(), l);
    144 }
    145 
    146 void ParamTraits<APIPermission::ID>::Write(
    147     Message* m, const param_type& p) {
    148   WriteParam(m, static_cast<int>(p));
    149 }
    150 
    151 bool ParamTraits<APIPermission::ID>::Read(
    152     const Message* m, PickleIterator* iter, param_type* p) {
    153   int api_id = -2;
    154   if (!ReadParam(m, iter, &api_id))
    155     return false;
    156 
    157   *p = static_cast<APIPermission::ID>(api_id);
    158   return true;
    159 }
    160 
    161 void ParamTraits<APIPermission::ID>::Log(
    162     const param_type& p, std::string* l) {
    163   LogParam(static_cast<int>(p), l);
    164 }
    165 
    166 void ParamTraits<APIPermissionSet>::Write(
    167     Message* m, const param_type& p) {
    168   APIPermissionSet::const_iterator it = p.begin();
    169   const APIPermissionSet::const_iterator end = p.end();
    170   WriteParam(m, p.size());
    171   for (; it != end; ++it) {
    172     WriteParam(m, it->id());
    173     it->Write(m);
    174   }
    175 }
    176 
    177 bool ParamTraits<APIPermissionSet>::Read(
    178     const Message* m, PickleIterator* iter, param_type* r) {
    179   size_t size;
    180   if (!ReadParam(m, iter, &size))
    181     return false;
    182   for (size_t i = 0; i < size; ++i) {
    183     APIPermission::ID id;
    184     if (!ReadParam(m, iter, &id))
    185       return false;
    186     const APIPermissionInfo* permission_info =
    187       extensions::PermissionsInfo::GetInstance()->GetByID(id);
    188     if (!permission_info)
    189       return false;
    190     scoped_ptr<APIPermission> p(permission_info->CreateAPIPermission());
    191     if (!p->Read(m, iter))
    192       return false;
    193     r->insert(p.release());
    194   }
    195   return true;
    196 }
    197 
    198 void ParamTraits<APIPermissionSet>::Log(
    199     const param_type& p, std::string* l) {
    200   LogParam(p.map(), l);
    201 }
    202 
    203 void ParamTraits<ManifestPermissionSet>::Write(
    204     Message* m, const param_type& p) {
    205   ManifestPermissionSet::const_iterator it = p.begin();
    206   const ManifestPermissionSet::const_iterator end = p.end();
    207   WriteParam(m, p.size());
    208   for (; it != end; ++it) {
    209     WriteParam(m, it->name());
    210     it->Write(m);
    211   }
    212 }
    213 
    214 bool ParamTraits<ManifestPermissionSet>::Read(
    215     const Message* m, PickleIterator* iter, param_type* r) {
    216   size_t size;
    217   if (!ReadParam(m, iter, &size))
    218     return false;
    219   for (size_t i = 0; i < size; ++i) {
    220     std::string name;
    221     if (!ReadParam(m, iter, &name))
    222       return false;
    223     scoped_ptr<ManifestPermission> p(ManifestHandler::CreatePermission(name));
    224     if (!p)
    225       return false;
    226     if (!p->Read(m, iter))
    227       return false;
    228     r->insert(p.release());
    229   }
    230   return true;
    231 }
    232 
    233 void ParamTraits<ManifestPermissionSet>::Log(
    234     const param_type& p, std::string* l) {
    235   LogParam(p.map(), l);
    236 }
    237 
    238 void ParamTraits<ExtensionMsg_PermissionSetStruct>::Write(Message* m,
    239                                                           const param_type& p) {
    240   WriteParam(m, p.apis);
    241   WriteParam(m, p.manifest_permissions);
    242   WriteParam(m, p.explicit_hosts);
    243   WriteParam(m, p.scriptable_hosts);
    244 }
    245 
    246 bool ParamTraits<ExtensionMsg_PermissionSetStruct>::Read(const Message* m,
    247                                                          PickleIterator* iter,
    248                                                          param_type* p) {
    249   return ReadParam(m, iter, &p->apis) &&
    250          ReadParam(m, iter, &p->manifest_permissions) &&
    251          ReadParam(m, iter, &p->explicit_hosts) &&
    252          ReadParam(m, iter, &p->scriptable_hosts);
    253 }
    254 
    255 void ParamTraits<ExtensionMsg_PermissionSetStruct>::Log(const param_type& p,
    256                                                         std::string* l) {
    257   LogParam(p.apis, l);
    258   LogParam(p.manifest_permissions, l);
    259   LogParam(p.explicit_hosts, l);
    260   LogParam(p.scriptable_hosts, l);
    261 }
    262 
    263 void ParamTraits<ExtensionMsg_Loaded_Params>::Write(Message* m,
    264                                                     const param_type& p) {
    265   WriteParam(m, p.location);
    266   WriteParam(m, p.path);
    267   WriteParam(m, *(p.manifest));
    268   WriteParam(m, p.creation_flags);
    269   WriteParam(m, p.active_permissions);
    270   WriteParam(m, p.withheld_permissions);
    271 }
    272 
    273 bool ParamTraits<ExtensionMsg_Loaded_Params>::Read(const Message* m,
    274                                                    PickleIterator* iter,
    275                                                    param_type* p) {
    276   p->manifest.reset(new base::DictionaryValue());
    277   return ReadParam(m, iter, &p->location) && ReadParam(m, iter, &p->path) &&
    278          ReadParam(m, iter, p->manifest.get()) &&
    279          ReadParam(m, iter, &p->creation_flags) &&
    280          ReadParam(m, iter, &p->active_permissions) &&
    281          ReadParam(m, iter, &p->withheld_permissions);
    282 }
    283 
    284 void ParamTraits<ExtensionMsg_Loaded_Params>::Log(const param_type& p,
    285                                                   std::string* l) {
    286   l->append(p.id);
    287 }
    288 
    289 }  // namespace IPC
    290