sbThreadUtils.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set sw=2 :miv */
/*
 *=BEGIN SONGBIRD GPL
 *
 * This file is part of the Songbird web player.
 *
 * Copyright(c) 2005-2010 POTI, Inc.
 * http://www.songbirdnest.com
 *
 * This file may be licensed under the terms of of the
 * GNU General Public License Version 2 (the ``GPL'').
 *
 * Software distributed under the License is distributed
 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
 * express or implied. See the GPL for the specific language
 * governing rights and limitations.
 *
 * You should have received a copy of the GPL along with this
 * program. If not, go to http://www.gnu.org/licenses/gpl.html
 * or write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 *=END SONGBIRD GPL
 */

#ifndef __SB_THREAD_UTILS_H__
#define __SB_THREAD_UTILS_H__

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// Songbird thread utilities defs.
//
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//
// Songbird thread utilities imported services.
//
//------------------------------------------------------------------------------

// Mozilla imports.
#include <mozilla/Monitor.h>
#include <nsAutoLock.h>
#include <nsAutoPtr.h>
#include <nsIThreadPool.h>
#include <nsThreadUtils.h>

//------------------------------------------------------------------------------
//
// Songbird thread utilities classes.
//
//------------------------------------------------------------------------------

template <class ClassType, typename ReturnType, typename Arg1Type>
class sbRunnableMethod1 : public nsRunnable
{
  //----------------------------------------------------------------------------
  //
  // Public interface.
  //
  //----------------------------------------------------------------------------

public:

  //
  // SelfType                   Type for this class.
  // MethodType                 Type of method to invoke.
  //

  typedef sbRunnableMethod1<ClassType, ReturnType, Arg1Type> SelfType;
  typedef ReturnType (ClassType::*MethodType)(Arg1Type aArg1Value);


  NS_IMETHOD Run()
  {
    // Do nothing if no object was provided.
    if (!mObject)
      return NS_OK;

    // Ensure lock is available.
    NS_ENSURE_TRUE(mLock, mFailureReturnValue);

    // Invoke method.
    ReturnType returnValue = (mObject->*mMethod)(mArg1Value);
    {
      nsAutoLock autoLock(mLock);
      mReturnValue = returnValue;
    }

    return NS_OK;
  }


  static nsresult New(SelfType** aRunnable,
                      ClassType* aObject,
                      MethodType aMethod,
                      ReturnType aFailureReturnValue,
                      Arg1Type   aArg1Value)
  {
    // Validate arguments.
    NS_ENSURE_ARG_POINTER(aRunnable);
    NS_ENSURE_ARG_POINTER(aObject);
    NS_ENSURE_ARG_POINTER(aMethod);

    // Function variables.
    nsresult rv;

    // Create a Songbird runnable method.
    nsRefPtr<SelfType> runnable = new SelfType(aObject,
                                               aMethod,
                                               aFailureReturnValue,
                                               aArg1Value);
    NS_ENSURE_TRUE(runnable, aFailureReturnValue);

    // Initialize the Songbird runnable method.
    rv = runnable->Initialize();
    NS_ENSURE_SUCCESS(rv, rv);

    // Return results.
    runnable.forget(aRunnable);

    return NS_OK;
  }


  static ReturnType InvokeOnMainThread(ClassType* aObject,
                                       MethodType aMethod,
                                       ReturnType aFailureReturnValue,
                                       Arg1Type   aArg1Value)
  {
    nsresult rv;

    // Create a Songbird runnable method.
    nsRefPtr<SelfType> runnable;
    rv = New(getter_AddRefs(runnable),
             aObject,
             aMethod,
             aFailureReturnValue,
             aArg1Value);
    NS_ENSURE_SUCCESS(rv, aFailureReturnValue);

    // Dispatch the runnable method on the main thread.
    rv = NS_DispatchToMainThread(runnable, NS_DISPATCH_SYNC);
    NS_ENSURE_SUCCESS(rv, rv);

    return runnable->GetReturnValue();
  }

