DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Mercurial (d38398e5144e)

VCS Links

RunnableMethod

TaskFactory

TaskWrapper

Macros

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_plugins_TaskFactory_h
#define mozilla_plugins_TaskFactory_h

#include <base/task.h>

#include "mozilla/Move.h"

/*
 * This is based on the ScopedRunnableMethodFactory from ipc/chromium/src/base/task.h
 * Chromium's factories assert if tasks are created and run on different threads,
 * which is something we need to do in PluginModuleParent (hang UI vs. main thread).
 * TaskFactory just provides cancellable tasks that don't assert this.
 * This version also allows both ScopedMethod and regular Tasks to be generated
 * by the same Factory object.
 */

namespace mozilla {
namespace ipc {

template<class T>
class TaskFactory : public RevocableStore
{
private:
  template<class TaskType>
  class TaskWrapper : public TaskType
  {
  public:
    template<typename... Args>
    explicit TaskWrapper(RevocableStore* store, Args&&... args)
      : TaskType(mozilla::Forward<Args>(args)...)
      , revocable_(store)
    {
    }

    NS_IMETHOD Run() override {
      if (!revocable_.revoked())
        TaskType::Run();
      return NS_OK;
    }

  private:
    Revocable revocable_;
  };

public:
  explicit TaskFactory(T* object) : object_(object) { }

  template <typename TaskParamType, typename... Args>
  inline already_AddRefed<TaskParamType> NewTask(Args&&... args)
  {
    typedef TaskWrapper<TaskParamType> TaskWrapper;
    RefPtr<TaskWrapper> task =
      new TaskWrapper(this, mozilla::Forward<Args>(args)...);
    return task.forget();
  }

  template <class Method>
  inline already_AddRefed<Runnable> NewRunnableMethod(Method method) {
    typedef TaskWrapper<RunnableMethod<Method, Tuple0> > TaskWrapper;

    RefPtr<TaskWrapper> task = new TaskWrapper(this, object_, method,
                                               base::MakeTuple());

    return task.forget();
  }

  template <class Method, class A>
  inline already_AddRefed<Runnable> NewRunnableMethod(Method method, const A& a) {
    typedef TaskWrapper<RunnableMethod<Method, Tuple1<A> > > TaskWrapper;

    RefPtr<TaskWrapper> task = new TaskWrapper(this, object_, method,
                                               base::MakeTuple(a));

    return task.forget();
  }

protected:
  template <class Method, class Params>
  class RunnableMethod : public Runnable {
   public:
    RunnableMethod(T* obj, Method meth, const Params& params)
      : obj_(obj)
      , meth_(meth)
      , params_(params) {

    }

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

   private:
    T* obj_;
    Method meth_;
    Params params_;
  };

private:
  T* object_;
};

} // namespace ipc
} // namespace mozilla

#endif // mozilla_plugins_TaskFactory_h