OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "gpu/ipc/gpu_command_buffer_traits.h" | 5 #include "gpu/ipc/gpu_command_buffer_traits.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 | 9 |
10 #include "gpu/command_buffer/common/mailbox_holder.h" | 10 #include "gpu/command_buffer/common/mailbox_holder.h" |
(...skipping 13 matching lines...) Expand all Loading... |
24 } // namespace IPC | 24 } // namespace IPC |
25 | 25 |
26 // Generate param traits log methods. | 26 // Generate param traits log methods. |
27 #include "ipc/param_traits_log_macros.h" | 27 #include "ipc/param_traits_log_macros.h" |
28 namespace IPC { | 28 namespace IPC { |
29 #include "gpu/ipc/gpu_command_buffer_traits_multi.h" | 29 #include "gpu/ipc/gpu_command_buffer_traits_multi.h" |
30 } // namespace IPC | 30 } // namespace IPC |
31 | 31 |
32 namespace IPC { | 32 namespace IPC { |
33 | 33 |
34 void ParamTraits<gpu::CommandBuffer::State> ::Write(Message* m, | 34 void ParamTraits<gpu::CommandBuffer::State>::Write(base::Pickle* m, |
35 const param_type& p) { | 35 const param_type& p) { |
36 WriteParam(m, p.get_offset); | 36 WriteParam(m, p.get_offset); |
37 WriteParam(m, p.token); | 37 WriteParam(m, p.token); |
38 WriteParam(m, p.error); | 38 WriteParam(m, p.error); |
39 WriteParam(m, p.generation); | 39 WriteParam(m, p.generation); |
40 } | 40 } |
41 | 41 |
42 bool ParamTraits<gpu::CommandBuffer::State> ::Read(const Message* m, | 42 bool ParamTraits<gpu::CommandBuffer::State>::Read(const base::Pickle* m, |
43 base::PickleIterator* iter, | 43 base::PickleIterator* iter, |
44 param_type* p) { | 44 param_type* p) { |
45 if (ReadParam(m, iter, &p->get_offset) && | 45 if (ReadParam(m, iter, &p->get_offset) && |
46 ReadParam(m, iter, &p->token) && | 46 ReadParam(m, iter, &p->token) && |
47 ReadParam(m, iter, &p->error) && | 47 ReadParam(m, iter, &p->error) && |
48 ReadParam(m, iter, &p->generation)) { | 48 ReadParam(m, iter, &p->generation)) { |
49 return true; | 49 return true; |
50 } else { | 50 } else { |
51 return false; | 51 return false; |
52 } | 52 } |
53 } | 53 } |
54 | 54 |
55 void ParamTraits<gpu::CommandBuffer::State> ::Log(const param_type& p, | 55 void ParamTraits<gpu::CommandBuffer::State> ::Log(const param_type& p, |
56 std::string* l) { | 56 std::string* l) { |
57 l->append("<CommandBuffer::State>"); | 57 l->append("<CommandBuffer::State>"); |
58 } | 58 } |
59 | 59 |
60 void ParamTraits<gpu::SyncToken>::Write(Message* m, const param_type& p) { | 60 void ParamTraits<gpu::SyncToken>::Write(base::Pickle* m, const param_type& p) { |
61 DCHECK(!p.HasData() || p.verified_flush()); | 61 DCHECK(!p.HasData() || p.verified_flush()); |
62 | 62 |
63 WriteParam(m, p.verified_flush()); | 63 WriteParam(m, p.verified_flush()); |
64 WriteParam(m, p.namespace_id()); | 64 WriteParam(m, p.namespace_id()); |
65 WriteParam(m, p.command_buffer_id()); | 65 WriteParam(m, p.command_buffer_id()); |
66 WriteParam(m, p.release_count()); | 66 WriteParam(m, p.release_count()); |
67 } | 67 } |
68 | 68 |
69 bool ParamTraits<gpu::SyncToken>::Read(const Message* m, | 69 bool ParamTraits<gpu::SyncToken>::Read(const base::Pickle* m, |
70 base::PickleIterator* iter, | 70 base::PickleIterator* iter, |
71 param_type* p) { | 71 param_type* p) { |
72 bool verified_flush = false; | 72 bool verified_flush = false; |
73 gpu::CommandBufferNamespace namespace_id = | 73 gpu::CommandBufferNamespace namespace_id = |
74 gpu::CommandBufferNamespace::INVALID; | 74 gpu::CommandBufferNamespace::INVALID; |
75 uint64_t command_buffer_id = 0; | 75 uint64_t command_buffer_id = 0; |
76 uint64_t release_count = 0; | 76 uint64_t release_count = 0; |
77 | 77 |
78 if (!ReadParam(m, iter, &verified_flush) || | 78 if (!ReadParam(m, iter, &verified_flush) || |
79 !ReadParam(m, iter, &namespace_id) || | 79 !ReadParam(m, iter, &namespace_id) || |
(...skipping 12 matching lines...) Expand all Loading... |
92 return true; | 92 return true; |
93 } | 93 } |
94 | 94 |
95 void ParamTraits<gpu::SyncToken>::Log(const param_type& p, std::string* l) { | 95 void ParamTraits<gpu::SyncToken>::Log(const param_type& p, std::string* l) { |
96 *l += | 96 *l += |
97 base::StringPrintf("[%d:%llX] %llu", static_cast<int>(p.namespace_id()), | 97 base::StringPrintf("[%d:%llX] %llu", static_cast<int>(p.namespace_id()), |
98 static_cast<unsigned long long>(p.command_buffer_id()), | 98 static_cast<unsigned long long>(p.command_buffer_id()), |
99 static_cast<unsigned long long>(p.release_count())); | 99 static_cast<unsigned long long>(p.release_count())); |
100 } | 100 } |
101 | 101 |
102 void ParamTraits<gpu::Mailbox>::Write(Message* m, const param_type& p) { | 102 void ParamTraits<gpu::Mailbox>::Write(base::Pickle* m, const param_type& p) { |
103 m->WriteBytes(p.name, sizeof(p.name)); | 103 m->WriteBytes(p.name, sizeof(p.name)); |
104 } | 104 } |
105 | 105 |
106 bool ParamTraits<gpu::Mailbox> ::Read(const Message* m, | 106 bool ParamTraits<gpu::Mailbox>::Read(const base::Pickle* m, |
107 base::PickleIterator* iter, | 107 base::PickleIterator* iter, |
108 param_type* p) { | 108 param_type* p) { |
109 const char* bytes = NULL; | 109 const char* bytes = NULL; |
110 if (!iter->ReadBytes(&bytes, sizeof(p->name))) | 110 if (!iter->ReadBytes(&bytes, sizeof(p->name))) |
111 return false; | 111 return false; |
112 DCHECK(bytes); | 112 DCHECK(bytes); |
113 memcpy(p->name, bytes, sizeof(p->name)); | 113 memcpy(p->name, bytes, sizeof(p->name)); |
114 return true; | 114 return true; |
115 } | 115 } |
116 | 116 |
117 void ParamTraits<gpu::Mailbox>::Log(const param_type& p, std::string* l) { | 117 void ParamTraits<gpu::Mailbox>::Log(const param_type& p, std::string* l) { |
118 for (size_t i = 0; i < sizeof(p.name); ++i) | 118 for (size_t i = 0; i < sizeof(p.name); ++i) |
119 *l += base::StringPrintf("%02x", p.name[i]); | 119 *l += base::StringPrintf("%02x", p.name[i]); |
120 } | 120 } |
121 | 121 |
122 void ParamTraits<gpu::MailboxHolder>::Write(Message* m, const param_type& p) { | 122 void ParamTraits<gpu::MailboxHolder>::Write(base::Pickle* m, |
| 123 const param_type& p) { |
123 WriteParam(m, p.mailbox); | 124 WriteParam(m, p.mailbox); |
124 WriteParam(m, p.sync_token); | 125 WriteParam(m, p.sync_token); |
125 WriteParam(m, p.texture_target); | 126 WriteParam(m, p.texture_target); |
126 } | 127 } |
127 | 128 |
128 bool ParamTraits<gpu::MailboxHolder> ::Read(const Message* m, | 129 bool ParamTraits<gpu::MailboxHolder>::Read(const base::Pickle* m, |
129 base::PickleIterator* iter, | 130 base::PickleIterator* iter, |
130 param_type* p) { | 131 param_type* p) { |
131 if (!ReadParam(m, iter, &p->mailbox) || !ReadParam(m, iter, &p->sync_token) || | 132 if (!ReadParam(m, iter, &p->mailbox) || !ReadParam(m, iter, &p->sync_token) || |
132 !ReadParam(m, iter, &p->texture_target)) | 133 !ReadParam(m, iter, &p->texture_target)) |
133 return false; | 134 return false; |
134 return true; | 135 return true; |
135 } | 136 } |
136 | 137 |
137 void ParamTraits<gpu::MailboxHolder>::Log(const param_type& p, std::string* l) { | 138 void ParamTraits<gpu::MailboxHolder>::Log(const param_type& p, std::string* l) { |
138 LogParam(p.mailbox, l); | 139 LogParam(p.mailbox, l); |
139 LogParam(p.sync_token, l); | 140 LogParam(p.sync_token, l); |
140 *l += base::StringPrintf(":%04x@", p.texture_target); | 141 *l += base::StringPrintf(":%04x@", p.texture_target); |
141 } | 142 } |
142 | 143 |
143 void ParamTraits<gpu::ValueState>::Write(Message* m, const param_type& p) { | 144 void ParamTraits<gpu::ValueState>::Write(base::Pickle* m, const param_type& p) { |
144 m->WriteData(reinterpret_cast<const char*>(&p), | 145 m->WriteData(reinterpret_cast<const char*>(&p), |
145 sizeof(gpu::ValueState)); | 146 sizeof(gpu::ValueState)); |
146 } | 147 } |
147 | 148 |
148 bool ParamTraits<gpu::ValueState> ::Read(const Message* m, | 149 bool ParamTraits<gpu::ValueState>::Read(const base::Pickle* m, |
149 base::PickleIterator* iter, | 150 base::PickleIterator* iter, |
150 param_type* p) { | 151 param_type* p) { |
151 int length; | 152 int length; |
152 const char* data = NULL; | 153 const char* data = NULL; |
153 if (!iter->ReadData(&data, &length) || length != sizeof(gpu::ValueState)) | 154 if (!iter->ReadData(&data, &length) || length != sizeof(gpu::ValueState)) |
154 return false; | 155 return false; |
155 DCHECK(data); | 156 DCHECK(data); |
156 memcpy(p, data, sizeof(gpu::ValueState)); | 157 memcpy(p, data, sizeof(gpu::ValueState)); |
157 return true; | 158 return true; |
158 } | 159 } |
159 | 160 |
160 void ParamTraits<gpu::ValueState>::Log(const param_type& p, std::string* l) { | 161 void ParamTraits<gpu::ValueState>::Log(const param_type& p, std::string* l) { |
161 l->append("<ValueState ("); | 162 l->append("<ValueState ("); |
162 for (int value : p.int_value) | 163 for (int value : p.int_value) |
163 *l += base::StringPrintf("%i ", value); | 164 *l += base::StringPrintf("%i ", value); |
164 l->append(" int values "); | 165 l->append(" int values "); |
165 for (float value : p.float_value) | 166 for (float value : p.float_value) |
166 *l += base::StringPrintf("%f ", value); | 167 *l += base::StringPrintf("%f ", value); |
167 l->append(" float values)>"); | 168 l->append(" float values)>"); |
168 } | 169 } |
169 | 170 |
170 } // namespace IPC | 171 } // namespace IPC |
OLD | NEW |