  static ReturnType InvokeOnThread(ClassType* aObject,
                                   MethodType aMethod,
                                   ReturnType aFailureReturnValue,
                                   Arg1Type   aArg1Value,
                                   nsIEventTarget* aThread)
  {
    nsresult rv;

    // Create a Songbird runnable method.
    nsRefPtr<SelfType> runnable;
    rv = New(getter_AddRefs(runnable),
             aObject,
             aMethod,
             aFailureReturnValue,
             aArg1Value);
    NS_ENSURE_SUCCESS(rv, aFailureReturnValue);

    // Dispatch the runnable method on the thread.
    rv = aThread->Dispatch(runnable, NS_DISPATCH_SYNC);
    NS_ENSURE_SUCCESS(rv, aFailureReturnValue);

    return runnable->GetReturnValue();
  }


  static nsresult InvokeOnMainThreadAsync(ClassType* aObject,
                                          MethodType aMethod,
                                          ReturnType aFailureReturnValue,
                                          Arg1Type   aArg1Value)
  {
    nsresult rv;

    // Create a Songbird runnable method.
    nsRefPtr<SelfType> runnable;
    rv = New(getter_AddRefs(runnable),
             aObject,
             aMethod,
             aFailureReturnValue,
             aArg1Value);
    NS_ENSURE_SUCCESS(rv, aFailureReturnValue);

    // Dispatch the runnable method on the main thread.
    rv = NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL);
    NS_ENSURE_SUCCESS(rv, rv);

    return NS_OK;
  }

  static nsresult InvokeOnThreadAsync(ClassType* aObject,
                                      MethodType aMethod,
                                      ReturnType aFailureReturnValue,
                                      Arg1Type   aArg1Value,
                                      nsIEventTarget* aThread)
  {
    nsresult rv;

    // Create a Songbird runnable method.
    nsRefPtr<SelfType> runnable;
    rv = New(getter_AddRefs(runnable),
             aObject,
             aMethod,
             aFailureReturnValue,
             aArg1Value);
    NS_ENSURE_SUCCESS(rv, aFailureReturnValue);

    // Dispatch the runnable method on the thread.
    rv = aThread->Dispatch(runnable, NS_DISPATCH_NORMAL);
    NS_ENSURE_SUCCESS(rv, aFailureReturnValue);

    return NS_OK;
  }

  ReturnType GetReturnValue()
  {
    NS_ENSURE_TRUE(mLock, mFailureReturnValue);
    nsAutoLock autoLock(mLock);
    return mReturnValue;
  }


  //----------------------------------------------------------------------------
  //
  // Protected interface.
  //
  //----------------------------------------------------------------------------

protected:

  sbRunnableMethod1(ClassType* aObject,
                    MethodType aMethod,
                    ReturnType aFailureReturnValue,
                    Arg1Type   aArg1Value) :
    mLock(nsnull),
    mObject(aObject),
    mMethod(aMethod),
    mReturnValue(aFailureReturnValue),
    mFailureReturnValue(aFailureReturnValue),
    mArg1Value(aArg1Value)
  {
  }


  virtual ~sbRunnableMethod1()
  {
    // Dispose of the Songbird runnable method lock.
    if (mLock)
      nsAutoLock::DestroyLock(mLock);
  }


  nsresult Initialize()
  {
    // Create the runnable lock.
    mLock = nsAutoLock::NewLock("sbRunnableMethod1::mLock");
    NS_ENSURE_TRUE(mLock, NS_ERROR_OUT_OF_MEMORY);

    return NS_OK;
  }


  //
  // mLock                      Lock used to serialize field access.
  // mObject                    Object for which to invoke method.
  // mMethod                    Method to invoke.
  // mReturnValue               Method return value.
  // mFailureReturnValue        Method return value to use on failure.
  // mArg1Value                 Method argument 1 value.
  //

  PRLock*             mLock;
  nsRefPtr<ClassType> mObject;
  MethodType          mMethod;
  ReturnType          mReturnValue;
  ReturnType          mFailureReturnValue;
  Arg1Type            mArg1Value;
};


template <class ClassType,
          typename ReturnType,
          typename Arg1Type,
          typename Arg2Type>
