blob: 9395b7351c086b5ee93efa0a642143dd54a7d18f [file] [log] [blame]
// Copyright 2016 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "cobalt/script/mozjs-45/wrapper_factory.h"
#include <utility>
#include "base/lazy_instance.h"
#include "cobalt/script/mozjs-45/mozjs_wrapper_handle.h"
#include "cobalt/script/mozjs-45/wrapper_private.h"
#include "third_party/mozjs-45/js/public/Proxy.h"
namespace cobalt {
namespace script {
namespace mozjs {
void WrapperFactory::RegisterWrappableType(
base::TypeId wrappable_type, const CreateWrapperFunction& create_function,
const PrototypeClassFunction& class_function) {
std::pair<WrappableTypeFunctionsHashMap::iterator, bool> pib =
wrappable_type_functions_.insert(std::make_pair(
wrappable_type,
WrappableTypeFunctions(create_function, class_function)));
DCHECK(pib.second)
<< "RegisterWrappableType registered for type more than once.";
}
JSObject* WrapperFactory::GetWrapperProxy(
const scoped_refptr<Wrappable>& wrappable) const {
if (!wrappable) {
return NULL;
}
JS::RootedObject wrapper_proxy(
context_,
MozjsWrapperHandle::GetObjectProxy(GetCachedWrapper(wrappable.get())));
if (!wrapper_proxy) {
scoped_ptr<Wrappable::WeakWrapperHandle> object_handle =
CreateWrapper(wrappable);
SetCachedWrapper(wrappable.get(), object_handle.Pass());
wrapper_proxy =
MozjsWrapperHandle::GetObjectProxy(GetCachedWrapper(wrappable.get()));
}
DCHECK(wrapper_proxy);
DCHECK(js::IsProxy(wrapper_proxy));
return wrapper_proxy;
}
bool WrapperFactory::HasWrapperProxy(
const scoped_refptr<Wrappable>& wrappable) const {
return wrappable &&
!!MozjsWrapperHandle::GetObjectProxy(
GetCachedWrapper(wrappable.get()));
}
bool WrapperFactory::IsWrapper(JS::HandleObject wrapper) const {
return JS_GetPrivate(wrapper) != NULL;
}
scoped_ptr<Wrappable::WeakWrapperHandle> WrapperFactory::CreateWrapper(
const scoped_refptr<Wrappable>& wrappable) const {
WrappableTypeFunctionsHashMap::const_iterator it =
wrappable_type_functions_.find(wrappable->GetWrappableType());
if (it == wrappable_type_functions_.end()) {
NOTREACHED();
return scoped_ptr<Wrappable::WeakWrapperHandle>();
}
JS::RootedObject new_proxy(
context_, it->second.create_wrapper.Run(context_, wrappable));
WrapperPrivate* wrapper_private =
WrapperPrivate::GetFromProxyObject(context_, new_proxy);
DCHECK(wrapper_private);
return make_scoped_ptr<Wrappable::WeakWrapperHandle>(
new MozjsWrapperHandle(wrapper_private));
}
bool WrapperFactory::DoesObjectImplementInterface(JS::HandleObject object,
base::TypeId type_id) const {
// If the object doesn't have a wrapper private which means it is not a
// platform object, so the object doesn't implement the interface.
if (!WrapperPrivate::HasWrapperPrivate(context_, object)) {
return false;
}
WrappableTypeFunctionsHashMap::const_iterator it =
wrappable_type_functions_.find(type_id);
if (it == wrappable_type_functions_.end()) {
NOTREACHED();
return false;
}
const JSClass* proto_class = it->second.prototype_class.Run(context_);
JS::RootedObject object_proto_object(context_);
bool success = JS_GetPrototype(context_, object, &object_proto_object);
bool equality = false;
while (!equality && success && object_proto_object) {
// Get the class of the prototype.
const JSClass* object_proto_class = JS_GetClass(object_proto_object);
equality = (object_proto_class == proto_class);
// Get the prototype of the previous prototype.
success =
JS_GetPrototype(context_, object_proto_object, &object_proto_object);
}
return equality;
}
} // namespace mozjs
} // namespace script
} // namespace cobalt