1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
// 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/shared_impl/private/ppb_x509_certificate_private_shared.h"
#include "base/logging.h"
#include "ppapi/shared_impl/ppapi_globals.h"
#include "ppapi/shared_impl/var.h"
#include "ppapi/shared_impl/var_tracker.h"
namespace ppapi {
PPB_X509Certificate_Fields::PPB_X509Certificate_Fields() {}
PPB_X509Certificate_Fields::PPB_X509Certificate_Fields(
const PPB_X509Certificate_Fields& fields) {
scoped_ptr<ListValue> new_values(fields.values_.DeepCopy());
values_.Swap(new_values.get());
}
void PPB_X509Certificate_Fields::SetField(
PP_X509Certificate_Private_Field field,
base::Value* value) {
uint32_t index = static_cast<uint32_t>(field);
bool success = values_.Set(index, value);
DCHECK(success);
}
PP_Var PPB_X509Certificate_Fields::GetFieldAsPPVar(
PP_X509Certificate_Private_Field field) const {
uint32_t index = static_cast<uint32_t>(field);
base::Value* value;
bool success = values_.Get(index, &value);
if (!success) {
// Our list received might be smaller than the number of fields, so just
// return null if the index is OOB.
return PP_MakeNull();
}
switch (value->GetType()) {
case Value::TYPE_NULL:
return PP_MakeNull();
case Value::TYPE_BOOLEAN: {
bool val;
value->GetAsBoolean(&val);
return PP_MakeBool(PP_FromBool(val));
}
case Value::TYPE_INTEGER: {
int val;
value->GetAsInteger(&val);
return PP_MakeInt32(val);
}
case Value::TYPE_DOUBLE: {
double val;
value->GetAsDouble(&val);
return PP_MakeDouble(val);
}
case Value::TYPE_STRING: {
std::string val;
value->GetAsString(&val);
return StringVar::StringToPPVar(val);
}
case Value::TYPE_BINARY: {
const base::BinaryValue* binary =
static_cast<const base::BinaryValue*>(value);
uint32_t size = static_cast<uint32_t>(binary->GetSize());
const char* buffer = binary->GetBuffer();
PP_Var array_buffer =
PpapiGlobals::Get()->GetVarTracker()->MakeArrayBufferPPVar(size,
buffer);
return array_buffer;
}
case Value::TYPE_DICTIONARY:
case Value::TYPE_LIST:
// Not handled.
break;
}
// Should not reach here.
CHECK(false);
return PP_MakeUndefined();
}
//------------------------------------------------------------------------------
PPB_X509Certificate_Private_Shared::PPB_X509Certificate_Private_Shared(
ResourceObjectType type,
PP_Instance instance) : Resource(type, instance), fields_(NULL) {
}
PPB_X509Certificate_Private_Shared::PPB_X509Certificate_Private_Shared(
ResourceObjectType type,
PP_Instance instance,
const PPB_X509Certificate_Fields& fields)
: Resource(type, instance),
fields_(new PPB_X509Certificate_Fields(fields)) {
}
PPB_X509Certificate_Private_Shared::~PPB_X509Certificate_Private_Shared() {
}
thunk::PPB_X509Certificate_Private_API*
PPB_X509Certificate_Private_Shared::AsPPB_X509Certificate_Private_API() {
return this;
}
PP_Bool PPB_X509Certificate_Private_Shared::Initialize(const char* bytes,
uint32_t length) {
// The certificate should be immutable once initialized.
if (fields_.get())
return PP_FALSE;
if (!bytes || length == 0)
return PP_FALSE;
std::vector<char> der(bytes, bytes + length);
scoped_ptr<PPB_X509Certificate_Fields> fields(
new PPB_X509Certificate_Fields());
bool success = ParseDER(der, fields.get());
if (success) {
fields_.swap(fields);
return PP_TRUE;
}
return PP_FALSE;
}
PP_Var PPB_X509Certificate_Private_Shared::GetField(
PP_X509Certificate_Private_Field field) {
if (!fields_.get())
return PP_MakeUndefined();
return fields_->GetFieldAsPPVar(field);
}
bool PPB_X509Certificate_Private_Shared::ParseDER(
const std::vector<char>& der,
PPB_X509Certificate_Fields* result) {
// A concrete PPB_X509Certificate_Private_Shared should only ever be
// constructed by passing in PPB_X509Certificate_Fields, in which case it is
// already initialized.
CHECK(false);
return false;
}
} // namespace ppapi
|