class sbRunnableMethod2 :
        public sbRunnableMethod1<ClassType, ReturnType, Arg1Type>
{
  //----------------------------------------------------------------------------
  //
  // Public interface.
  //
  //----------------------------------------------------------------------------

public:

  //
  // SelfType                   Type for this class.
  // BaseType                   Base type for this class.
  // MethodType                 Type of method to invoke.
  //

  typedef sbRunnableMethod2<ClassType, ReturnType, Arg1Type, Arg2Type> SelfType;
  typedef sbRunnableMethod1<ClassType, ReturnType, Arg1Type> BaseType;
  typedef ReturnType (ClassType::*MethodType)(Arg1Type aArg1Value,
                                              Arg2Type aArg2Value);


  NS_IMETHOD Run()
  {
    // Do nothing if no object was provided.
    if (!BaseType::mObject)
      return NS_OK;

    // Invoke method.
    ReturnType
      returnValue = (BaseType::mObject->*mMethod)(BaseType::mArg1Value,
                                                  mArg2Value);
    {
      nsAutoLock autoLock(BaseType::mLock);
      BaseType::mReturnValue = returnValue;
    }

    return NS_OK;
  }


  static nsresult New(SelfType** aRunnable,
                      ClassType* aObject,
                      MethodType aMethod,
                      ReturnType aFailureReturnValue,
                      Arg1Type   aArg1Value,
                      Arg2Type   aArg2Value)
  {
    // Validate arguments.
    NS_ENSURE_ARG_POINTER(aRunnable);
    NS_ENSURE_ARG_POINTER(aObject);
    NS_ENSURE_ARG_POINTER(aMethod);

    // Function variables.
    nsresult rv;

    // Create a Songbird runnable method.
    nsRefPtr<SelfType> runnable = new SelfType(aObject,
                                               aMethod,
                                               aFailureReturnValue,
                                               aArg1Value,
                                               aArg2Value);
    NS_ENSURE_TRUE(runnable, aFailureReturnValue);

    // Initialize the Songbird runnable method.
    rv = runnable->Initialize();
    NS_ENSURE_SUCCESS(rv, rv);

    // Return results.
    runnable.forget(aRunnable);

    return NS_OK;
  }


  static ReturnType InvokeOnMainThread(ClassType* aObject,
                                       MethodType aMethod,
                                       ReturnType aFailureReturnValue,
                                       Arg1Type   aArg1Value,
                                       Arg2Type   aArg2Value)
  {
    nsresult rv;

    // Create a Songbird runnable method.
    nsRefPtr<SelfType> runnable;
    rv = New(getter_AddRefs(runnable),
             aObject,
             aMethod,
             aFailureReturnValue,
             aArg1Value,
             aArg2Value);
    NS_ENSURE_SUCCESS(rv, aFailureReturnValue);

    // Dispatch the runnable method on the main thread.
    rv = NS_DispatchToMainThread(runnable, NS_DISPATCH_SYNC);
    NS_ENSURE_SUCCESS(rv, rv);

    return runnable->GetReturnValue();
  }

  static ReturnType InvokeOnThread(ClassType* aObject,
                                   MethodType aMethod,
                                   ReturnType aFailureReturnValue,
                                   Arg1Type   aArg1Value,
                                   Arg2Type   aArg2Value,
                                   nsIEventTarget* aThread)
  {
    nsresult rv;

    // Create a Songbird runnable method.
    nsRefPtr<SelfType> runnable;
    rv = New(getter_AddRefs(runnable),
             aObject,
             aMethod,
             aFailureReturnValue,
             aArg1Value,
             aArg2Value);
    NS_ENSURE_SUCCESS(rv, aFailureReturnValue);

    // Dispatch the runnable method on the main thread.
    rv = aThread->Dispatch(runnable, NS_DISPATCH_SYNC);
    NS_ENSURE_SUCCESS(rv, aFailureReturnValue);

    return runnable->GetReturnValue();
  }

  static nsresult InvokeOnMainThreadAsync(ClassType* aObject,
                                          MethodType aMethod,
                                          ReturnType aFailureReturnValue,
                                          Arg1Type   aArg1Value,
                                          Arg2Type   aArg2Value)
  {
    nsresult rv;

    // Create a Songbird runnable method.
    nsRefPtr<SelfType> runnable;
    rv = New(getter_AddRefs(runnable),
             aObject,
             aMethod,
             aFailureReturnValue,
             aArg1Value,
             aArg2Value);
    NS_ENSURE_SUCCESS(rv, aFailureReturnValue);

    // Dispatch the runnable method on the main thread.
    rv = NS_DispatchToMainThread(runnable, NS_DISPATCH_NORMAL);
    NS_ENSURE_SUCCESS(rv, rv);

    return NS_OK;
  }

  static nsresult InvokeOnThreadAsync(ClassType* aObject,
                                      MethodType aMethod,
                                      ReturnType aFailureReturnValue,
                                      Arg1Type   aArg1Value,
                                      Arg2Type   aArg2Value,
                                      nsIEventTarget* aThread)
  {
    nsresult rv;

    // Create a Songbird runnable method.
    nsRefPtr<SelfType> runnable;
    rv = New(getter_AddRefs(runnable),
             aObject,
             aMethod,
             aFailureReturnValue,
             aArg1Value,
             aArg2Value);
    NS_ENSURE_SUCCESS(rv, aFailureReturnValue);

    // Dispatch the runnable method on the main thread.
    rv = aThread->Dispatch(runnable, NS_DISPATCH_NORMAL);
    NS_ENSURE_SUCCESS(rv, aFailureReturnValue);

    return NS_OK;
  }

  //----------------------------------------------------------------------------
  //
  // Protected interface.
  //
  //----------------------------------------------------------------------------

protected:

  sbRunnableMethod2(ClassType* aObject,
                    MethodType aMethod,
                    ReturnType aFailureReturnValue,
                    Arg1Type   aArg1Value,
                    Arg2Type   aArg2Value) :
    BaseType(aObject, nsnull, aFailureReturnValue, aArg1Value),
    mMethod(aMethod),
    mArg2Value(aArg2Value)
  {
  }


  virtual ~sbRunnableMethod2()
  {
  }


  //
  // mMethod                    Method to invoke.
  // mArg2Value                 Method argument 2 value.
  //

  MethodType mMethod;
  Arg2Type   mArg2Value;
};



