Home | History | Annotate | Download | only in common 
      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/resource_messages.h"
      6 
      7 #include "net/base/load_timing_info.h"
      8 #include "net/http/http_response_headers.h"
      9 
     10 namespace IPC {
     11 
     12 void ParamTraits<scoped_refptr<net::HttpResponseHeaders> >::Write(
     13     Message* m, const param_type& p) {
     14   WriteParam(m, p.get() != NULL);
     15   if (p.get()) {
     16     // Do not disclose Set-Cookie headers over IPC.
     17     p->Persist(m, net::HttpResponseHeaders::PERSIST_SANS_COOKIES);
     18   }
     19 }
     20 
     21 bool ParamTraits<scoped_refptr<net::HttpResponseHeaders> >::Read(
     22     const Message* m, PickleIterator* iter, param_type* r) {
     23   bool has_object;
     24   if (!ReadParam(m, iter, &has_object))
     25     return false;
     26   if (has_object)
     27     *r = new net::HttpResponseHeaders(*m, iter);
     28   return true;
     29 }
     30 
     31 void ParamTraits<scoped_refptr<net::HttpResponseHeaders> >::Log(
     32     const param_type& p, std::string* l) {
     33   l->append("<HttpResponseHeaders>");
     34 }
     35 
     36 void ParamTraits<storage::DataElement>::Write(Message* m, const param_type& p) {
     37   WriteParam(m, static_cast<int>(p.type()));
     38   switch (p.type()) {
     39     case storage::DataElement::TYPE_BYTES: {
     40       m->WriteData(p.bytes(), static_cast<int>(p.length()));
     41       break;
     42     }
     43     case storage::DataElement::TYPE_FILE: {
     44       WriteParam(m, p.path());
     45       WriteParam(m, p.offset());
     46       WriteParam(m, p.length());
     47       WriteParam(m, p.expected_modification_time());
     48       break;
     49     }
     50     case storage::DataElement::TYPE_FILE_FILESYSTEM: {
     51       WriteParam(m, p.filesystem_url());
     52       WriteParam(m, p.offset());
     53       WriteParam(m, p.length());
     54       WriteParam(m, p.expected_modification_time());
     55       break;
     56     }
     57     default: {
     58       DCHECK(p.type() == storage::DataElement::TYPE_BLOB);
     59       WriteParam(m, p.blob_uuid());
     60       WriteParam(m, p.offset());
     61       WriteParam(m, p.length());
     62       break;
     63     }
     64   }
     65 }
     66 
     67 bool ParamTraits<storage::DataElement>::Read(const Message* m,
     68                                              PickleIterator* iter,
     69                                              param_type* r) {
     70   int type;
     71   if (!ReadParam(m, iter, &type))
     72     return false;
     73   switch (type) {
     74     case storage::DataElement::TYPE_BYTES: {
     75       const char* data;
     76       int len;
     77       if (!m->ReadData(iter, &data, &len))
     78         return false;
     79       r->SetToBytes(data, len);
     80       break;
     81     }
     82     case storage::DataElement::TYPE_FILE: {
     83       base::FilePath file_path;
     84       uint64 offset, length;
     85       base::Time expected_modification_time;
     86       if (!ReadParam(m, iter, &file_path))
     87         return false;
     88       if (!ReadParam(m, iter, &offset))
     89         return false;
     90       if (!ReadParam(m, iter, &length))
     91         return false;
     92       if (!ReadParam(m, iter, &expected_modification_time))
     93         return false;
     94       r->SetToFilePathRange(file_path, offset, length,
     95                             expected_modification_time);
     96       break;
     97     }
     98     case storage::DataElement::TYPE_FILE_FILESYSTEM: {
     99       GURL file_system_url;
    100       uint64 offset, length;
    101       base::Time expected_modification_time;
    102       if (!ReadParam(m, iter, &file_system_url))
    103         return false;
    104       if (!ReadParam(m, iter, &offset))
    105         return false;
    106       if (!ReadParam(m, iter, &length))
    107         return false;
    108       if (!ReadParam(m, iter, &expected_modification_time))
    109         return false;
    110       r->SetToFileSystemUrlRange(file_system_url, offset, length,
    111                                  expected_modification_time);
    112       break;
    113     }
    114     default: {
    115       DCHECK(type == storage::DataElement::TYPE_BLOB);
    116       std::string blob_uuid;
    117       uint64 offset, length;
    118       if (!ReadParam(m, iter, &blob_uuid))
    119         return false;
    120       if (!ReadParam(m, iter, &offset))
    121         return false;
    122       if (!ReadParam(m, iter, &length))
    123         return false;
    124       r->SetToBlobRange(blob_uuid, offset, length);
    125       break;
    126     }
    127   }
    128   return true;
    129 }
    130 
    131 void ParamTraits<storage::DataElement>::Log(const param_type& p,
    132                                             std::string* l) {
    133   l->append("<storage::DataElement>");
    134 }
    135 
    136 void ParamTraits<scoped_refptr<content::ResourceDevToolsInfo> >::Write(
    137     Message* m, const param_type& p) {
    138   WriteParam(m, p.get() != NULL);
    139   if (p.get()) {
    140     WriteParam(m, p->http_status_code);
    141     WriteParam(m, p->http_status_text);
    142     WriteParam(m, p->request_headers);
    143     WriteParam(m, p->response_headers);
    144     WriteParam(m, p->request_headers_text);
    145     WriteParam(m, p->response_headers_text);
    146   }
    147 }
    148 
    149 bool ParamTraits<scoped_refptr<content::ResourceDevToolsInfo> >::Read(
    150     const Message* m, PickleIterator* iter, param_type* r) {
    151   bool has_object;
    152   if (!ReadParam(m, iter, &has_object))
    153     return false;
    154   if (!has_object)
    155     return true;
    156   *r = new content::ResourceDevToolsInfo();
    157   return
    158       ReadParam(m, iter, &(*r)->http_status_code) &&
    159       ReadParam(m, iter, &(*r)->http_status_text) &&
    160       ReadParam(m, iter, &(*r)->request_headers) &&
    161       ReadParam(m, iter, &(*r)->response_headers) &&
    162       ReadParam(m, iter, &(*r)->request_headers_text) &&
    163       ReadParam(m, iter, &(*r)->response_headers_text);
    164 }
    165 
    166 void ParamTraits<scoped_refptr<content::ResourceDevToolsInfo> >::Log(
    167     const param_type& p, std::string* l) {
    168   l->append("(");
    169   if (p.get()) {
    170     LogParam(p->request_headers, l);
    171     l->append(", ");
    172     LogParam(p->response_headers, l);
    173   }
    174   l->append(")");
    175 }
    176 
    177 void ParamTraits<net::LoadTimingInfo>::Write(
    178     Message* m, const param_type& p) {
    179   WriteParam(m, p.socket_log_id);
    180   WriteParam(m, p.socket_reused);
    181   WriteParam(m, p.request_start_time.is_null());
    182   if (p.request_start_time.is_null())
    183     return;
    184   WriteParam(m, p.request_start_time);
    185   WriteParam(m, p.request_start);
    186   WriteParam(m, p.proxy_resolve_start);
    187   WriteParam(m, p.proxy_resolve_end);
    188   WriteParam(m, p.connect_timing.dns_start);
    189   WriteParam(m, p.connect_timing.dns_end);
    190   WriteParam(m, p.connect_timing.connect_start);
    191   WriteParam(m, p.connect_timing.connect_end);
    192   WriteParam(m, p.connect_timing.ssl_start);
    193   WriteParam(m, p.connect_timing.ssl_end);
    194   WriteParam(m, p.send_start);
    195   WriteParam(m, p.send_end);
    196   WriteParam(m, p.receive_headers_end);
    197 }
    198 
    199 bool ParamTraits<net::LoadTimingInfo>::Read(
    200     const Message* m, PickleIterator* iter, param_type* r) {
    201   bool has_no_times;
    202   if (!ReadParam(m, iter, &r->socket_log_id) ||
    203       !ReadParam(m, iter, &r->socket_reused) ||
    204       !ReadParam(m, iter, &has_no_times)) {
    205     return false;
    206   }
    207   if (has_no_times)
    208     return true;
    209 
    210   return
    211       ReadParam(m, iter, &r->request_start_time) &&
    212       ReadParam(m, iter, &r->request_start) &&
    213       ReadParam(m, iter, &r->proxy_resolve_start) &&
    214       ReadParam(m, iter, &r->proxy_resolve_end) &&
    215       ReadParam(m, iter, &r->connect_timing.dns_start) &&
    216       ReadParam(m, iter, &r->connect_timing.dns_end) &&
    217       ReadParam(m, iter, &r->connect_timing.connect_start) &&
    218       ReadParam(m, iter, &r->connect_timing.connect_end) &&
    219       ReadParam(m, iter, &r->connect_timing.ssl_start) &&
    220       ReadParam(m, iter, &r->connect_timing.ssl_end) &&
    221       ReadParam(m, iter, &r->send_start) &&
    222       ReadParam(m, iter, &r->send_end) &&
    223       ReadParam(m, iter, &r->receive_headers_end);
    224 }
    225 
    226 void ParamTraits<net::LoadTimingInfo>::Log(const param_type& p,
    227                                            std::string* l) {
    228   l->append("(");
    229   LogParam(p.socket_log_id, l);
    230   l->append(",");
    231   LogParam(p.socket_reused, l);
    232   l->append(",");
    233   LogParam(p.request_start_time, l);
    234   l->append(", ");
    235   LogParam(p.request_start, l);
    236   l->append(", ");
    237   LogParam(p.proxy_resolve_start, l);
    238   l->append(", ");
    239   LogParam(p.proxy_resolve_end, l);
    240   l->append(", ");
    241   LogParam(p.connect_timing.dns_start, l);
    242   l->append(", ");
    243   LogParam(p.connect_timing.dns_end, l);
    244   l->append(", ");
    245   LogParam(p.connect_timing.connect_start, l);
    246   l->append(", ");
    247   LogParam(p.connect_timing.connect_end, l);
    248   l->append(", ");
    249   LogParam(p.connect_timing.ssl_start, l);
    250   l->append(", ");
    251   LogParam(p.connect_timing.ssl_end, l);
    252   l->append(", ");
    253   LogParam(p.send_start, l);
    254   l->append(", ");
    255   LogParam(p.send_end, l);
    256   l->append(", ");
    257   LogParam(p.receive_headers_end, l);
    258   l->append(")");
    259 }
    260 
    261 void ParamTraits<scoped_refptr<content::ResourceRequestBody> >::Write(
    262     Message* m,
    263     const param_type& p) {
    264   WriteParam(m, p.get() != NULL);
    265   if (p.get()) {
    266     WriteParam(m, *p->elements());
    267     WriteParam(m, p->identifier());
    268   }
    269 }
    270 
    271 bool ParamTraits<scoped_refptr<content::ResourceRequestBody> >::Read(
    272     const Message* m,
    273     PickleIterator* iter,
    274     param_type* r) {
    275   bool has_object;
    276   if (!ReadParam(m, iter, &has_object))
    277     return false;
    278   if (!has_object)
    279     return true;
    280   std::vector<storage::DataElement> elements;
    281   if (!ReadParam(m, iter, &elements))
    282     return false;
    283   int64 identifier;
    284   if (!ReadParam(m, iter, &identifier))
    285     return false;
    286   *r = new content::ResourceRequestBody;
    287   (*r)->swap_elements(&elements);
    288   (*r)->set_identifier(identifier);
    289   return true;
    290 }
    291 
    292 void ParamTraits<scoped_refptr<content::ResourceRequestBody> >::Log(
    293     const param_type& p, std::string* l) {
    294   l->append("<ResourceRequestBody>");
    295 }
    296 
    297 }  // namespace IPC
    298