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// This file is used to define IPC::ParamTraits<> specializations for a number
6// of types so that they can be serialized over IPC.  IPC::ParamTraits<>
7// specializations for basic types (like int and std::string) and types in the
8// 'base' project can be found in ipc/ipc_message_utils.h.  This file contains
9// specializations for types that are used by the content code, and which need
10// manual serialization code.  This is usually because they're not structs with
11// public members, or because the same type is being used in multiple
12// *_messages.h headers.
13
14#ifndef CONTENT_PUBLIC_COMMON_COMMON_PARAM_TRAITS_H_
15#define CONTENT_PUBLIC_COMMON_COMMON_PARAM_TRAITS_H_
16
17#include <string>
18
19#include "base/memory/ref_counted.h"
20#include "content/common/content_export.h"
21#include "content/public/common/common_param_traits_macros.h"
22#include "ipc/ipc_message_utils.h"
23#include "ui/gfx/native_widget_types.h"
24#include "ui/surface/transport_dib.h"
25#include "url/gurl.h"
26#include "url/origin.h"
27
28namespace content {
29class PageState;
30}
31
32namespace net {
33class HostPortPair;
34class IPEndPoint;
35}
36
37namespace IPC {
38
39template <>
40struct CONTENT_EXPORT ParamTraits<GURL> {
41  typedef GURL param_type;
42  static void Write(Message* m, const param_type& p);
43  static bool Read(const Message* m, PickleIterator* iter, param_type* p);
44  static void Log(const param_type& p, std::string* l);
45};
46
47template <>
48struct CONTENT_EXPORT ParamTraits<url::Origin> {
49  typedef url::Origin param_type;
50  static void Write(Message* m, const param_type& p);
51  static bool Read(const Message* m, PickleIterator* iter, param_type* p);
52  static void Log(const param_type& p, std::string* l);
53};
54
55template<>
56struct CONTENT_EXPORT ParamTraits<net::HostPortPair> {
57  typedef net::HostPortPair param_type;
58  static void Write(Message* m, const param_type& p);
59  static bool Read(const Message* m, PickleIterator* iter, param_type* r);
60  static void Log(const param_type& p, std::string* l);
61};
62
63template <>
64struct CONTENT_EXPORT ParamTraits<net::IPEndPoint> {
65  typedef net::IPEndPoint param_type;
66  static void Write(Message* m, const param_type& p);
67  static bool Read(const Message* m, PickleIterator* iter, param_type* p);
68  static void Log(const param_type& p, std::string* l);
69};
70
71template <>
72struct CONTENT_EXPORT ParamTraits<content::PageState> {
73  typedef content::PageState param_type;
74  static void Write(Message* m, const param_type& p);
75  static bool Read(const Message* m, PickleIterator* iter, param_type* p);
76  static void Log(const param_type& p, std::string* l);
77};
78
79template <>
80struct ParamTraits<gfx::NativeWindow> {
81  typedef gfx::NativeWindow param_type;
82  static void Write(Message* m, const param_type& p) {
83#if defined(OS_WIN)
84    // HWNDs are always 32 bits on Windows, even on 64 bit systems.
85    m->WriteUInt32(reinterpret_cast<uint32>(p));
86#else
87    m->WriteData(reinterpret_cast<const char*>(&p), sizeof(p));
88#endif
89  }
90  static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
91#if defined(OS_WIN)
92    return m->ReadUInt32(iter, reinterpret_cast<uint32*>(r));
93#else
94    const char *data;
95    int data_size = 0;
96    bool result = m->ReadData(iter, &data, &data_size);
97    if (result && data_size == sizeof(gfx::NativeWindow)) {
98      memcpy(r, data, sizeof(gfx::NativeWindow));
99    } else {
100      result = false;
101      NOTREACHED();
102    }
103    return result;
104#endif
105  }
106  static void Log(const param_type& p, std::string* l) {
107    l->append("<gfx::NativeWindow>");
108  }
109};
110
111#if defined(OS_WIN)
112template<>
113struct ParamTraits<TransportDIB::Id> {
114  typedef TransportDIB::Id param_type;
115  static void Write(Message* m, const param_type& p) {
116    WriteParam(m, p.handle);
117    WriteParam(m, p.sequence_num);
118  }
119  static bool Read(const Message* m, PickleIterator* iter, param_type* r) {
120    return (ReadParam(m, iter, &r->handle) &&
121            ReadParam(m, iter, &r->sequence_num));
122  }
123  static void Log(const param_type& p, std::string* l) {
124    l->append("TransportDIB(");
125    LogParam(p.handle, l);
126    l->append(", ");
127    LogParam(p.sequence_num, l);
128    l->append(")");
129  }
130};
131#endif
132
133}  // namespace IPC
134
135#endif  // CONTENT_PUBLIC_COMMON_COMMON_PARAM_TRAITS_H_
136