class sbRunnable : public nsRunnable
{
public:
  sbRunnable(
    const char *  aName) :
    mMonitor(aName ? aName : "sbRunnable"),
    mDone(false)
    {}


  NS_IMETHOD Run();

  PRBool Wait(PRIntervalTime aTimeout);

private:
  mozilla::Monitor  mMonitor;
  PRBool            mDone;
};



template <typename ResultType>
class sbRunnable_ : public sbRunnable
{
public:
  using sbRunnable::Wait;

public:
  sbRunnable_(
    const char *  aName) :
    sbRunnable(aName)
    {}


  NS_IMETHOD Run()
  {
    // Invoke method.
    mResult = OnRun();
    return sbRunnable::Run();
  }


  ResultType
  Wait()
  {
    Wait(PR_INTERVAL_NO_TIMEOUT);
    return mResult;
  }


  PRBool
  Wait(PRIntervalTime aTimeout, ResultType & aResult)
  {
    if (!Wait(aTimeout)) {
      return PR_FALSE;
    }

    aResult = mResult;
    return PR_TRUE;
  }


protected:
  virtual ResultType OnRun() = 0;

private:
  ResultType  mResult;
};



template <>
class sbRunnable_<void> : public sbRunnable
{
public:
  sbRunnable_(
    const char *  aName) :
    sbRunnable(aName)
    {}


  NS_IMETHOD Run()
  {
    // Invoke method.
    OnRun();
    return sbRunnable::Run();
  }


protected:
  virtual void OnRun() = 0;
};



template <typename ResultType,
          typename TargetType,
          typename MethodType>
class sbRunnableMethod_ : public sbRunnable_<ResultType>
{
public:
  sbRunnableMethod_(
    TargetType &  aTarget,
    MethodType    aMethod,
    const char *  aName) :
    sbRunnable_<ResultType>(aName),
    mTarget(&aTarget),
    mMethod(aMethod)
    {}


protected:
  virtual ResultType OnRun() = 0;

  nsRefPtr<TargetType>  mTarget;
  MethodType            mMethod;
};



template <typename ResultType,
          typename TargetType,
          typename Param1Type,
          typename Arg1Type = Param1Type,
          typename MethodType = ResultType (TargetType::*) (Param1Type)>
