Cleanup the IPC param traits structure

content/common/resource_messages.cc

+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/common/resource_messages.h"
+
+#include "net/http/http_response_headers.h"
+#include "webkit/glue/resource_loader_bridge.h"
+
+namespace IPC {
+
+void ParamTraits<scoped_refptr<net::HttpResponseHeaders> >::Write(
+    Message* m, const param_type& p) {
+  WriteParam(m, p.get() != NULL);
+  if (p) {
+    // Do not disclose Set-Cookie headers over IPC.
+    p->Persist(m, net::HttpResponseHeaders::PERSIST_SANS_COOKIES);
+  }
+}
+
+bool ParamTraits<scoped_refptr<net::HttpResponseHeaders> >::Read(
+    const Message* m, PickleIterator* iter, param_type* r) {
+  bool has_object;
+  if (!ReadParam(m, iter, &has_object))
+    return false;
+  if (has_object)
+    *r = new net::HttpResponseHeaders(*m, iter);
+  return true;
+}
+
+void ParamTraits<scoped_refptr<net::HttpResponseHeaders> >::Log(
+    const param_type& p, std::string* l) {
+  l->append("<HttpResponseHeaders>");
+}
+
+
+void ParamTraits<webkit_base::DataElement>::Write(
+    Message* m, const param_type& p) {
+  WriteParam(m, static_cast<int>(p.type()));
+  switch (p.type()) {
+    case webkit_base::DataElement::TYPE_BYTES: {
+      m->WriteData(p.bytes(), static_cast<int>(p.length()));
+      break;
+    }
+    case webkit_base::DataElement::TYPE_FILE: {
+      WriteParam(m, p.path());
+      WriteParam(m, p.offset());
+      WriteParam(m, p.length());
+      WriteParam(m, p.expected_modification_time());
+      break;
+    }
+    case webkit_base::DataElement::TYPE_FILE_FILESYSTEM: {
+      WriteParam(m, p.url());
+      WriteParam(m, p.offset());
+      WriteParam(m, p.length());
+      WriteParam(m, p.expected_modification_time());
+      break;
+    }
+    default: {
+      DCHECK(p.type() == webkit_base::DataElement::TYPE_BLOB);
+      WriteParam(m, p.url());
+      WriteParam(m, p.offset());
+      WriteParam(m, p.length());
+      break;
+    }
+  }
+}
+
+bool ParamTraits<webkit_base::DataElement>::Read(
+    const Message* m, PickleIterator* iter, param_type* r) {
+  int type;
+  if (!ReadParam(m, iter, &type))
+    return false;
+  switch (type) {
+    case webkit_base::DataElement::TYPE_BYTES: {
+      const char* data;
+      int len;
+      if (!m->ReadData(iter, &data, &len))
+        return false;
+      r->SetToBytes(data, len);
+      break;
+    }
+    case webkit_base::DataElement::TYPE_FILE: {
+      FilePath file_path;
+      uint64 offset, length;
+      base::Time expected_modification_time;
+      if (!ReadParam(m, iter, &file_path))
+        return false;
+      if (!ReadParam(m, iter, &offset))
+        return false;
+      if (!ReadParam(m, iter, &length))
+        return false;
+      if (!ReadParam(m, iter, &expected_modification_time))
+        return false;
+      r->SetToFilePathRange(file_path, offset, length,
+                            expected_modification_time);
+      break;
+    }
+    case webkit_base::DataElement::TYPE_FILE_FILESYSTEM: {
+      GURL file_system_url;
+      uint64 offset, length;
+      base::Time expected_modification_time;
+      if (!ReadParam(m, iter, &file_system_url))
+        return false;
+      if (!ReadParam(m, iter, &offset))
+        return false;
+      if (!ReadParam(m, iter, &length))
+        return false;
+      if (!ReadParam(m, iter, &expected_modification_time))
+        return false;
+      r->SetToFileSystemUrlRange(file_system_url, offset, length,
+                                 expected_modification_time);
+      break;
+    }
+    default: {
+      DCHECK(type == webkit_base::DataElement::TYPE_BLOB);
+      GURL blob_url;
+      uint64 offset, length;
+      if (!ReadParam(m, iter, &blob_url))
+        return false;
+      if (!ReadParam(m, iter, &offset))
+        return false;
+      if (!ReadParam(m, iter, &length))
+        return false;
+      r->SetToBlobUrlRange(blob_url, offset, length);
+      break;
+    }
+  }
+  return true;
+}
+
+void ParamTraits<webkit_base::DataElement>::Log(
+    const param_type& p, std::string* l) {
+  l->append("<webkit_base::DataElement>");
+}
+
+void ParamTraits<scoped_refptr<webkit_glue::ResourceDevToolsInfo> >::Write(
+    Message* m, const param_type& p) {
+  WriteParam(m, p.get() != NULL);
+  if (p.get()) {
+    WriteParam(m, p->http_status_code);
+    WriteParam(m, p->http_status_text);
+    WriteParam(m, p->request_headers);
+    WriteParam(m, p->response_headers);
+    WriteParam(m, p->request_headers_text);
+    WriteParam(m, p->response_headers_text);
+  }
+}
+
+bool ParamTraits<scoped_refptr<webkit_glue::ResourceDevToolsInfo> >::Read(
+    const Message* m, PickleIterator* iter, param_type* r) {
+  bool has_object;
+  if (!ReadParam(m, iter, &has_object))
+    return false;
+  if (!has_object)
+    return true;
+  *r = new webkit_glue::ResourceDevToolsInfo();
+  return
+      ReadParam(m, iter, &(*r)->http_status_code) &&
+      ReadParam(m, iter, &(*r)->http_status_text) &&
+      ReadParam(m, iter, &(*r)->request_headers) &&
+      ReadParam(m, iter, &(*r)->response_headers) &&
+      ReadParam(m, iter, &(*r)->request_headers_text) &&
+      ReadParam(m, iter, &(*r)->response_headers_text);
+}
+
+void ParamTraits<scoped_refptr<webkit_glue::ResourceDevToolsInfo> >::Log(
+    const param_type& p, std::string* l) {
+  l->append("(");
+  if (p) {
+    LogParam(p->request_headers, l);
+    l->append(", ");
+    LogParam(p->response_headers, l);
+  }
+  l->append(")");
+}
+
+void ParamTraits<webkit_glue::ResourceLoadTimingInfo>::Write(
+    Message* m, const param_type& p) {
+  WriteParam(m, p.base_time.is_null());
+  if (p.base_time.is_null())
+    return;
+  WriteParam(m, p.base_ticks);
+  WriteParam(m, p.base_time);
+  WriteParam(m, p.proxy_start);
+  WriteParam(m, p.proxy_end);
+  WriteParam(m, p.dns_start);
+  WriteParam(m, p.dns_end);
+  WriteParam(m, p.connect_start);
+  WriteParam(m, p.connect_end);
+  WriteParam(m, p.ssl_start);
+  WriteParam(m, p.ssl_end);
+  WriteParam(m, p.send_start);
+  WriteParam(m, p.send_end);
+  WriteParam(m, p.receive_headers_start);
+  WriteParam(m, p.receive_headers_end);
+}
+
+bool ParamTraits<webkit_glue::ResourceLoadTimingInfo>::Read(
+    const Message* m, PickleIterator* iter, param_type* r) {
+  bool is_null;
+  if (!ReadParam(m, iter, &is_null))
+    return false;
+  if (is_null)
+    return true;
+
+  return
+      ReadParam(m, iter, &r->base_ticks) &&
+      ReadParam(m, iter, &r->base_time) &&
+      ReadParam(m, iter, &r->proxy_start) &&
+      ReadParam(m, iter, &r->proxy_end) &&
+      ReadParam(m, iter, &r->dns_start) &&
+      ReadParam(m, iter, &r->dns_end) &&
+      ReadParam(m, iter, &r->connect_start) &&
+      ReadParam(m, iter, &r->connect_end) &&
+      ReadParam(m, iter, &r->ssl_start) &&
+      ReadParam(m, iter, &r->ssl_end) &&
+      ReadParam(m, iter, &r->send_start) &&
+      ReadParam(m, iter, &r->send_end) &&
+      ReadParam(m, iter, &r->receive_headers_start) &&
+      ReadParam(m, iter, &r->receive_headers_end);
+}
+
+void ParamTraits<webkit_glue::ResourceLoadTimingInfo>::Log(const param_type& p,
+                                                           std::string* l) {
+  l->append("(");
+  LogParam(p.base_ticks, l);
+  l->append(", ");
+  LogParam(p.base_time, l);
+  l->append(", ");
+  LogParam(p.proxy_start, l);
+  l->append(", ");
+  LogParam(p.proxy_end, l);
+  l->append(", ");
+  LogParam(p.dns_start, l);
+  l->append(", ");
+  LogParam(p.dns_end, l);
+  l->append(", ");
+  LogParam(p.connect_start, l);
+  l->append(", ");
+  LogParam(p.connect_end, l);
+  l->append(", ");
+  LogParam(p.ssl_start, l);
+  l->append(", ");
+  LogParam(p.ssl_end, l);
+  l->append(", ");
+  LogParam(p.send_start, l);
+  l->append(", ");
+  LogParam(p.send_end, l);
+  l->append(", ");
+  LogParam(p.receive_headers_start, l);
+  l->append(", ");
+  LogParam(p.receive_headers_end, l);
+  l->append(")");
+}
+
+void ParamTraits<scoped_refptr<webkit_glue::ResourceRequestBody> >::Write(
+    Message* m,
+    const param_type& p) {
+  WriteParam(m, p.get() != NULL);
+  if (p) {
+    WriteParam(m, *p->elements());
+    WriteParam(m, p->identifier());
+  }
+}
+
+bool ParamTraits<scoped_refptr<webkit_glue::ResourceRequestBody> >::Read(
+    const Message* m,
+    PickleIterator* iter,
+    param_type* r) {
+  bool has_object;
+  if (!ReadParam(m, iter, &has_object))
+    return false;
+  if (!has_object)
+    return true;
+  std::vector<webkit_base::DataElement> elements;
+  if (!ReadParam(m, iter, &elements))
+    return false;
+  int64 identifier;
+  if (!ReadParam(m, iter, &identifier))
+    return false;
+  *r = new webkit_glue::ResourceRequestBody;
+  (*r)->swap_elements(&elements);
+  (*r)->set_identifier(identifier);
+  return true;
+}
+
+void ParamTraits<scoped_refptr<webkit_glue::ResourceRequestBody> >::Log(
+    const param_type& p, std::string* l) {
+  l->append("<webkit_glue::ResourceRequestBody>");
+}
+
+}  // namespace IPC