cc: Added inline to Tile::IsReadyToDraw
[chromium-blink-merge.git] / ipc / ipc_message_utils.cc
blob2acddceb51c870752c58138779f4a4e4b6b01b61
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.
5 #include "ipc/ipc_message_utils.h"
7 #include "base/files/file_path.h"
8 #include "base/json/json_writer.h"
9 #include "base/memory/scoped_ptr.h"
10 #include "base/strings/nullable_string16.h"
11 #include "base/strings/string_number_conversions.h"
12 #include "base/strings/utf_string_conversions.h"
13 #include "base/time/time.h"
14 #include "base/values.h"
15 #include "ipc/ipc_channel_handle.h"
17 #if defined(OS_POSIX)
18 #include "ipc/file_descriptor_set_posix.h"
19 #elif defined(OS_WIN)
20 #include <tchar.h>
21 #endif
23 namespace IPC {
25 namespace {
27 const int kMaxRecursionDepth = 100;
29 template<typename CharType>
30 void LogBytes(const std::vector<CharType>& data, std::string* out) {
31 #if defined(OS_WIN)
32 // Windows has a GUI for logging, which can handle arbitrary binary data.
33 for (size_t i = 0; i < data.size(); ++i)
34 out->push_back(data[i]);
35 #else
36 // On POSIX, we log to stdout, which we assume can display ASCII.
37 static const size_t kMaxBytesToLog = 100;
38 for (size_t i = 0; i < std::min(data.size(), kMaxBytesToLog); ++i) {
39 if (isprint(data[i]))
40 out->push_back(data[i]);
41 else
42 out->append(
43 base::StringPrintf("[%02X]", static_cast<unsigned char>(data[i])));
45 if (data.size() > kMaxBytesToLog) {
46 out->append(base::StringPrintf(
47 " and %u more bytes",
48 static_cast<unsigned>(data.size() - kMaxBytesToLog)));
50 #endif
53 bool ReadValue(const Message* m, PickleIterator* iter, base::Value** value,
54 int recursion);
56 void WriteValue(Message* m, const base::Value* value, int recursion) {
57 bool result;
58 if (recursion > kMaxRecursionDepth) {
59 LOG(WARNING) << "Max recursion depth hit in WriteValue.";
60 return;
63 m->WriteInt(value->GetType());
65 switch (value->GetType()) {
66 case base::Value::TYPE_NULL:
67 break;
68 case base::Value::TYPE_BOOLEAN: {
69 bool val;
70 result = value->GetAsBoolean(&val);
71 DCHECK(result);
72 WriteParam(m, val);
73 break;
75 case base::Value::TYPE_INTEGER: {
76 int val;
77 result = value->GetAsInteger(&val);
78 DCHECK(result);
79 WriteParam(m, val);
80 break;
82 case base::Value::TYPE_DOUBLE: {
83 double val;
84 result = value->GetAsDouble(&val);
85 DCHECK(result);
86 WriteParam(m, val);
87 break;
89 case base::Value::TYPE_STRING: {
90 std::string val;
91 result = value->GetAsString(&val);
92 DCHECK(result);
93 WriteParam(m, val);
94 break;
96 case base::Value::TYPE_BINARY: {
97 const base::BinaryValue* binary =
98 static_cast<const base::BinaryValue*>(value);
99 m->WriteData(binary->GetBuffer(), static_cast<int>(binary->GetSize()));
100 break;
102 case base::Value::TYPE_DICTIONARY: {
103 const base::DictionaryValue* dict =
104 static_cast<const base::DictionaryValue*>(value);
106 WriteParam(m, static_cast<int>(dict->size()));
108 for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd();
109 it.Advance()) {
110 WriteParam(m, it.key());
111 WriteValue(m, &it.value(), recursion + 1);
113 break;
115 case base::Value::TYPE_LIST: {
116 const base::ListValue* list = static_cast<const base::ListValue*>(value);
117 WriteParam(m, static_cast<int>(list->GetSize()));
118 for (base::ListValue::const_iterator it = list->begin();
119 it != list->end(); ++it) {
120 WriteValue(m, *it, recursion + 1);
122 break;
127 // Helper for ReadValue that reads a DictionaryValue into a pre-allocated
128 // object.
129 bool ReadDictionaryValue(const Message* m, PickleIterator* iter,
130 base::DictionaryValue* value, int recursion) {
131 int size;
132 if (!ReadParam(m, iter, &size))
133 return false;
135 for (int i = 0; i < size; ++i) {
136 std::string key;
137 base::Value* subval;
138 if (!ReadParam(m, iter, &key) ||
139 !ReadValue(m, iter, &subval, recursion + 1))
140 return false;
141 value->SetWithoutPathExpansion(key, subval);
144 return true;
147 // Helper for ReadValue that reads a ReadListValue into a pre-allocated
148 // object.
149 bool ReadListValue(const Message* m, PickleIterator* iter,
150 base::ListValue* value, int recursion) {
151 int size;
152 if (!ReadParam(m, iter, &size))
153 return false;
155 for (int i = 0; i < size; ++i) {
156 base::Value* subval;
157 if (!ReadValue(m, iter, &subval, recursion + 1))
158 return false;
159 value->Set(i, subval);
162 return true;
165 bool ReadValue(const Message* m, PickleIterator* iter, base::Value** value,
166 int recursion) {
167 if (recursion > kMaxRecursionDepth) {
168 LOG(WARNING) << "Max recursion depth hit in ReadValue.";
169 return false;
172 int type;
173 if (!ReadParam(m, iter, &type))
174 return false;
176 switch (type) {
177 case base::Value::TYPE_NULL:
178 *value = base::Value::CreateNullValue();
179 break;
180 case base::Value::TYPE_BOOLEAN: {
181 bool val;
182 if (!ReadParam(m, iter, &val))
183 return false;
184 *value = new base::FundamentalValue(val);
185 break;
187 case base::Value::TYPE_INTEGER: {
188 int val;
189 if (!ReadParam(m, iter, &val))
190 return false;
191 *value = new base::FundamentalValue(val);
192 break;
194 case base::Value::TYPE_DOUBLE: {
195 double val;
196 if (!ReadParam(m, iter, &val))
197 return false;
198 *value = new base::FundamentalValue(val);
199 break;
201 case base::Value::TYPE_STRING: {
202 std::string val;
203 if (!ReadParam(m, iter, &val))
204 return false;
205 *value = new base::StringValue(val);
206 break;
208 case base::Value::TYPE_BINARY: {
209 const char* data;
210 int length;
211 if (!m->ReadData(iter, &data, &length))
212 return false;
213 *value = base::BinaryValue::CreateWithCopiedBuffer(data, length);
214 break;
216 case base::Value::TYPE_DICTIONARY: {
217 scoped_ptr<base::DictionaryValue> val(new base::DictionaryValue());
218 if (!ReadDictionaryValue(m, iter, val.get(), recursion))
219 return false;
220 *value = val.release();
221 break;
223 case base::Value::TYPE_LIST: {
224 scoped_ptr<base::ListValue> val(new base::ListValue());
225 if (!ReadListValue(m, iter, val.get(), recursion))
226 return false;
227 *value = val.release();
228 break;
230 default:
231 return false;
234 return true;
237 } // namespace
239 // -----------------------------------------------------------------------------
241 LogData::LogData()
242 : routing_id(0),
243 type(0),
244 sent(0),
245 receive(0),
246 dispatch(0) {
249 LogData::~LogData() {
252 void ParamTraits<bool>::Log(const param_type& p, std::string* l) {
253 l->append(p ? "true" : "false");
256 void ParamTraits<unsigned char>::Write(Message* m, const param_type& p) {
257 m->WriteBytes(&p, sizeof(param_type));
260 bool ParamTraits<unsigned char>::Read(const Message* m, PickleIterator* iter,
261 param_type* r) {
262 const char* data;
263 if (!m->ReadBytes(iter, &data, sizeof(param_type)))
264 return false;
265 memcpy(r, data, sizeof(param_type));
266 return true;
269 void ParamTraits<unsigned char>::Log(const param_type& p, std::string* l) {
270 l->append(base::UintToString(p));
273 void ParamTraits<unsigned short>::Write(Message* m, const param_type& p) {
274 m->WriteBytes(&p, sizeof(param_type));
277 bool ParamTraits<unsigned short>::Read(const Message* m, PickleIterator* iter,
278 param_type* r) {
279 const char* data;
280 if (!m->ReadBytes(iter, &data, sizeof(param_type)))
281 return false;
282 memcpy(r, data, sizeof(param_type));
283 return true;
286 void ParamTraits<unsigned short>::Log(const param_type& p, std::string* l) {
287 l->append(base::UintToString(p));
290 void ParamTraits<int>::Log(const param_type& p, std::string* l) {
291 l->append(base::IntToString(p));
294 void ParamTraits<unsigned int>::Log(const param_type& p, std::string* l) {
295 l->append(base::UintToString(p));
298 void ParamTraits<long>::Log(const param_type& p, std::string* l) {
299 l->append(base::Int64ToString(static_cast<int64>(p)));
302 void ParamTraits<unsigned long>::Log(const param_type& p, std::string* l) {
303 l->append(base::Uint64ToString(static_cast<uint64>(p)));
306 void ParamTraits<long long>::Log(const param_type& p, std::string* l) {
307 l->append(base::Int64ToString(static_cast<int64>(p)));
310 void ParamTraits<unsigned long long>::Log(const param_type& p, std::string* l) {
311 l->append(base::Uint64ToString(p));
314 void ParamTraits<float>::Write(Message* m, const param_type& p) {
315 m->WriteData(reinterpret_cast<const char*>(&p), sizeof(param_type));
318 bool ParamTraits<float>::Read(const Message* m, PickleIterator* iter,
319 param_type* r) {
320 const char *data;
321 int data_size;
322 if (!m->ReadData(iter, &data, &data_size) ||
323 data_size != sizeof(param_type)) {
324 NOTREACHED();
325 return false;
327 memcpy(r, data, sizeof(param_type));
328 return true;
331 void ParamTraits<float>::Log(const param_type& p, std::string* l) {
332 l->append(base::StringPrintf("%e", p));
335 void ParamTraits<double>::Write(Message* m, const param_type& p) {
336 m->WriteData(reinterpret_cast<const char*>(&p), sizeof(param_type));
339 bool ParamTraits<double>::Read(const Message* m, PickleIterator* iter,
340 param_type* r) {
341 const char *data;
342 int data_size;
343 if (!m->ReadData(iter, &data, &data_size) ||
344 data_size != sizeof(param_type)) {
345 NOTREACHED();
346 return false;
348 memcpy(r, data, sizeof(param_type));
349 return true;
352 void ParamTraits<double>::Log(const param_type& p, std::string* l) {
353 l->append(base::StringPrintf("%e", p));
357 void ParamTraits<std::string>::Log(const param_type& p, std::string* l) {
358 l->append(p);
361 void ParamTraits<std::wstring>::Log(const param_type& p, std::string* l) {
362 l->append(WideToUTF8(p));
365 #if !defined(WCHAR_T_IS_UTF16)
366 void ParamTraits<string16>::Log(const param_type& p, std::string* l) {
367 l->append(UTF16ToUTF8(p));
369 #endif
371 void ParamTraits<std::vector<char> >::Write(Message* m, const param_type& p) {
372 if (p.empty()) {
373 m->WriteData(NULL, 0);
374 } else {
375 m->WriteData(&p.front(), static_cast<int>(p.size()));
379 bool ParamTraits<std::vector<char> >::Read(const Message* m,
380 PickleIterator* iter,
381 param_type* r) {
382 const char *data;
383 int data_size = 0;
384 if (!m->ReadData(iter, &data, &data_size) || data_size < 0)
385 return false;
386 r->resize(data_size);
387 if (data_size)
388 memcpy(&r->front(), data, data_size);
389 return true;
392 void ParamTraits<std::vector<char> >::Log(const param_type& p, std::string* l) {
393 LogBytes(p, l);
396 void ParamTraits<std::vector<unsigned char> >::Write(Message* m,
397 const param_type& p) {
398 if (p.empty()) {
399 m->WriteData(NULL, 0);
400 } else {
401 m->WriteData(reinterpret_cast<const char*>(&p.front()),
402 static_cast<int>(p.size()));
406 bool ParamTraits<std::vector<unsigned char> >::Read(const Message* m,
407 PickleIterator* iter,
408 param_type* r) {
409 const char *data;
410 int data_size = 0;
411 if (!m->ReadData(iter, &data, &data_size) || data_size < 0)
412 return false;
413 r->resize(data_size);
414 if (data_size)
415 memcpy(&r->front(), data, data_size);
416 return true;
419 void ParamTraits<std::vector<unsigned char> >::Log(const param_type& p,
420 std::string* l) {
421 LogBytes(p, l);
424 void ParamTraits<std::vector<bool> >::Write(Message* m, const param_type& p) {
425 WriteParam(m, static_cast<int>(p.size()));
426 // Cast to bool below is required because libc++'s
427 // vector<bool>::const_reference is different from bool, and we want to avoid
428 // writing an extra specialization of ParamTraits for it.
429 for (size_t i = 0; i < p.size(); i++)
430 WriteParam(m, static_cast<bool>(p[i]));
433 bool ParamTraits<std::vector<bool> >::Read(const Message* m,
434 PickleIterator* iter,
435 param_type* r) {
436 int size;
437 // ReadLength() checks for < 0 itself.
438 if (!m->ReadLength(iter, &size))
439 return false;
440 r->resize(size);
441 for (int i = 0; i < size; i++) {
442 bool value;
443 if (!ReadParam(m, iter, &value))
444 return false;
445 (*r)[i] = value;
447 return true;
450 void ParamTraits<std::vector<bool> >::Log(const param_type& p, std::string* l) {
451 for (size_t i = 0; i < p.size(); ++i) {
452 if (i != 0)
453 l->push_back(' ');
454 LogParam(static_cast<bool>(p[i]), l);
458 void ParamTraits<base::DictionaryValue>::Write(Message* m,
459 const param_type& p) {
460 WriteValue(m, &p, 0);
463 bool ParamTraits<base::DictionaryValue>::Read(
464 const Message* m, PickleIterator* iter, param_type* r) {
465 int type;
466 if (!ReadParam(m, iter, &type) || type != base::Value::TYPE_DICTIONARY)
467 return false;
469 return ReadDictionaryValue(m, iter, r, 0);
472 void ParamTraits<base::DictionaryValue>::Log(const param_type& p,
473 std::string* l) {
474 std::string json;
475 base::JSONWriter::Write(&p, &json);
476 l->append(json);
479 #if defined(OS_POSIX)
480 void ParamTraits<base::FileDescriptor>::Write(Message* m, const param_type& p) {
481 const bool valid = p.fd >= 0;
482 WriteParam(m, valid);
484 if (valid) {
485 if (!m->WriteFileDescriptor(p))
486 NOTREACHED();
490 bool ParamTraits<base::FileDescriptor>::Read(const Message* m,
491 PickleIterator* iter,
492 param_type* r) {
493 bool valid;
494 if (!ReadParam(m, iter, &valid))
495 return false;
497 if (!valid) {
498 r->fd = -1;
499 r->auto_close = false;
500 return true;
503 return m->ReadFileDescriptor(iter, r);
506 void ParamTraits<base::FileDescriptor>::Log(const param_type& p,
507 std::string* l) {
508 if (p.auto_close) {
509 l->append(base::StringPrintf("FD(%d auto-close)", p.fd));
510 } else {
511 l->append(base::StringPrintf("FD(%d)", p.fd));
514 #endif // defined(OS_POSIX)
516 void ParamTraits<base::FilePath>::Write(Message* m, const param_type& p) {
517 p.WriteToPickle(m);
520 bool ParamTraits<base::FilePath>::Read(const Message* m,
521 PickleIterator* iter,
522 param_type* r) {
523 return r->ReadFromPickle(iter);
526 void ParamTraits<base::FilePath>::Log(const param_type& p, std::string* l) {
527 ParamTraits<base::FilePath::StringType>::Log(p.value(), l);
530 void ParamTraits<base::ListValue>::Write(Message* m, const param_type& p) {
531 WriteValue(m, &p, 0);
534 bool ParamTraits<base::ListValue>::Read(
535 const Message* m, PickleIterator* iter, param_type* r) {
536 int type;
537 if (!ReadParam(m, iter, &type) || type != base::Value::TYPE_LIST)
538 return false;
540 return ReadListValue(m, iter, r, 0);
543 void ParamTraits<base::ListValue>::Log(const param_type& p, std::string* l) {
544 std::string json;
545 base::JSONWriter::Write(&p, &json);
546 l->append(json);
549 void ParamTraits<base::NullableString16>::Write(Message* m,
550 const param_type& p) {
551 WriteParam(m, p.string());
552 WriteParam(m, p.is_null());
555 bool ParamTraits<base::NullableString16>::Read(const Message* m,
556 PickleIterator* iter,
557 param_type* r) {
558 string16 string;
559 if (!ReadParam(m, iter, &string))
560 return false;
561 bool is_null;
562 if (!ReadParam(m, iter, &is_null))
563 return false;
564 *r = base::NullableString16(string, is_null);
565 return true;
568 void ParamTraits<base::NullableString16>::Log(const param_type& p,
569 std::string* l) {
570 l->append("(");
571 LogParam(p.string(), l);
572 l->append(", ");
573 LogParam(p.is_null(), l);
574 l->append(")");
577 void ParamTraits<base::PlatformFileInfo>::Write(Message* m,
578 const param_type& p) {
579 WriteParam(m, p.size);
580 WriteParam(m, p.is_directory);
581 WriteParam(m, p.last_modified.ToDoubleT());
582 WriteParam(m, p.last_accessed.ToDoubleT());
583 WriteParam(m, p.creation_time.ToDoubleT());
586 bool ParamTraits<base::PlatformFileInfo>::Read(const Message* m,
587 PickleIterator* iter,
588 param_type* p) {
589 double last_modified;
590 double last_accessed;
591 double creation_time;
592 bool result =
593 ReadParam(m, iter, &p->size) &&
594 ReadParam(m, iter, &p->is_directory) &&
595 ReadParam(m, iter, &last_modified) &&
596 ReadParam(m, iter, &last_accessed) &&
597 ReadParam(m, iter, &creation_time);
598 if (result) {
599 p->last_modified = base::Time::FromDoubleT(last_modified);
600 p->last_accessed = base::Time::FromDoubleT(last_accessed);
601 p->creation_time = base::Time::FromDoubleT(creation_time);
603 return result;
606 void ParamTraits<base::PlatformFileInfo>::Log(const param_type& p,
607 std::string* l) {
608 l->append("(");
609 LogParam(p.size, l);
610 l->append(",");
611 LogParam(p.is_directory, l);
612 l->append(",");
613 LogParam(p.last_modified.ToDoubleT(), l);
614 l->append(",");
615 LogParam(p.last_accessed.ToDoubleT(), l);
616 l->append(",");
617 LogParam(p.creation_time.ToDoubleT(), l);
618 l->append(")");
621 void ParamTraits<base::Time>::Write(Message* m, const param_type& p) {
622 ParamTraits<int64>::Write(m, p.ToInternalValue());
625 bool ParamTraits<base::Time>::Read(const Message* m, PickleIterator* iter,
626 param_type* r) {
627 int64 value;
628 if (!ParamTraits<int64>::Read(m, iter, &value))
629 return false;
630 *r = base::Time::FromInternalValue(value);
631 return true;
634 void ParamTraits<base::Time>::Log(const param_type& p, std::string* l) {
635 ParamTraits<int64>::Log(p.ToInternalValue(), l);
638 void ParamTraits<base::TimeDelta>::Write(Message* m, const param_type& p) {
639 ParamTraits<int64>::Write(m, p.ToInternalValue());
642 bool ParamTraits<base::TimeDelta>::Read(const Message* m,
643 PickleIterator* iter,
644 param_type* r) {
645 int64 value;
646 bool ret = ParamTraits<int64>::Read(m, iter, &value);
647 if (ret)
648 *r = base::TimeDelta::FromInternalValue(value);
650 return ret;
653 void ParamTraits<base::TimeDelta>::Log(const param_type& p, std::string* l) {
654 ParamTraits<int64>::Log(p.ToInternalValue(), l);
657 void ParamTraits<base::TimeTicks>::Write(Message* m, const param_type& p) {
658 ParamTraits<int64>::Write(m, p.ToInternalValue());
661 bool ParamTraits<base::TimeTicks>::Read(const Message* m,
662 PickleIterator* iter,
663 param_type* r) {
664 int64 value;
665 bool ret = ParamTraits<int64>::Read(m, iter, &value);
666 if (ret)
667 *r = base::TimeTicks::FromInternalValue(value);
669 return ret;
672 void ParamTraits<base::TimeTicks>::Log(const param_type& p, std::string* l) {
673 ParamTraits<int64>::Log(p.ToInternalValue(), l);
676 void ParamTraits<IPC::ChannelHandle>::Write(Message* m, const param_type& p) {
677 #if defined(OS_WIN)
678 // On Windows marshalling pipe handle is not supported.
679 DCHECK(p.pipe.handle == NULL);
680 #endif // defined (OS_WIN)
681 WriteParam(m, p.name);
682 #if defined(OS_POSIX)
683 WriteParam(m, p.socket);
684 #endif
687 bool ParamTraits<IPC::ChannelHandle>::Read(const Message* m,
688 PickleIterator* iter,
689 param_type* r) {
690 return ReadParam(m, iter, &r->name)
691 #if defined(OS_POSIX)
692 && ReadParam(m, iter, &r->socket)
693 #endif
697 void ParamTraits<IPC::ChannelHandle>::Log(const param_type& p,
698 std::string* l) {
699 l->append(base::StringPrintf("ChannelHandle(%s", p.name.c_str()));
700 #if defined(OS_POSIX)
701 l->append(", ");
702 ParamTraits<base::FileDescriptor>::Log(p.socket, l);
703 #endif
704 l->append(")");
707 void ParamTraits<LogData>::Write(Message* m, const param_type& p) {
708 WriteParam(m, p.channel);
709 WriteParam(m, p.routing_id);
710 WriteParam(m, p.type);
711 WriteParam(m, p.flags);
712 WriteParam(m, p.sent);
713 WriteParam(m, p.receive);
714 WriteParam(m, p.dispatch);
715 WriteParam(m, p.message_name);
716 WriteParam(m, p.params);
719 bool ParamTraits<LogData>::Read(const Message* m,
720 PickleIterator* iter,
721 param_type* r) {
722 return
723 ReadParam(m, iter, &r->channel) &&
724 ReadParam(m, iter, &r->routing_id) &&
725 ReadParam(m, iter, &r->type) &&
726 ReadParam(m, iter, &r->flags) &&
727 ReadParam(m, iter, &r->sent) &&
728 ReadParam(m, iter, &r->receive) &&
729 ReadParam(m, iter, &r->dispatch) &&
730 ReadParam(m, iter, &r->message_name) &&
731 ReadParam(m, iter, &r->params);
734 void ParamTraits<LogData>::Log(const param_type& p, std::string* l) {
735 // Doesn't make sense to implement this!
738 void ParamTraits<Message>::Write(Message* m, const Message& p) {
739 #if defined(OS_POSIX)
740 // We don't serialize the file descriptors in the nested message, so there
741 // better not be any.
742 DCHECK(!p.HasFileDescriptors());
743 #endif
745 // Don't just write out the message. This is used to send messages between
746 // NaCl (Posix environment) and the browser (could be on Windows). The message
747 // header formats differ between these systems (so does handle sharing, but
748 // we already asserted we don't have any handles). So just write out the
749 // parts of the header we use.
751 // Be careful also to use only explicitly-sized types. The NaCl environment
752 // could be 64-bit and the host browser could be 32-bits. The nested message
753 // may or may not be safe to send between 32-bit and 64-bit systems, but we
754 // leave that up to the code sending the message to ensure.
755 m->WriteUInt32(static_cast<uint32>(p.routing_id()));
756 m->WriteUInt32(p.type());
757 m->WriteUInt32(p.flags());
758 m->WriteData(p.payload(), static_cast<uint32>(p.payload_size()));
761 bool ParamTraits<Message>::Read(const Message* m, PickleIterator* iter,
762 Message* r) {
763 uint32 routing_id, type, flags;
764 if (!m->ReadUInt32(iter, &routing_id) ||
765 !m->ReadUInt32(iter, &type) ||
766 !m->ReadUInt32(iter, &flags))
767 return false;
769 int payload_size;
770 const char* payload;
771 if (!m->ReadData(iter, &payload, &payload_size))
772 return false;
774 r->SetHeaderValues(static_cast<int32>(routing_id), type, flags);
775 return r->WriteBytes(payload, payload_size);
778 void ParamTraits<Message>::Log(const Message& p, std::string* l) {
779 l->append("<IPC::Message>");
782 #if defined(OS_WIN)
783 // Note that HWNDs/HANDLE/HCURSOR/HACCEL etc are always 32 bits, even on 64
784 // bit systems. That's why we use the Windows macros to convert to 32 bits.
785 void ParamTraits<HANDLE>::Write(Message* m, const param_type& p) {
786 m->WriteInt(HandleToLong(p));
789 bool ParamTraits<HANDLE>::Read(const Message* m, PickleIterator* iter,
790 param_type* r) {
791 int32 temp;
792 if (!m->ReadInt(iter, &temp))
793 return false;
794 *r = LongToHandle(temp);
795 return true;
798 void ParamTraits<HANDLE>::Log(const param_type& p, std::string* l) {
799 l->append(base::StringPrintf("0x%X", p));
802 void ParamTraits<LOGFONT>::Write(Message* m, const param_type& p) {
803 m->WriteData(reinterpret_cast<const char*>(&p), sizeof(LOGFONT));
806 bool ParamTraits<LOGFONT>::Read(const Message* m, PickleIterator* iter,
807 param_type* r) {
808 const char *data;
809 int data_size = 0;
810 if (m->ReadData(iter, &data, &data_size) && data_size == sizeof(LOGFONT)) {
811 const LOGFONT *font = reinterpret_cast<LOGFONT*>(const_cast<char*>(data));
812 if (_tcsnlen(font->lfFaceName, LF_FACESIZE) < LF_FACESIZE) {
813 memcpy(r, data, sizeof(LOGFONT));
814 return true;
818 NOTREACHED();
819 return false;
822 void ParamTraits<LOGFONT>::Log(const param_type& p, std::string* l) {
823 l->append(base::StringPrintf("<LOGFONT>"));
826 void ParamTraits<MSG>::Write(Message* m, const param_type& p) {
827 m->WriteData(reinterpret_cast<const char*>(&p), sizeof(MSG));
830 bool ParamTraits<MSG>::Read(const Message* m, PickleIterator* iter,
831 param_type* r) {
832 const char *data;
833 int data_size = 0;
834 bool result = m->ReadData(iter, &data, &data_size);
835 if (result && data_size == sizeof(MSG)) {
836 memcpy(r, data, sizeof(MSG));
837 } else {
838 result = false;
839 NOTREACHED();
842 return result;
845 void ParamTraits<MSG>::Log(const param_type& p, std::string* l) {
846 l->append("<MSG>");
849 #endif // OS_WIN
851 } // namespace IPC