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