1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
// Copyright (c) 2011 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.
// This file is used to define IPC::ParamTraits<> specializations for a number
// of types so that they can be serialized over IPC. IPC::ParamTraits<>
// specializations for basic types (like int and std::string) and types in the
// 'base' project can be found in ipc/ipc_message_utils.h. This file contains
// specializations for types that are used by the content code, and which need
// manual serialization code. This is usually because they're not structs with
// public members..
#ifndef CONTENT_COMMON_COMMON_PARAM_TRAITS_H_
#define CONTENT_COMMON_COMMON_PARAM_TRAITS_H_
#pragma once
#include "base/platform_file.h"
#include "base/ref_counted.h"
#include "googleurl/src/gurl.h"
#include "ipc/ipc_message_utils.h"
#include "net/base/ip_endpoint.h"
#include "net/url_request/url_request_status.h"
// !!! WARNING: DO NOT ADD NEW WEBKIT DEPENDENCIES !!!
//
// That means don't add #includes to any file in 'webkit/' or
// 'third_party/WebKit/'. Chrome Frame and NACL build parts of base/ and
// content/common/ for a mini-library that doesn't depend on webkit.
// TODO(erg): The following headers are historical and only work because
// their definitions are inlined, which also needs to be fixed.
#include "ui/gfx/native_widget_types.h"
#include "webkit/glue/resource_type.h"
// Forward declarations.
class GURL;
namespace gfx {
class Point;
class Rect;
class Size;
} // namespace gfx
namespace net {
class HttpResponseHeaders;
class HostPortPair;
class UploadData;
}
namespace webkit_glue {
struct ResourceDevToolsInfo;
struct ResourceLoadTimingInfo;
}
namespace IPC {
template <>
struct ParamTraits<GURL> {
typedef GURL param_type;
static void Write(Message* m, const param_type& p);
static bool Read(const Message* m, void** iter, param_type* p);
static void Log(const param_type& p, std::string* l);
};
template <>
struct ParamTraits<ResourceType::Type> {
typedef ResourceType::Type param_type;
static void Write(Message* m, const param_type& p);
static bool Read(const Message* m, void** iter, param_type* p);
static void Log(const param_type& p, std::string* l);
};
template <>
struct ParamTraits<net::URLRequestStatus> {
typedef net::URLRequestStatus param_type;
static void Write(Message* m, const param_type& p);
static bool Read(const Message* m, void** iter, param_type* r);
static void Log(const param_type& p, std::string* l);
};
template <>
struct ParamTraits<scoped_refptr<net::UploadData> > {
typedef scoped_refptr<net::UploadData> param_type;
static void Write(Message* m, const param_type& p);
static bool Read(const Message* m, void** iter, param_type* r);
static void Log(const param_type& p, std::string* l);
};
template<>
struct ParamTraits<net::HostPortPair> {
typedef net::HostPortPair param_type;
static void Write(Message* m, const param_type& p);
static bool Read(const Message* m, void** iter, param_type* r);
static void Log(const param_type& p, std::string* l);
};
template <>
struct ParamTraits<scoped_refptr<net::HttpResponseHeaders> > {
typedef scoped_refptr<net::HttpResponseHeaders> param_type;
static void Write(Message* m, const param_type& p);
static bool Read(const Message* m, void** iter, param_type* r);
static void Log(const param_type& p, std::string* l);
};
template <>
struct ParamTraits<net::IPEndPoint> {
typedef net::IPEndPoint param_type;
static void Write(Message* m, const param_type& p);
static bool Read(const Message* m, void** iter, param_type* p);
static void Log(const param_type& p, std::string* l);
};
template <>
struct ParamTraits<webkit_glue::ResourceLoadTimingInfo> {
typedef webkit_glue::ResourceLoadTimingInfo param_type;
static void Write(Message* m, const param_type& p);
static bool Read(const Message* m, void** iter, param_type* r);
static void Log(const param_type& p, std::string* l);
};
template <>
struct ParamTraits<scoped_refptr<webkit_glue::ResourceDevToolsInfo> > {
typedef scoped_refptr<webkit_glue::ResourceDevToolsInfo> param_type;
static void Write(Message* m, const param_type& p);
static bool Read(const Message* m, void** iter, param_type* r);
static void Log(const param_type& p, std::string* l);
};
template <>
struct ParamTraits<base::PlatformFileInfo> {
typedef base::PlatformFileInfo param_type;
static void Write(Message* m, const param_type& p);
static bool Read(const Message* m, void** iter, param_type* r);
static void Log(const param_type& p, std::string* l);
};
template <>
struct SimilarTypeTraits<base::PlatformFileError> {
typedef int Type;
};
template <>
struct ParamTraits<gfx::Point> {
typedef gfx::Point param_type;
static void Write(Message* m, const param_type& p);
static bool Read(const Message* m, void** iter, param_type* r);
static void Log(const param_type& p, std::string* l);
};
template <>
struct ParamTraits<gfx::Size> {
typedef gfx::Size param_type;
static void Write(Message* m, const param_type& p);
static bool Read(const Message* m, void** iter, param_type* r);
static void Log(const param_type& p, std::string* l);
};
template <>
struct ParamTraits<gfx::Rect> {
typedef gfx::Rect param_type;
static void Write(Message* m, const param_type& p);
static bool Read(const Message* m, void** iter, param_type* r);
static void Log(const param_type& p, std::string* l);
};
template <>
struct ParamTraits<gfx::NativeWindow> {
typedef gfx::NativeWindow param_type;
static void Write(Message* m, const param_type& p) {
#if defined(OS_WIN)
// HWNDs are always 32 bits on Windows, even on 64 bit systems.
m->WriteUInt32(reinterpret_cast<uint32>(p));
#else
m->WriteData(reinterpret_cast<const char*>(&p), sizeof(p));
#endif
}
static bool Read(const Message* m, void** iter, param_type* r) {
#if defined(OS_WIN)
return m->ReadUInt32(iter, reinterpret_cast<uint32*>(r));
#else
const char *data;
int data_size = 0;
bool result = m->ReadData(iter, &data, &data_size);
if (result && data_size == sizeof(gfx::NativeWindow)) {
memcpy(r, data, sizeof(gfx::NativeWindow));
} else {
result = false;
NOTREACHED();
}
return result;
#endif
}
static void Log(const param_type& p, std::string* l) {
l->append("<gfx::NativeWindow>");
}
};
} // namespace IPC
#endif // CONTENT_COMMON_COMMON_PARAM_TRAITS_H_
|
