/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef BASE_TASK_H_
#define BASE_TASK_H_

#include "base/revocable_store.h"
#include "base/tuple.h"

#include "nsISupportsImpl.h"
#include "nsThreadUtils.h"

#include <type_traits>
#include <utility>

// Helper functions so that we can call a function a pass it arguments that come
// from a Tuple.

namespace details {

// Call the given method on the given object. Arguments are passed by move
// semantics from the given tuple. If the tuple has length N, the sequence must
// be IndexSequence<0, 1, ..., N-1>.
template <size_t... Indices, class ObjT, class Method, typename... Args>
void CallMethod(std::index_sequence<Indices...>, ObjT* obj, Method method,
                std::tuple<Args...>& arg) {
  (obj->*method)(std::move(std::get<Indices>(arg))...);
}

// Same as above, but call a function.
template <size_t... Indices, typename Function, typename... Args>
void CallFunction(std::index_sequence<Indices...>, Function function,
                  std::tuple<Args...>& arg) {
  (*function)(std::move(std::get<Indices>(arg))...);
}

}  // namespace details

// Call a method on the given object. Arguments are passed by move semantics
// from the given tuple.
template <class ObjT, class Method, typename... Args>
void DispatchTupleToMethod(ObjT* obj, Method method, std::tuple<Args...>& arg) {
  details::CallMethod(std::index_sequence_for<Args...>{}, obj, method, arg);
}

// Same as above, but call a function.
template <typename Function, typename... Args>
void DispatchTupleToFunction(Function function, std::tuple<Args...>& arg) {
  details::CallFunction(std::index_sequence_for<Args...>{}, function, arg);
}

// General task implementations ------------------------------------------------

// Task to delete an object
template <class T>
class DeleteTask : public mozilla::CancelableRunnable {
 public:
  explicit DeleteTask(T* obj)
      : mozilla::CancelableRunnable("DeleteTask"), obj_(obj) {}
  NS_IMETHOD Run() override {
    delete obj_;
    return NS_OK;
  }
  virtual nsresult Cancel() override {
    obj_ = NULL;
    return NS_OK;
  }

 private:
  T* MOZ_UNSAFE_REF(
      "The validity of this pointer must be enforced by "
      "external factors.") obj_;
};

// RunnableMethodTraits --------------------------------------------------------
//
// This traits-class is used by RunnableMethod to manage the lifetime of the
// callee object.  By default, it is assumed that the callee supports AddRef
// and Release methods.  A particular class can specialize this template to
// define other lifetime management.  For example, if the callee is known to
// live longer than the RunnableMethod object, then a RunnableMethodTraits
// struct could be defined with empty RetainCallee and ReleaseCallee methods.

template <class T>
struct RunnableMethodTraits {
  static void RetainCallee(T* obj) { obj->AddRef(); }
  static void ReleaseCallee(T* obj) { obj->Release(); }
};

// This allows using the NewRunnableMethod() functions with a const pointer
// to the callee object. See the similar support in nsRefPtr for a rationale
// of why this is reasonable.
template <class T>
struct RunnableMethodTraits<const T> {
  static void RetainCallee(const T* obj) { const_cast<T*>(obj)->AddRef(); }
  static void ReleaseCallee(const T* obj) { const_cast<T*>(obj)->Release(); }
};

// RunnableMethod and RunnableFunction -----------------------------------------
//
// Runnable methods are a type of task that call a function on an object when
// they are run. We implement both an object and a set of NewRunnableMethod and
// NewRunnableFunction functions for convenience. These functions are
// overloaded and will infer the template types, simplifying calling code.
//
// The template definitions all use the following names:
// T                - the class type of the object you're supplying
//                    this is not needed for the Static version of the call
// Method/Function  - the signature of a pointer to the method or function you
//                    want to call
// Param            - the parameter(s) to the method, possibly packed as a Tuple
// A                - the first parameter (if any) to the method
// B                - the second parameter (if any) to the mathod
//
// Put these all together and you get an object that can call a method whose
// signature is:
//   R T::MyFunction([A[, B]])
//
// Usage:
// PostTask(NewRunnableMethod(object, &Object::method[, a[, b]])
// PostTask(NewRunnableFunction(&function[, a[, b]])

// RunnableMethod and NewRunnableMethod implementation -------------------------

template <class T, class Method, class Params>
class RunnableMethod : public mozilla::CancelableRunnable,
                       public RunnableMethodTraits<T> {
 public:
  RunnableMethod(T* obj, Method meth, Params&& params)
      : mozilla::CancelableRunnable("RunnableMethod"),
        obj_(obj),
        meth_(meth),
        params_(std::forward<Params>(params)) {
    this->RetainCallee(obj_);
  }
  ~RunnableMethod() { ReleaseCallee(); }

  NS_IMETHOD Run() override {
    if (obj_) DispatchTupleToMethod(obj_, meth_, params_);
    return NS_OK;
  }

  virtual nsresult Cancel() override {
    ReleaseCallee();
    return NS_OK;
  }

 private:
  void ReleaseCallee() {
    if (obj_) {
      RunnableMethodTraits<T>::ReleaseCallee(obj_);
      obj_ = nullptr;
    }
  }

  // This is owning because of the RetainCallee and ReleaseCallee calls in the
  // constructor and destructor.
  T* MOZ_OWNING_REF obj_;
  Method meth_;
  Params params_;
};

namespace dont_add_new_uses_of_this {

// Don't add new uses of this!!!!
template <class T, class Method, typename... Args>
inline already_AddRefed<mozilla::Runnable> NewRunnableMethod(T* object,
                                                             Method method,
                                                             Args&&... args) {
  typedef std::tuple<std::decay_t<Args>...> ArgsTuple;
  RefPtr<mozilla::Runnable> t = new RunnableMethod<T, Method, ArgsTuple>(
      object, method, std::make_tuple(std::forward<Args>(args)...));
  return t.forget();
}

}  // namespace dont_add_new_uses_of_this

// RunnableFunction and NewRunnableFunction implementation ---------------------

template <class Function, class Params>
class RunnableFunction : public mozilla::CancelableRunnable {
 public:
  RunnableFunction(const char* name, Function function, Params&& params)
      : mozilla::CancelableRunnable(name),
        function_(function),
        params_(std::forward<Params>(params)) {}

  ~RunnableFunction() {}

  NS_IMETHOD Run() override {
    if (function_) DispatchTupleToFunction(function_, params_);
    return NS_OK;
  }

  virtual nsresult Cancel() override {
    function_ = nullptr;
    return NS_OK;
  }

  Function function_;
  Params params_;
};

template <class Function, typename... Args>
inline already_AddRefed<mozilla::CancelableRunnable>
NewCancelableRunnableFunction(const char* name, Function function,
                              Args&&... args) {
  typedef std::tuple<std::decay_t<Args>...> ArgsTuple;
  RefPtr<mozilla::CancelableRunnable> t =
      new RunnableFunction<Function, ArgsTuple>(
          name, function, std::make_tuple(std::forward<Args>(args)...));
  return t.forget();
}

template <class Function, typename... Args>
inline already_AddRefed<mozilla::Runnable> NewRunnableFunction(
    const char* name, Function function, Args&&... args) {
  typedef std::tuple<std::decay_t<Args>...> ArgsTuple;
  RefPtr<mozilla::Runnable> t = new RunnableFunction<Function, ArgsTuple>(
      name, function, std::make_tuple(std::forward<Args>(args)...));
  return t.forget();
}

#endif  // BASE_TASK_H_