• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2014 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/renderer/java/gin_java_bridge_value_converter.h"
6 
7 #include "base/float_util.h"
8 #include "base/values.h"
9 #include "content/common/android/gin_java_bridge_value.h"
10 #include "content/renderer/java/gin_java_bridge_object.h"
11 #include "gin/array_buffer.h"
12 
13 namespace content {
14 
GinJavaBridgeValueConverter()15 GinJavaBridgeValueConverter::GinJavaBridgeValueConverter()
16     : converter_(V8ValueConverter::create()) {
17   converter_->SetDateAllowed(false);
18   converter_->SetRegExpAllowed(false);
19   converter_->SetFunctionAllowed(true);
20   converter_->SetStrategy(this);
21 }
22 
~GinJavaBridgeValueConverter()23 GinJavaBridgeValueConverter::~GinJavaBridgeValueConverter() {
24 }
25 
ToV8Value(const base::Value * value,v8::Handle<v8::Context> context) const26 v8::Handle<v8::Value> GinJavaBridgeValueConverter::ToV8Value(
27     const base::Value* value,
28     v8::Handle<v8::Context> context) const {
29   return converter_->ToV8Value(value, context);
30 }
31 
FromV8Value(v8::Handle<v8::Value> value,v8::Handle<v8::Context> context) const32 scoped_ptr<base::Value> GinJavaBridgeValueConverter::FromV8Value(
33     v8::Handle<v8::Value> value,
34     v8::Handle<v8::Context> context) const {
35   return make_scoped_ptr(converter_->FromV8Value(value, context));
36 }
37 
FromV8Object(v8::Handle<v8::Object> value,base::Value ** out,v8::Isolate * isolate,const FromV8ValueCallback & callback) const38 bool GinJavaBridgeValueConverter::FromV8Object(
39     v8::Handle<v8::Object> value,
40     base::Value** out,
41     v8::Isolate* isolate,
42     const FromV8ValueCallback& callback) const {
43   GinJavaBridgeObject* unwrapped;
44   if (!gin::ConvertFromV8(isolate, value, &unwrapped)) {
45     return false;
46   }
47   *out =
48       GinJavaBridgeValue::CreateObjectIDValue(unwrapped->object_id()).release();
49   return true;
50 }
51 
52 namespace {
53 
54 class TypedArraySerializer {
55  public:
~TypedArraySerializer()56   virtual ~TypedArraySerializer() {}
57   static scoped_ptr<TypedArraySerializer> Create(
58       v8::Handle<v8::TypedArray> typed_array);
59   virtual void serializeTo(char* data,
60                            size_t data_length,
61                            base::ListValue* out) = 0;
62  protected:
TypedArraySerializer()63   TypedArraySerializer() {}
64 };
65 
66 template <typename ElementType, typename ListType>
67 class TypedArraySerializerImpl : public TypedArraySerializer {
68  public:
Create(v8::Handle<v8::TypedArray> typed_array)69   static scoped_ptr<TypedArraySerializer> Create(
70       v8::Handle<v8::TypedArray> typed_array) {
71     scoped_ptr<TypedArraySerializerImpl<ElementType, ListType> > result(
72         new TypedArraySerializerImpl<ElementType, ListType>(typed_array));
73     return result.template PassAs<TypedArraySerializer>();
74   }
75 
serializeTo(char * data,size_t data_length,base::ListValue * out)76   virtual void serializeTo(char* data,
77                    size_t data_length,
78                    base::ListValue* out) OVERRIDE {
79     DCHECK_EQ(data_length, typed_array_->Length() * sizeof(ElementType));
80     for (ElementType *element = reinterpret_cast<ElementType*>(data),
81                      *end = element + typed_array_->Length();
82          element != end;
83          ++element) {
84       const ListType list_value = *element;
85       out->Append(new base::FundamentalValue(list_value));
86     }
87   }
88 
89  private:
TypedArraySerializerImpl(v8::Handle<v8::TypedArray> typed_array)90   explicit TypedArraySerializerImpl(v8::Handle<v8::TypedArray> typed_array)
91       : typed_array_(typed_array) {}
92 
93   v8::Handle<v8::TypedArray> typed_array_;
94 
95   DISALLOW_COPY_AND_ASSIGN(TypedArraySerializerImpl);
96 };
97 
98 // static
Create(v8::Handle<v8::TypedArray> typed_array)99 scoped_ptr<TypedArraySerializer> TypedArraySerializer::Create(
100     v8::Handle<v8::TypedArray> typed_array) {
101   if (typed_array->IsInt8Array() ||
102       typed_array->IsUint8Array() ||
103       typed_array->IsUint8ClampedArray()) {
104     return TypedArraySerializerImpl<char, int>::Create(typed_array).Pass();
105   } else if (typed_array->IsInt16Array() || typed_array->IsUint16Array()) {
106     return TypedArraySerializerImpl<int16_t, int>::Create(typed_array).Pass();
107   } else if (typed_array->IsInt32Array() || typed_array->IsUint32Array()) {
108     return TypedArraySerializerImpl<int32_t, int>::Create(typed_array).Pass();
109   } else if (typed_array->IsFloat32Array()) {
110     return TypedArraySerializerImpl<float, double>::Create(typed_array).Pass();
111   } else if (typed_array->IsFloat64Array()) {
112     return TypedArraySerializerImpl<double, double>::Create(typed_array).Pass();
113   }
114   NOTREACHED();
115   return scoped_ptr<TypedArraySerializer>();
116 }
117 
118 }  // namespace
119 
FromV8ArrayBuffer(v8::Handle<v8::Object> value,base::Value ** out,v8::Isolate * isolate) const120 bool GinJavaBridgeValueConverter::FromV8ArrayBuffer(
121     v8::Handle<v8::Object> value,
122     base::Value** out,
123     v8::Isolate* isolate) const {
124   if (!value->IsTypedArray()) {
125     *out = GinJavaBridgeValue::CreateUndefinedValue().release();
126     return true;
127   }
128 
129   char* data = NULL;
130   size_t data_length = 0;
131   gin::ArrayBufferView view;
132   if (ConvertFromV8(isolate, value.As<v8::ArrayBufferView>(), &view)) {
133     data = reinterpret_cast<char*>(view.bytes());
134     data_length = view.num_bytes();
135   }
136   if (!data) {
137     *out = GinJavaBridgeValue::CreateUndefinedValue().release();
138     return true;
139   }
140 
141   base::ListValue* result = new base::ListValue();
142   *out = result;
143   scoped_ptr<TypedArraySerializer> serializer(
144       TypedArraySerializer::Create(value.As<v8::TypedArray>()));
145   serializer->serializeTo(data, data_length, result);
146   return true;
147 }
148 
FromV8Number(v8::Handle<v8::Number> value,base::Value ** out) const149 bool GinJavaBridgeValueConverter::FromV8Number(v8::Handle<v8::Number> value,
150                                                base::Value** out) const {
151   double double_value = value->Value();
152   if (base::IsFinite(double_value))
153     return false;
154   *out = GinJavaBridgeValue::CreateNonFiniteValue(double_value).release();
155   return true;
156 }
157 
FromV8Undefined(base::Value ** out) const158 bool GinJavaBridgeValueConverter::FromV8Undefined(base::Value** out) const {
159   *out = GinJavaBridgeValue::CreateUndefinedValue().release();
160   return true;
161 }
162 
163 }  // namespace content
164