Implement TextureImageTransportSurface using texture mailbox

ipc/ipc_message_utils.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 "ipc/ipc_message_utils.h"
 
 #include "base/file_path.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/nullable_string16.h"
@@ skipping 408 matching lines @@
   if (data_size)
     memcpy(&r->front(), data, data_size);
   return true;
 }
 
 void ParamTraits<std::vector<unsigned char> >::Log(const param_type& p,
                                                    std::string* l) {
   LogBytes(p, l);
 }
 
+void ParamTraits<std::vector<signed char> >::Write(Message* m,

[apatrick_chromium, 2012/11/09 19:19:04]

Are you sure you need explicit ParamTraits for std::vector? I think it will just
work?

Also, I've been using std::string to shuttle mailbox names around by IPC. It's
less typing :) std::string can hold null characters so it works.

[no sievers, 2012/11/09 21:53:02]

It has the ipc traits for char and unsigned char.
But ut did not compile with gcc. I think maybe because strictly speaking char,
signed char and unsigned char are different types?

I initially used string but then changed it because passing it around and
casting pointers become a little ugly.


On 2012/11/09 19:19:04, apatrick_chromium wrote:

[piman, 2012/11/09 22:02:01]

It will work though use an int for each char (i.e. conversion + extra size).
This sounds like a good idea.

[no sievers, 2012/11/19 20:30:44]

I switched it to using strings.

+                                                   const param_type& p) {
+  if (p.empty()) {
+    m->WriteData(NULL, 0);
+  } else {
+    m->WriteData(reinterpret_cast<const char*>(&p.front()),
+                 static_cast<int>(p.size()));
+  }
+}
+
+bool ParamTraits<std::vector<signed char> >::Read(const Message* m,
+                                                  PickleIterator* iter,
+                                                  param_type* r) {
+  const char *data;
+  int data_size = 0;
+  if (!m->ReadData(iter, &data, &data_size) || data_size < 0)
+    return false;
+  r->resize(data_size);
+  if (data_size)
+    memcpy(&r->front(), data, data_size);
+  return true;
+}
+
+void ParamTraits<std::vector<signed char> >::Log(const param_type& p,
+                                                 std::string* l) {
+  LogBytes(p, l);
+}
+
 void ParamTraits<std::vector<bool> >::Write(Message* m, const param_type& p) {
   WriteParam(m, static_cast<int>(p.size()));
   for (size_t i = 0; i < p.size(); i++)
     WriteParam(m, p[i]);
 }
 
 bool ParamTraits<std::vector<bool> >::Read(const Message* m,
                                            PickleIterator* iter,
                                            param_type* r) {
   int size;
@@ skipping 401 matching lines @@
   return result;
 }
 
 void ParamTraits<MSG>::Log(const param_type& p, std::string* l) {
   l->append("<MSG>");
 }
 
 #endif  // OS_WIN
 
 }  // namespace IPC