extensions/common/extension_messages.cc

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