[PPAPI] Compositor API implementation

ppapi/proxy/ppapi_param_traits.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 "ppapi/proxy/ppapi_param_traits.h"
 
 #include <string.h>  // For memcpy
 
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/proxy/ppapi_messages.h"
@@ skipping 615 matching lines @@
     // No default so the compiler will warn on new types.
   }
   return false;
 }
 
 // static
 void ParamTraits<ppapi::SocketOptionData>::Log(const param_type& p,
                                                std::string* l) {
 }
 
+// ppapi::CompositorLayer ------------------------------------------------------
+
+// static
+void ParamTraits<ppapi::CompositorLayer::Mailbox>::Write(Message* m,
+                                                         const param_type& p) {
+  m->WriteBytes(p, sizeof(p));
+}
+
+// static
+bool ParamTraits<ppapi::CompositorLayer::Mailbox>::Read(const Message* m,
+                                                        PickleIterator* iter,
+                                                        param_type* r) {
+  const char* data = NULL;
+  if (!m->ReadBytes(iter, &data, sizeof(*r)))
+    return false;
+  memcpy(r, data, sizeof(*r));
+  return true;
+}
+
+// static
+void ParamTraits<ppapi::CompositorLayer::Mailbox>::Log(const param_type& p,
+                                                       std::string* l) {
+}
+
+// static
+void ParamTraits<ppapi::CompositorLayer>::Write(Message* m,
+                                                const param_type& p) {
+  ParamTraits<ppapi::CompositorLayer::Type>::Write(m, p.type);
+  ParamTraits<PP_Size>::Write(m, p.size);
+  ParamTraits<PP_Rect>::Write(m, p.clip_rect);
+  for (size_t i = 0; i < arraysize(p.transform); i++)
+    ParamTraits<float>::Write(m, p.transform[i]);
+  ParamTraits<PP_BlendMode>::Write(m, p.blend_mode);
+  ParamTraits<uint8_t>::Write(m, p.opacity);
+  switch(p.type) {
+    case ppapi::CompositorLayer::TYPE_COLOR:
+      ParamTraits<uint8_t>::Write(m, p.color.red);
+      ParamTraits<uint8_t>::Write(m, p.color.green);
+      ParamTraits<uint8_t>::Write(m, p.color.blue);
+      ParamTraits<uint8_t>::Write(m, p.color.alpha);
+      break;
+    case ppapi::CompositorLayer::TYPE_TEXTURE:
+      ParamTraits<int32_t>::Write(m, p.texture.id);
+      ParamTraits<ppapi::CompositorLayer::Mailbox>::Write(m, p.texture.mailbox);
+      ParamTraits<uint32_t>::Write(m, p.texture.sync_point);
+      ParamTraits<PP_FloatRect>::Write(m, p.texture.source_rect);
+      ParamTraits<bool>::Write(m, p.texture.premult_alpha);
+      break;
+    case ppapi::CompositorLayer::TYPE_IMAGE:
+      ParamTraits<int32_t>::Write(m, p.image.id);
+      ParamTraits<PP_Instance>::Write(m, p.image.instance);
+      ParamTraits<PP_Resource>::Write(m, p.image.host_resource);
+      ParamTraits<PP_FloatRect>::Write(m, p.texture.source_rect);
+      break;
+    default:
+      NOTREACHED();
+  };
+}
+
+// static
+bool ParamTraits<ppapi::CompositorLayer>::Read(const Message* m,
+                                               PickleIterator* iter,
+                                               param_type* r) {
+  if (!ParamTraits<ppapi::CompositorLayer::Type>::Read(m, iter, &r->type))
+    return false;
+  if (!ParamTraits<PP_Size>::Read(m, iter, &r->size))
+    return false;
+  ParamTraits<PP_Rect>::Read(m, iter, &r->clip_rect);
+  for (size_t i = 0; i < arraysize(r->transform);i++) {
+    if (!ParamTraits<float>::Read(m, iter, &r->transform[i]))
+      return false;
+  }
+  if (!ParamTraits<PP_BlendMode>::Read(m, iter, &r->blend_mode))
+    return false;
+  if (!ParamTraits<uint8_t>::Read(m, iter, &r->opacity))
+    return false;
+  switch(r->type) {
+    case ppapi::CompositorLayer::TYPE_COLOR:
+      return
+          ParamTraits<uint8_t>::Read(m, iter, &r->color.red) &&
+          ParamTraits<uint8_t>::Read(m, iter, &r->color.green) &&
+          ParamTraits<uint8_t>::Read(m, iter, &r->color.blue) &&
+          ParamTraits<uint8_t>::Read(m, iter, &r->color.alpha);
+    case ppapi::CompositorLayer::TYPE_TEXTURE:
+      return
+          ParamTraits<int32_t>::Read(m, iter, &r->texture.id) &&
+          ParamTraits<ppapi::CompositorLayer::Mailbox>::Read(
+              m, iter, &r->texture.mailbox) &&
+          ParamTraits<uint32_t>::Read(m, iter, &r->texture.sync_point) &&
+          ParamTraits<PP_FloatRect>::Read(m, iter, &r->texture.source_rect) &&
+          ParamTraits<bool>::Read(m, iter, &r->texture.premult_alpha);
+    case ppapi::CompositorLayer::TYPE_IMAGE:
+      return
+          ParamTraits<int32_t>::Read(m, iter, &r->image.id) &&
+          ParamTraits<PP_Instance>::Read(m, iter, &r->image.instance) &&
+          ParamTraits<PP_Resource>::Read(m, iter, &r->image.host_resource) &&
+          ParamTraits<PP_FloatRect>::Read(m, iter, &r->texture.source_rect);
+    default:
+       NOTREACHED();

[raymes, 2014/06/02 03:51:08]

return false?

[Peng, 2014/06/02 19:01:55]

Done.

+  }
+
+  return true;
+}
+
+// static
+void ParamTraits<ppapi::CompositorLayer>::Log(const param_type& p,
+                                              std::string* l) {
+}
+
 }  // namespace IPC