class sbRunnableMethod1_ :
  public sbRunnableMethod_<ResultType, TargetType, MethodType>
{
public:
  typedef sbRunnableMethod_<ResultType, TargetType, MethodType> BaseType;


  sbRunnableMethod1_(
    TargetType &  aTarget,
    MethodType    aMethod,
    Param1Type    aArg1,
    const char *  aName = NULL) :
    BaseType(aTarget, aMethod, aName),
    mArg1(aArg1)
    {}


protected:
  virtual ResultType OnRun()
  {
    return (BaseType::mTarget->*BaseType::mMethod)(mArg1);
  }


private:
  Arg1Type  mArg1;
};



template <typename ResultType,
          typename TargetType,
          typename Param1Type,
          typename Param2Type,
          typename Arg1Type = Param1Type,
          typename Arg2Type = Param2Type,
          typename MethodType = ResultType (TargetType::*) (Param1Type,
                                                            Param2Type)>
class sbRunnableMethod2_ :
  public sbRunnableMethod_<ResultType, TargetType, MethodType>
{
public:
  typedef sbRunnableMethod_<ResultType, TargetType, MethodType> BaseType;


  sbRunnableMethod2_(
    TargetType &  aTarget,
    MethodType    aMethod,
    Param1Type    aArg1,
    Param2Type    aArg2,
    const char *  aName = NULL) :
    BaseType(aTarget, aMethod, aName),
    mArg1(aArg1),
    mArg2(aArg2)
    {}


protected:
  virtual ResultType OnRun()
  {
    return (BaseType::mTarget->*BaseType::mMethod)(mArg1, mArg2);
  }


private:
  Arg1Type  mArg1;
  Arg2Type  mArg2;
};



template <typename ResultType,
          typename TargetType,
          typename Param1Type,
          typename Param2Type,
          typename Param3Type,
          typename Arg1Type = Param1Type,
          typename Arg2Type = Param2Type,
          typename Arg3Type = Param3Type,
          typename MethodType = ResultType (TargetType::*) (Param1Type,
                                                            Param2Type,
                                                            Param3Type)>
class sbRunnableMethod3_ :
  public sbRunnableMethod_<ResultType, TargetType, MethodType>
{
public:
  typedef sbRunnableMethod_<ResultType, TargetType, MethodType> BaseType;


  sbRunnableMethod3_(
    TargetType &  aTarget,
    MethodType    aMethod,
    Param1Type    aArg1,
    Param2Type    aArg2,
    Param3Type    aArg3,
    const char *  aName = NULL) :
    BaseType(aTarget, aMethod, aName),
    mArg1(aArg1),
    mArg2(aArg2),
    mArg3(aArg3)
    {}


protected:
  virtual ResultType OnRun()
  {
    return (BaseType::mTarget->*BaseType::mMethod)(mArg1, mArg2, mArg3);
  }


private:
  Arg1Type  mArg1;
  Arg2Type  mArg2;
  Arg3Type  mArg3;
};



template <typename ResultType,
          typename TargetType,
          typename Param1Type,
          typename Param2Type,
          typename Param3Type,
          typename Param4Type,
          typename Arg1Type = Param1Type,
          typename Arg2Type = Param2Type,
          typename Arg3Type = Param3Type,
          typename Arg4Type = Param4Type,
          typename MethodType = ResultType (TargetType::*) (Param1Type,
                                                            Param2Type,
                                                            Param3Type,
                                                            Param4Type)>
class sbRunnableMethod4_ :
  public sbRunnableMethod_<ResultType, TargetType, MethodType>
{
public:
  typedef sbRunnableMethod_<ResultType, TargetType, MethodType> BaseType;


  sbRunnableMethod4_(
    TargetType &  aTarget,
    MethodType    aMethod,
    Param1Type    aArg1,
    Param2Type    aArg2,
    Param3Type    aArg3,
    Param4Type    aArg4,
    const char *  aName = NULL) :
    BaseType(aTarget, aMethod, aName),
    mArg1(aArg1),
    mArg2(aArg2),
    mArg3(aArg3),
    mArg4(aArg4)
    {}


protected:
  virtual ResultType OnRun()
  {
    return (BaseType::mTarget->*BaseType::mMethod)(mArg1, mArg2, mArg3, mArg4);
  }


private:
  Arg1Type  mArg1;
  Arg2Type  mArg2;
  Arg3Type  mArg3;
  Arg4Type  mArg4;
};



