src/content/common/indexed_db/indexed_db_param_traits.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 "content/common/indexed_db/indexed_db_param_traits.h"
   6
   7 #include <string>
   8 #include <vector>
   9 #include "content/common/indexed_db/indexed_db_key.h"
  10 #include "content/common/indexed_db/indexed_db_key_path.h"
  11 #include "content/common/indexed_db/indexed_db_key_range.h"
  12 #include "ipc/ipc_message_utils.h"
  13
  14 using content::IndexedDBKey;
  15 using content::IndexedDBKeyPath;
  16 using content::IndexedDBKeyRange;
  17
  18 using WebKit::WebIDBKeyPathTypeArray;
  19 using WebKit::WebIDBKeyPathTypeNull;
  20 using WebKit::WebIDBKeyPathTypeString;
  21 using WebKit::WebIDBKeyType;
  22 using WebKit::WebIDBKeyTypeArray;
  23 using WebKit::WebIDBKeyTypeDate;
  24 using WebKit::WebIDBKeyTypeInvalid;
  25 using WebKit::WebIDBKeyTypeMin;
  26 using WebKit::WebIDBKeyTypeNull;
  27 using WebKit::WebIDBKeyTypeNumber;
  28 using WebKit::WebIDBKeyTypeString;
  29
  30 namespace IPC {
  31
  32 void ParamTraits<IndexedDBKey>::Write(Message* m, const param_type& p) {
  33   WriteParam(m, static_cast<int>(p.type()));
  34   switch (p.type()) {
  35     case WebIDBKeyTypeArray:
  36       WriteParam(m, p.array());
  37       return;
  38     case WebIDBKeyTypeString:
  39       WriteParam(m, p.string());
  40       return;
  41     case WebIDBKeyTypeDate:
  42       WriteParam(m, p.date());
  43       return;
  44     case WebIDBKeyTypeNumber:
  45       WriteParam(m, p.number());
  46       return;
  47     case WebIDBKeyTypeInvalid:
  48     case WebIDBKeyTypeNull:
  49       return;
  50     case WebIDBKeyTypeMin:
  51     default:
  52       NOTREACHED();
  53       return;
  54   }
  55 }
  56
  57 bool ParamTraits<IndexedDBKey>::Read(const Message* m,
  58                                      PickleIterator* iter,
  59                                      param_type* r) {
  60   int type;
  61   if (!ReadParam(m, iter, &type))
  62     return false;
  63   WebIDBKeyType web_type = static_cast<WebIDBKeyType>(type);
  64
  65   switch (web_type) {
  66     case WebIDBKeyTypeArray: {
  67       std::vector<IndexedDBKey> array;
  68       if (!ReadParam(m, iter, &array))
  69         return false;
  70       *r = IndexedDBKey(array);
  71       return true;
  72     }
  73     case WebIDBKeyTypeString: {
  74       string16 string;
  75       if (!ReadParam(m, iter, &string))
  76         return false;
  77       *r = IndexedDBKey(string);
  78       return true;
  79     }
  80     case WebIDBKeyTypeDate:
  81     case WebIDBKeyTypeNumber: {
  82       double number;
  83       if (!ReadParam(m, iter, &number))
  84         return false;
  85       *r = IndexedDBKey(number, web_type);
  86       return true;
  87     }
  88     case WebIDBKeyTypeInvalid:
  89     case WebIDBKeyTypeNull:
  90       *r = IndexedDBKey(web_type);
  91       return true;
  92     case WebIDBKeyTypeMin:
  93     default:
  94       NOTREACHED();
  95       return false;
  96   }
  97   NOTREACHED();
  98   return false;
  99 }
 100
 101 void ParamTraits<IndexedDBKey>::Log(const param_type& p, std::string* l) {
 102   l->append("<IndexedDBKey>(");
 103   LogParam(static_cast<int>(p.type()), l);
 104   l->append(", ");
 105   l->append("[");
 106   std::vector<IndexedDBKey>::const_iterator it = p.array().begin();
 107   while (it != p.array().end()) {
 108     Log(*it, l);
 109     ++it;
 110     if (it != p.array().end())
 111       l->append(", ");
 112   }
 113   l->append("], ");
 114   LogParam(p.string(), l);
 115   l->append(", ");
 116   LogParam(p.date(), l);
 117   l->append(", ");
 118   LogParam(p.number(), l);
 119   l->append(")");
 120 }
 121
 122 void ParamTraits<IndexedDBKeyPath>::Write(Message* m, const param_type& p) {
 123   WriteParam(m, static_cast<int>(p.type()));
 124   switch (p.type()) {
 125     case WebIDBKeyPathTypeArray:
 126       WriteParam(m, p.array());
 127       return;
 128     case WebIDBKeyPathTypeString:
 129       WriteParam(m, p.string());
 130       return;
 131     case WebIDBKeyPathTypeNull:
 132       return;
 133   }
 134   NOTREACHED();
 135 }
 136
 137 bool ParamTraits<IndexedDBKeyPath>::Read(const Message* m,
 138                                          PickleIterator* iter,
 139                                          param_type* r) {
 140   int type;
 141   if (!ReadParam(m, iter, &type))
 142     return false;
 143
 144   switch (type) {
 145     case WebIDBKeyPathTypeArray: {
 146       std::vector<string16> array;
 147       if (!ReadParam(m, iter, &array))
 148         return false;
 149       *r = IndexedDBKeyPath(array);
 150       return true;
 151     }
 152     case WebIDBKeyPathTypeString: {
 153       string16 string;
 154       if (!ReadParam(m, iter, &string))
 155         return false;
 156       *r = IndexedDBKeyPath(string);
 157       return true;
 158     }
 159     case WebIDBKeyPathTypeNull:
 160       *r = IndexedDBKeyPath();
 161       return true;
 162   }
 163   NOTREACHED();
 164   return false;
 165 }
 166
 167 void ParamTraits<IndexedDBKeyPath>::Log(const param_type& p, std::string* l) {
 168   l->append("<IndexedDBKeyPath>(");
 169   LogParam(static_cast<int>(p.type()), l);
 170   l->append(", ");
 171   LogParam(p.string(), l);
 172   l->append(", ");
 173   l->append("[");
 174   std::vector<string16>::const_iterator it = p.array().begin();
 175   while (it != p.array().end()) {
 176     LogParam(*it, l);
 177     ++it;
 178     if (it != p.array().end())
 179       l->append(", ");
 180   }
 181   l->append("])");
 182 }
 183
 184 void ParamTraits<IndexedDBKeyRange>::Write(Message* m, const param_type& p) {
 185   WriteParam(m, p.lower());
 186   WriteParam(m, p.upper());
 187   WriteParam(m, p.lowerOpen());
 188   WriteParam(m, p.upperOpen());
 189 }
 190
 191 bool ParamTraits<IndexedDBKeyRange>::Read(const Message* m,
 192                                           PickleIterator* iter,
 193                                           param_type* r) {
 194   IndexedDBKey lower;
 195   if (!ReadParam(m, iter, &lower))
 196     return false;
 197
 198   IndexedDBKey upper;
 199   if (!ReadParam(m, iter, &upper))
 200     return false;
 201
 202   bool lower_open;
 203   if (!ReadParam(m, iter, &lower_open))
 204     return false;
 205
 206   bool upper_open;
 207   if (!ReadParam(m, iter, &upper_open))
 208     return false;
 209
 210   *r = IndexedDBKeyRange(lower, upper, lower_open, upper_open);
 211   return true;
 212 }
 213
 214 void ParamTraits<IndexedDBKeyRange>::Log(const param_type& p, std::string* l) {
 215   l->append("<IndexedDBKeyRange>(lower=");
 216   LogParam(p.lower(), l);
 217   l->append(", upper=");
 218   LogParam(p.upper(), l);
 219   l->append(", lower_open=");
 220   LogParam(p.lowerOpen(), l);
 221   l->append(", upper_open=");
 222   LogParam(p.upperOpen(), l);
 223   l->append(")");
 224 }
 225
 226 }  // namespace IPC