chrome/common/extensions/extension_messages.cc

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