js_wrappers.h

Go to the documentation of this file.

// Copyright 2016 Google LLC
//
// 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
//
//     https://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.

#ifndef SHAKA_EMBEDDED_MAPPING_JS_WRAPPERS_H_
#define SHAKA_EMBEDDED_MAPPING_JS_WRAPPERS_H_

#include <glog/logging.h>

#include <string>
#include <vector>

#include "src/util/macros.h"
// Use the IndexedDB protobuf for ValueType so we don't have to duplicate
// the enum here and for IndexedDB storage.
#include "src/js/idb/database.pb.h"

#if defined(USING_V8)
#  include <v8.h>
#  include "src/mapping/v8/v8_utils.h"
#elif defined(USING_JSC)
#  include <JavaScriptCore/JavaScriptCore.h>
#  include "src/mapping/jsc/jsc_utils.h"
#  include "src/util/cfref.h"
#endif

namespace shaka {

class BackingObject;

namespace util {

#ifdef USING_JSC
template <>
struct RefTypeTraits<JSStringRef> {
  static constexpr const bool AcquireWithRaw = false;

  static JSStringRef Duplicate(JSStringRef arg) {
    if (arg)
      JSStringRetain(arg);
    return arg;
  }

  static void Release(JSStringRef arg) {
    if (arg)
      JSStringRelease(arg);
  }
};
template <>
struct RefTypeTraits<JSValueRef> {
  static constexpr const bool AcquireWithRaw = true;

  static JSValueRef Duplicate(JSValueRef arg) {
    if (arg)
      JSValueProtect(GetContext(), arg);
    return arg;
  }

  static void Release(JSValueRef arg) {
    if (arg)
      JSValueUnprotect(GetContext(), arg);
  }
};
template <>
struct RefTypeTraits<JSObjectRef> : RefTypeTraits<JSValueRef> {
  static JSObjectRef Duplicate(JSObjectRef arg) {
    if (arg)
      JSValueProtect(GetContext(), arg);
    return arg;
  }
};

#endif

}  // namespace util

#if defined(USING_V8)
template <typename T>
using Handle = v8::Local<T>;
template <typename T>
using LocalVar = v8::Local<T>;
template <typename T>
using ReturnVal = v8::Local<T>;
template <typename T>
struct Global {
  Global() {}
  template <typename U = T>
  explicit Global(v8::Local<U> val) : val_(GetIsolate(), val) {}

  template <typename U = T>
  operator v8::Local<U>() const {
    return val_.Get(GetIsolate());
  }
  operator bool() const {
    return !val_.IsEmpty();
  }

  template <typename U = T>
  Global& operator=(v8::Local<U> other) {
    val_.Reset(GetIsolate(), other);
    return *this;
  }
  Global& operator=(std::nullptr_t) {
    val_.Reset();
    return *this;
  }

  template <typename U = T>
  bool operator==(v8::Local<U> other) {
    return val_ == other;
  }

 private:
  v8::Global<T> val_;
};

using JsValue = v8::Value;
using JsObject = v8::Object;
using JsString = v8::String;
using JsFunction = v8::Function;
using JsPromise = v8::Promise;
using JsMap = v8::Map;

using CallbackArguments = v8::FunctionCallbackInfo<v8::Value>;
#elif defined(USING_JSC)
template <typename T>
using Handle = util::CFRef<T>;
template <typename T>
using LocalVar = Handle<T>;
template <typename T>
using ReturnVal = Handle<T>;
template <typename T>
using Global = Handle<T>;

using JsValue = JSValueRef;
using JsObject = JSObjectRef;
using JsString = JSStringRef;
using JsFunction = JSObjectRef;
using JsPromise = JSObjectRef;
using JsMap = JSObjectRef;

class CallbackArguments {
 public:
  CallbackArguments(const JSValueRef* args, size_t count, JSObjectRef callee,
                    JSObjectRef thisv, JSValueRef* except);
  ~CallbackArguments();

  size_t length() const {
    return count_;
  }
  JSObjectRef callee() const {
    return callee_;
  }
  JSObjectRef thisv() const {
    return this_;
  }
  ReturnVal<JSValueRef> ret() const {
    return ret_;
  }

  ReturnVal<JsValue> operator[](size_t i) const;

  void SetReturn(Handle<JsValue> ret) const;
  void SetException(Handle<JsValue> except) const;