template <typename ResultType,
          typename TargetType,
          typename Param1Type,
          typename Param2Type,
          typename Param3Type,
          typename Param4Type,
          typename Param5Type,
          typename Arg1Type = Param1Type,
          typename Arg2Type = Param2Type,
          typename Arg3Type = Param3Type,
          typename Arg4Type = Param4Type,
          typename Arg5Type = Param5Type,
          typename MethodType = ResultType (TargetType::*) (Param1Type,
                                                            Param2Type,
                                                            Param3Type,
                                                            Param4Type,
                                                            Param5Type)>
class sbRunnableMethod5_ :
  public sbRunnableMethod_<ResultType, TargetType, MethodType>
{
public:
  typedef sbRunnableMethod_<ResultType, TargetType, MethodType> BaseType;


  sbRunnableMethod5_(
    TargetType &  aTarget,
    MethodType    aMethod,
    Param1Type    aArg1,
    Param2Type    aArg2,
    Param3Type    aArg3,
    Param4Type    aArg4,
    Param5Type    aArg5,
    const char *  aName = NULL) :
    BaseType(aTarget, aMethod, aName),
    mArg1(aArg1),
    mArg2(aArg2),
    mArg3(aArg3),
    mArg4(aArg4),
    mArg5(aArg5)
    {}


protected:
  virtual ResultType OnRun()
  {
    return (BaseType::mTarget->*BaseType::mMethod)(mArg1, mArg2, mArg3, mArg4, mArg5);
  }


private:
  Arg1Type  mArg1;
  Arg2Type  mArg2;
  Arg3Type  mArg3;
  Arg4Type  mArg4;
  Arg5Type  mArg5;
};



//------------------------------------------------------------------------------
//
// Songbird thread utilities macros.
//
//------------------------------------------------------------------------------

#define SB_INVOKE_ON_MAIN_THREAD1(aClassType,                                  \
                                  aObject,                                     \
                                  aMethod,                                     \
                                  aReturnType,                                 \
                                  aFailureReturnValue,                         \
                                  aArg1Type,                                   \
                                  aArg1Value)                                  \
  sbRunnableMethod1<aClassType, aReturnType, aArg1Type>                        \
    ::InvokeOnMainThread(aObject,                                              \
                         &aClassType::aMethod,                                 \
                         aFailureReturnValue,                                  \
                         aArg1Value)

template <class T, class MT, class RT, class A1>
inline
RT sbInvokeOnMainThread1(T & aObject,
                         MT aMethod,
                         RT aFailureReturnValue,
                         A1 aArg1)
{
  return sbRunnableMethod1<T, RT, A1>::InvokeOnMainThread(&aObject,
                                                          aMethod,
                                                          aFailureReturnValue,
                                                          aArg1);
}

template <class T, class MT, class RT, class A1, class TH>
inline
RT sbInvokeOnThread1(T & aObject,
                     MT aMethod,
                     RT aFailureReturnValue,
                     A1 aArg1,
                     TH aThread)
{
  return sbRunnableMethod1<T, RT, A1>::InvokeOnThread(&aObject,
                                                      aMethod,
                                                      aFailureReturnValue,
                                                      aArg1,
                                                      aThread);
}

template <class T, class MT, class RT, class A1>
inline
nsresult sbInvokeOnMainThread1Async(T & aObject,
                                    MT aMethod,
                                    RT aFailureReturnValue,
                                    A1 aArg1)
{
  return sbRunnableMethod1<T, RT, A1>::InvokeOnMainThreadAsync(
                                                            &aObject,
                                                            aMethod,
                                                            aFailureReturnValue,
                                                            aArg1);
}

template <class T, class MT, class RT, class A1, class TH>
inline
nsresult sbInvokeOnThread1Async(T & aObject,
                                MT aMethod,
                                RT aFailureReturnValue,
                                A1 aArg1,
                                TH aThread)
{
  return sbRunnableMethod1<T, RT, A1>::InvokeOnThreadAsync(&aObject,
                                                           aMethod,
                                                           aFailureReturnValue,
                                                           aArg1,
                                                           aThread);
}

