1// Copyright 2013 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.
4
5#include "content/child/plugin_param_traits.h"
6
7#include "base/strings/string_number_conversions.h"
8#include "ipc/ipc_message_utils.h"
9#include "third_party/WebKit/public/web/WebBindings.h"
10
11namespace content {
12
13NPIdentifier_Param::NPIdentifier_Param()
14    : identifier() {
15}
16
17NPIdentifier_Param::~NPIdentifier_Param() {
18}
19
20NPVariant_Param::NPVariant_Param()
21    : type(NPVARIANT_PARAM_VOID),
22      bool_value(false),
23      int_value(0),
24      double_value(0),
25      npobject_routing_id(-1),
26      npobject_owner_id(-1) {
27}
28
29NPVariant_Param::~NPVariant_Param() {
30}
31
32}  // namespace content
33
34using content::NPIdentifier_Param;
35using content::NPVariant_Param;
36
37namespace IPC {
38
39void ParamTraits<NPVariant_Param>::Write(Message* m, const param_type& p) {
40  WriteParam(m, static_cast<int>(p.type));
41  if (p.type == content::NPVARIANT_PARAM_BOOL) {
42    WriteParam(m, p.bool_value);
43  } else if (p.type == content::NPVARIANT_PARAM_INT) {
44    WriteParam(m, p.int_value);
45  } else if (p.type == content::NPVARIANT_PARAM_DOUBLE) {
46    WriteParam(m, p.double_value);
47  } else if (p.type == content::NPVARIANT_PARAM_STRING) {
48    WriteParam(m, p.string_value);
49  } else if (p.type == content::NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID ||
50             p.type == content::NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID) {
51    // This is the routing id used to connect NPObjectProxy in the other
52    // process with NPObjectStub in this process or to identify the raw
53    // npobject pointer to be used in the callee process.
54    WriteParam(m, p.npobject_routing_id);
55    // This is a routing Id used to identify the plugin instance that owns
56    // the object, for ownership-tracking purposes.
57    WriteParam(m, p.npobject_owner_id);
58  } else {
59    DCHECK(p.type == content::NPVARIANT_PARAM_VOID ||
60           p.type == content::NPVARIANT_PARAM_NULL);
61  }
62}
63
64bool ParamTraits<NPVariant_Param>::Read(const Message* m,
65                                        PickleIterator* iter,
66                                        param_type* r) {
67  int type;
68  if (!ReadParam(m, iter, &type))
69    return false;
70
71  bool result = false;
72  r->type = static_cast<content::NPVariant_ParamEnum>(type);
73  if (r->type == content::NPVARIANT_PARAM_BOOL) {
74    result = ReadParam(m, iter, &r->bool_value);
75  } else if (r->type == content::NPVARIANT_PARAM_INT) {
76    result = ReadParam(m, iter, &r->int_value);
77  } else if (r->type == content::NPVARIANT_PARAM_DOUBLE) {
78    result = ReadParam(m, iter, &r->double_value);
79  } else if (r->type == content::NPVARIANT_PARAM_STRING) {
80    result = ReadParam(m, iter, &r->string_value);
81  } else if (r->type == content::NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID ||
82             r->type == content::NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID) {
83    result = ReadParam(m, iter, &r->npobject_routing_id) &&
84        ReadParam(m, iter, &r->npobject_owner_id);
85  } else if ((r->type == content::NPVARIANT_PARAM_VOID) ||
86             (r->type == content::NPVARIANT_PARAM_NULL)) {
87    result = true;
88  } else {
89    NOTREACHED();
90  }
91
92  return result;
93}
94
95void ParamTraits<NPVariant_Param>::Log(const param_type& p, std::string* l) {
96  l->append(
97      base::StringPrintf("NPVariant_Param(%d, ", static_cast<int>(p.type)));
98  if (p.type == content::NPVARIANT_PARAM_BOOL) {
99    LogParam(p.bool_value, l);
100  } else if (p.type == content::NPVARIANT_PARAM_INT) {
101    LogParam(p.int_value, l);
102  } else if (p.type == content::NPVARIANT_PARAM_DOUBLE) {
103    LogParam(p.double_value, l);
104  } else if (p.type == content::NPVARIANT_PARAM_STRING) {
105    LogParam(p.string_value, l);
106  } else if (p.type == content::NPVARIANT_PARAM_SENDER_OBJECT_ROUTING_ID ||
107             p.type == content::NPVARIANT_PARAM_RECEIVER_OBJECT_ROUTING_ID) {
108    LogParam(p.npobject_routing_id, l);
109  } else {
110    l->append("<none>");
111  }
112  l->append(")");
113}
114
115void ParamTraits<NPIdentifier_Param>::Write(Message* m, const param_type& p) {
116  content::SerializeNPIdentifier(p.identifier, m);
117}
118
119bool ParamTraits<NPIdentifier_Param>::Read(const Message* m,
120                                           PickleIterator* iter,
121                                           param_type* r) {
122  return content::DeserializeNPIdentifier(iter, &r->identifier);
123}
124
125void ParamTraits<NPIdentifier_Param>::Log(const param_type& p, std::string* l) {
126  if (blink::WebBindings::identifierIsString(p.identifier)) {
127    NPUTF8* str = blink::WebBindings::utf8FromIdentifier(p.identifier);
128    l->append(str);
129    free(str);
130  } else {
131    l->append(base::IntToString(
132        blink::WebBindings::intFromIdentifier(p.identifier)));
133  }
134}
135
136}  // namespace IPC
137