js_object_wrapper.h

Go to the documentation of this file.

// Copyright 2019 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_CORE_JS_OBJECT_WRAPPER_H_
#define SHAKA_EMBEDDED_CORE_JS_OBJECT_WRAPPER_H_

#include <future>
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>

#include "shaka/async_results.h"
#include "shaka/error.h"
#include "shaka/variant.h"
#include "src/core/js_manager_impl.h"
#include "src/core/task_runner.h"
#include "src/mapping/convert_js.h"
#include "src/mapping/js_engine.h"
#include "src/mapping/js_utils.h"
#include "src/mapping/js_wrappers.h"
#include "src/mapping/promise.h"
#include "src/util/macros.h"

namespace shaka {

class JsObjectWrapper {
 public:
  JsObjectWrapper();
  ~JsObjectWrapper();

  SHAKA_NON_COPYABLE_OR_MOVABLE_TYPE(JsObjectWrapper);

  template <typename Ret, typename = void>
  struct Converter {
    using variant_type = typename AsyncResults<Ret>::variant_type;
    using future_type = std::shared_future<variant_type>;

    static variant_type Convert(const std::string& name,
                                Handle<JsValue> result) {
      Ret ret;
      if (!FromJsValue(result, &ret)) {
        return Error("Invalid return value from " + name + "().");
      }

      return ret;
    }
  };
  template <typename Dummy>
  struct Converter<void, Dummy> {
    using variant_type = AsyncResults<void>::variant_type;
    using future_type = std::shared_future<variant_type>;

    static variant_type Convert(const std::string& /* name */,
                                Handle<JsValue> /* result */) {
      return monostate();
    }
  };

  template <typename Ret, typename... Args>
  typename Converter<Ret>::future_type CallMethod(const std::string& name,
                                                  Args&&... args) const {
    return CallMethodCommon<Ret>(&object_, name, std::forward<Args>(args)...);
  }

  template <typename Ret, typename... Args>
  static typename Converter<Ret>::future_type CallGlobalMethod(
      const std::vector<std::string>& global_path, Args&&... args) {
    std::vector<std::string> obj_path{global_path.begin(),
                                      global_path.end() - 1};
    return CallMethodCommon<Ret>(std::move(obj_path), global_path.back(),
                                 std::forward<Args>(args)...);
  }

  template <typename T>
  static typename Converter<T>::future_type GetGlobalField(
      const std::vector<std::string>& global_path) {
    auto callback = std::bind(&GetFieldRaw<T>, global_path);
    return JsManagerImpl::Instance()->MainThread()->InvokeOrSchedule(
        std::move(callback));
  }

  static Error ConvertError(Handle<JsValue> except);

  void Init(Handle<JsObject> object);

 protected:
  static Converter<void>::variant_type CallMemberFunction(
      Handle<JsObject> that, const std::string& name, int argc,
      LocalVar<JsValue>* argv, LocalVar<JsValue>* result);

  Converter<void>::variant_type AttachEventListener(
      const std::string& name, std::function<void(const Error&)> on_error,
      std::function<void(Handle<JsObject> event)> handler) const;

  template <typename T>
  static typename Converter<T>::variant_type GetFieldRaw(
      const std::vector<std::string>& global_path) {
    LocalVar<JsValue> value =
        GetDescendant(JsEngine::Instance()->global_handle(), global_path);
    return Converter<T>::Convert(global_path.back(), value);
  }

  template <typename Ret, typename... Args>
  static void CallMethodRaw(
      std::shared_ptr<std::promise<typename Converter<Ret>::variant_type>> p,
      variant<const Global<JsObject>*, std::vector<std::string>> that,
      const std::string& name, Args&&... args) {
    DCHECK(JsManagerImpl::Instance()->MainThread()->BelongsToCurrentThread());
    LocalVar<JsObject> that_obj;
    if (holds_alternative<const Global<JsObject>*>(that)) {
      that_obj = *get<const Global<JsObject>*>(that);
    } else {
      LocalVar<JsValue> temp =
          GetDescendant(JsEngine::Instance()->global_handle(),
                        get<std::vector<std::string>>(that));
      if (!IsObject(temp)) {
        p->set_value(Error("Unable to find object."));
        return;
      }
      that_obj = UnsafeJsCast<JsObject>(temp);
    }

    LocalVar<JsValue> result;
    LocalVar<JsValue> js_args[] = {ToJsValue(args)..., JsUndefined()};
    auto error =
        CallMemberFunction(that_obj, name, sizeof...(args), js_args, &result);
    if (holds_alternative<Error>(error)) {
      p->set_value(get<Error>(error));
      return;
    }

    auto js_promise = Converter<Promise>::Convert(name, result);
    if (holds_alternative<Error>(js_promise)) {
      p->set_value(Converter<Ret>::Convert(name, result));
      return;
    }

    get<Promise>(js_promise)
        .Then(
            [p, name](Any res) {
              LocalVar<JsValue> value = res.ToJsValue();
              p->set_value(Converter<Ret>::Convert(name, value));
            },
            [p](Any except) {
              LocalVar<JsValue> val = except.ToJsValue();
              p->set_value(ConvertError(val));
            });
  }

  template <typename T>
  using bind_forward =
      typename std::add_const<typename std::remove_reference<T>::type>::type&;

  template <typename Ret, typename... Args>
  static typename Converter<Ret>::future_type CallMethodCommon(
      variant<const Global<JsObject>*, std::vector<std::string>> that,
      const std::string& name, Args&&... args) {
    auto promise =
        std::make_shared<std::promise<typename Converter<Ret>::variant_type>>();
    if (JsManagerImpl::Instance()->MainThread()->BelongsToCurrentThread()) {
      CallMethodRaw<Ret>(promise, std::move(that), name,
                         std::forward<Args>(args)...);
    } else {
      auto callback =
          std::bind(&CallMethodRaw<Ret, bind_forward<Args>...>, promise,
                    std::move(that), name, std::forward<Args>(args)...);
      JsManagerImpl::Instance()->MainThread()->AddInternalTask(
          TaskPriority::Internal, name, std::move(callback));
    }
    return promise->get_future().share();
  }

  Global<JsObject> object_;
};

}  // namespace shaka

#endif  // SHAKA_EMBEDDED_CORE_JS_OBJECT_WRAPPER_H_