#define SB_INVOKE_ON_MAIN_THREAD2(aClassType,                                  \
                                  aObject,                                     \
                                  aMethod,                                     \
                                  aReturnType,                                 \
                                  aFailureReturnValue,                         \
                                  aArg1Type,                                   \
                                  aArg1Value,                                  \
                                  aArg2Type,                                   \
                                  aArg2Value)                                  \
  sbRunnableMethod2<aClassType, aReturnType, aArg1Type, aArg2Type>             \
    ::InvokeOnMainThread(aObject,                                              \
                         &aClassType::aMethod,                                 \
                         aFailureReturnValue,                                  \
                         aArg1Value,                                           \
                         aArg2Value)

template <class T, class MT, class RT, class A1, class A2>
inline
RT sbInvokeOnMainThread2(T & aObject,
                         MT aMethod,
                         RT aFailureReturnValue,
                         A1 aArg1,
                         A2 aArg2)
{
  return sbRunnableMethod2<T, RT, A1, A2>::InvokeOnMainThread(
                                                            &aObject,
                                                            aMethod,
                                                            aFailureReturnValue,
                                                            aArg1,
                                                            aArg2);
}

template <class T, class MT, class RT, class A1, class A2, class TH>
inline
RT sbInvokeOnThread2(T & aObject,
                     MT aMethod,
                     RT aFailureReturnValue,
                     A1 aArg1,
                     A2 aArg2,
                     TH aThread)
{
  return sbRunnableMethod2<T, RT, A1, A2>::InvokeOnThread(&aObject,
                                                          aMethod,
                                                          aFailureReturnValue,
                                                          aArg1,
                                                          aArg2,
                                                          aThread);
}

template <class T, class MT, class RT, class A1, class A2>
inline
nsresult sbInvokeOnMainThread2Async(T & aObject,
                                    MT aMethod,
                                    RT aFailureReturnValue,
                                    A1 aArg1,
                                    A2 aArg2)
{
  return sbRunnableMethod2<T, RT, A1, A2>::InvokeOnMainThreadAsync(
                                                            &aObject,
                                                            aMethod,
                                                            aFailureReturnValue,
                                                            aArg1,
                                                            aArg2);
}

template <class T, class MT, class RT, class A1, class A2, class TH>
inline
nsresult sbInvokeOnThread2Async(T & aObject,
                                MT aMethod,
                                RT aFailureReturnValue,
                                A1 aArg1,
                                A2 aArg2,
                                TH aThread)
{
  return sbRunnableMethod2<T, RT, A1, A2>::InvokeOnThreadAsync(
                                                            &aObject,
                                                            aMethod,
                                                            aFailureReturnValue,
                                                            aArg1,
                                                            aArg2,
                                                            aThread);
}

#define SB_INVOKE_ON_MAIN_THREAD_ASYNC1(aClassType,                            \
                                        aObject,                               \
                                        aMethod,                               \
                                        aReturnType,                           \
                                        aFailureReturnValue,                   \
                                        aArg1Type,                             \
                                        aArg1Value)                            \
  sbRunnableMethod1<aClassType, aReturnType, aArg1Type>                        \
    ::InvokeOnMainThreadAsync(aObject,                                         \
                              &aClassType::aMethod,                            \
                              aFailureReturnValue,                             \
                              aArg1Value)

#define SB_INVOKE_ON_MAIN_THREAD_ASYNC2(aClassType,                            \
                                        aObject,                               \
                                        aMethod,                               \
                                        aReturnType,                           \
                                        aFailureReturnValue,                   \
                                        aArg1Type,                             \
                                        aArg1Value,                            \
                                        aArg2Type,                             \
                                        aArg2Value)                            \
  sbRunnableMethod2<aClassType, aReturnType, aArg1Type, aArg2Type>             \
    ::InvokeOnMainThreadAsync(aObject,                                         \
                              &aClassType::aMethod,                            \
                              aFailureReturnValue,                             \
                              aArg1Value,                                      \
                              aArg2Value)


//------------------------------------------------------------------------------
//
// Songbird thread utilities service prototypes.
//
//------------------------------------------------------------------------------

PRBool SB_IsMainThread(nsIThreadManager* aThreadManager = nsnull);


#endif // __SB_THREAD_UTILS_H__