event_target.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_JS_EVENTS_EVENT_TARGET_H_
#define SHAKA_EMBEDDED_JS_EVENTS_EVENT_TARGET_H_

#include <list>
#include <memory>
#include <string>
#include <unordered_map>
#include <utility>

#include "shaka/optional.h"
#include "src/core/js_manager_impl.h"
#include "src/core/member.h"
#include "src/core/ref_ptr.h"
#include "src/debug/thread_event.h"
#include "src/js/events/event.h"
#include "src/js/events/event_names.h"
#include "src/mapping/backing_object.h"
#include "src/mapping/backing_object_factory.h"
#include "src/mapping/callback.h"
#include "src/mapping/exception_or.h"

namespace shaka {
namespace js {
namespace events {

class EventTarget : public BackingObject {
  DECLARE_TYPE_INFO(EventTarget);

 public:
  EventTarget();

  using Listener = optional<Callback>;

  void Trace(memory::HeapTracer* tracer) const override;

  void AddEventListener(const std::string& type, Listener callback);

  void SetCppEventListener(EventType type, std::function<void()> callback);

  void RemoveEventListener(const std::string& type, Listener callback);

  void UnsetCppEventListener(EventType type);

  ExceptionOr<bool> DispatchEvent(RefPtr<Event> event) {
    return DispatchEventInternal(event, nullptr);
  }

  ExceptionOr<bool> DispatchEventInternal(RefPtr<Event> event,
                                          bool* did_listeners_throw);

  template <typename EventType, typename... Args>
  std::shared_ptr<ThreadEvent<bool>> ScheduleEvent(Args&&... args) {
    RefPtr<EventType> event = new EventType(std::forward<Args>(args)...);
    RefPtr<EventTarget> target(this);
    return JsManagerImpl::Instance()->MainThread()->AddInternalTask(
        TaskPriority::Events, std::string("Schedule ") + EventType::name(),
        [=]() {
          ExceptionOr<bool> val = target->DispatchEvent(event);
          if (holds_alternative<bool>(val)) {
            return get<bool>(val);
          } else {
            LocalVar<JsValue> except = get<js::JsError>(val).error();
            LOG(INFO) << "Exception thrown while raising event: "
                      << ConvertToString(except);
            return false;
          }
        });
  }

  template <typename EventType, typename... Args>
  ExceptionOr<bool> RaiseEvent(Args... args) {
    RefPtr<EventType> backing = new EventType(args...);
    return this->DispatchEvent(backing);
  }

 protected:
  void AddListenerField(EventType type, Listener* on_field) {
    on_listeners_[to_string(type)] = on_field;
  }

 private:
  struct ListenerInfo {
    ListenerInfo(Listener listener, const std::string& type);
    ~ListenerInfo();

    Listener callback_;
    std::string type_;
    bool should_remove_;
  };

  void InvokeListeners(RefPtr<Event> event, bool* did_listeners_throw);

  std::list<ListenerInfo>::iterator FindListener(const Listener& callback,
                                                 const std::string& type);

  std::unordered_map<std::string, std::function<void()>> cpp_listeners_;

  // Elements are stored in insert order. Use a list since we store an iterator
  // while invoking and it needs to remain valid with concurrent inserts.  This
  // will also have faster removals since we only use iterators.
  std::list<ListenerInfo> listeners_;
  // A map of the on-event listeners (e.g. onerror).
  std::unordered_map<std::string, Listener*> on_listeners_;
  bool is_dispatching_;
};

class EventTargetFactory : public BackingObjectFactory<EventTarget> {
 public:
  EventTargetFactory();
};

}  // namespace events
}  // namespace js
}  // namespace shaka

#endif  // SHAKA_EMBEDDED_JS_EVENTS_EVENT_TARGET_H_