 private:
  // These need to be modifiable within const methods since in V8
  // we can modify the return value when the arguments are const.
  mutable JSValueRef* except_;
  mutable Handle<JsValue> ret_;
  const JSObjectRef callee_;
  const JSObjectRef this_;
  const JSValueRef* args_;
  const size_t count_;
};
#endif


inline size_t ArgumentCount(const CallbackArguments& arguments) {
#if defined(USING_V8)
  return arguments.Length();
#elif defined(USING_JSC)
  return arguments.length();
#endif
}

std::vector<std::string> GetMemberNames(Handle<JsObject> object);

ReturnVal<JsValue> GetMemberRaw(Handle<JsObject> object,
                                const std::string& name,
                                LocalVar<JsValue>* exception = nullptr);

ReturnVal<JsValue> GetArrayIndexRaw(Handle<JsObject> object, size_t index,
                                    LocalVar<JsValue>* exception = nullptr);

void SetMemberRaw(Handle<JsObject> object, const std::string& name,
                  Handle<JsValue> value);

void SetArrayIndexRaw(Handle<JsObject> object, size_t i, Handle<JsValue> value);

void SetGenericPropertyRaw(Handle<JsObject> object, const std::string& name,
                           Handle<JsFunction> getter,
                           Handle<JsFunction> setter);


bool InvokeConstructor(Handle<JsFunction> ctor, int argc,
                       LocalVar<JsValue>* argv,
                       LocalVar<JsValue>* result_or_except);

bool InvokeMethod(Handle<JsFunction> method, Handle<JsObject> that, int argc,
                  LocalVar<JsValue>* argv, LocalVar<JsValue>* result_or_except);


std::string ConvertToString(Handle<JsValue> value);

ReturnVal<JsValue> WrapPointer(void* ptr);

void* MaybeUnwrapPointer(Handle<JsValue> value);

BackingObject* GetInternalPointer(Handle<JsValue> value);

bool IsDerivedFrom(BackingObject* ptr, const std::string& name);

bool RunScript(const std::string& path);

bool RunScript(const std::string& path, const uint8_t* data, size_t data_size);

ReturnVal<JsValue> ParseJsonString(const std::string& json);

ReturnVal<JsString> JsStringFromUtf8(const std::string& str);

ReturnVal<JsString> JsStringFromUtf8(const uint8_t* data, size_t size);

ReturnVal<JsValue> JsUndefined();

ReturnVal<JsValue> JsNull();

ReturnVal<JsObject> CreateArray(size_t length);

ReturnVal<JsObject> CreateObject();

ReturnVal<JsMap> CreateMap();

void SetMapValue(Handle<JsMap> map, Handle<JsValue> key, Handle<JsValue> value);

bool IsNullOrUndefined(Handle<JsValue> value);

bool IsObject(Handle<JsValue> value);

bool IsBuiltInObject(Handle<JsObject> object);

proto::ValueType GetValueType(Handle<JsValue> value);



template <typename Dest>
ReturnVal<Dest> UnsafeJsCast(Handle<JsValue> source) {
#ifdef USING_V8
  return source.As<Dest>();
#else
  static_assert(std::is_same<Dest, JsValue>::value,
                "Should use other specializations");
  return source;
#endif
}

#ifdef USING_JSC
template <>
inline ReturnVal<JsObject> UnsafeJsCast<JsObject>(Handle<JsValue> source) {
  DCHECK(IsObject(source));
  return JSValueToObject(GetContext(), source, nullptr);
}
#endif



template <typename T>
ReturnVal<JsValue> RawToJsValue(Handle<T> source) {
  return source;
}

#if defined(USING_JSC)
template <>
inline ReturnVal<JsValue> RawToJsValue<JsString>(Handle<JsString> source) {
  return JSValueMakeString(GetContext(), source);
}
#endif


inline size_t ArrayLength(Handle<JsObject> value) {
#if defined(USING_V8)
  DCHECK(GetValueType(value) == proto::ValueType::Array);
  return value.As<v8::Array>()->Length();
#elif defined(USING_JSC)
  auto* ctx = GetContext();
  LocalVar<JsValue> length(GetMemberRaw(value, "length"));
  CHECK(length && JSValueIsNumber(ctx, length));
  return static_cast<size_t>(JSValueToNumber(ctx, length, nullptr));
#endif
}

double NumberFromValue(Handle<JsValue> value);

bool BooleanFromValue(Handle<JsValue> value);

}  // namespace shaka

#endif  // SHAKA_EMBEDDED_MAPPING_JS_WRAPPERS_H_