sbRequestThreadQueue.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-2011 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 SBREQUESTTHREADQUEUE_H_
#define SBREQUESTTHREADQUEUE_H_

// Platform includes
#include <algorithm>
#include <deque>
#include <list>

// Mozilla includes
#include <nsAutoLock.h>
#include <nsAutoPtr.h>
#include <nsCOMPtr.h>

#include <prlock.h>

// Mozilla interfaces
#include <nsIClassInfo.h>
#include <nsIRunnable.h>
#include <nsIThread.h>
#include <nsITimer.h>

// Local includes
#include "sbRequestItem.h"

class sbRequestThreadQueue
{
public:

  NS_IMETHOD_(nsrefcnt) AddRef(void);
  NS_IMETHOD_(nsrefcnt) Release(void);

  class Batch
  {
    typedef std::list<sbRequestItem *> RequestItems;
  public:
    // types
    typedef RequestItems::const_iterator const_iterator;
    typedef RequestItems::iterator iterator;
    typedef RequestItems::size_type size_type;
    typedef RequestItems::reference reference;
    typedef RequestItems::const_reference const_reference;

    Batch();
    ~Batch();

    const_iterator begin() const
    {
      return mRequestItems.begin();
    }

    iterator begin()
    {
      return mRequestItems.begin();
    }

    const_iterator end() const
    {
      return mRequestItems.end();
    }

    iterator end()
    {
      return mRequestItems.end();
    }

    size_type size()
    {
      return mRequestItems.size();
    }
    PRUint32 CountableItems() const
    {
      return mCountableItems;
    }

    PRUint32 RequestType() const
    {
      return mRequestType;
    }

    void push_back(sbRequestItem * aItem);

    void erase(iterator aIter);

    bool empty() const
    {
      return mRequestItems.empty();
    }

    iterator insert(iterator aIter, sbRequestItem * aRequestItem)
    {
      NS_ASSERTION(aRequestItem,
                   "sbRequestThreadQueue::Batch::insert passed null");
      NS_IF_ADDREF(aRequestItem);
      return mRequestItems.insert(aIter, aRequestItem);
    }
    template <class T>
    void sort(T aComparer)
    {
      std::sort(mRequestItems.begin(), mRequestItems.end(), aComparer);
      RecalcBatchStats();
    }

    sbRequestItem * operator [](int aIndex) const
    {
      const const_iterator end = mRequestItems.end();
      const_iterator iter = mRequestItems.begin();
      while (aIndex-- > 0 && iter != end) ++iter;
      if (iter == end) {
        return nsnull;
      }
      return *iter;
    }

    void clear();
  private:
    RequestItems mRequestItems;
    PRUint32 mCountableItems;
    PRUint32 mRequestType;

    void RecalcBatchStats();
  };

  sbRequestThreadQueue();
  virtual ~sbRequestThreadQueue();

  enum {
    USER_REQUEST_TYPES = 0x20000000,

    REQUEST_TYPE_NOT_SET = 0,

    REQUEST_THREAD_START = 1,

    REQUEST_THREAD_STOP = 2
  };
  nsresult Start();

  nsresult Stop();

  nsresult BatchBegin();

  nsresult BatchEnd();

  nsresult PushRequest(sbRequestItem * aRequestItem);

  nsresult PopBatch(Batch & aBatch);

  nsresult ClearRequests();

  nsresult CancelRequests();

  bool CheckAndResetRequestAbort();

  bool IsHandlingRequests() const {
    NS_ENSURE_TRUE(mLock, false);
    nsAutoLock lock(mLock);

    return mIsHandlingRequests;
  }

  bool IsRequestAbortActive() const
  {
    nsAutoMonitor monitor(mStopWaitMonitor);
    return mAbortRequests;
  }

  PRMonitor * GetStopWaitMonitor() const
  {
    return mStopWaitMonitor;
  }

protected:
  PRLock * mLock;

  PRInt32 mBatchDepth;

  PRMonitor* mStopWaitMonitor;

protected:
  bool mAbortRequests;

  bool mIsHandlingRequests;

  nsresult ClearRequestsNoLock(Batch & aRequests);

  virtual void CompleteRequests()
  {
    nsAutoLock lock(mLock);
    NS_ASSERTION(mIsHandlingRequests,
                 "CompleteRequests called while no requests pending");
    mIsHandlingRequests = false;
    nsAutoMonitor monitor(mStopWaitMonitor);
    mAbortRequests = false;
  }

  bool mThreadStarted;

  bool mStopProcessing;
  
private:
  typedef std::deque<sbRequestItem *> RequestQueue;

  RequestQueue mRequestQueue;

  nsCOMPtr<nsIThread> mThread;

  nsCOMPtr<nsIRunnable> mReqAddedEvent;

  PRInt32 mCurrentBatchId;

  nsCOMPtr<nsIRunnable> mShutdownAction;

  nsresult FindDuplicateRequest(sbRequestItem * aItem, bool &aIsDuplicate);

  nsresult ProcessRequest();

  nsresult ThreadShutdownAction(int);

  nsAutoRefCnt mRefCnt;

  bool StartRequests()
  {
    nsAutoLock lock(mLock);
    const bool isHandlingRequests = mIsHandlingRequests;
    mIsHandlingRequests = true;
    return isHandlingRequests;
  }

  nsresult PushRequestInternal(sbRequestItem * aRequestItem);

  // Private interface derive classes must implement
  virtual nsresult OnThreadStart() { return NS_OK; };

  virtual nsresult OnThreadStop() { return NS_OK; }

  virtual nsresult IsDuplicateRequest(sbRequestItem * aItem1,
                                      sbRequestItem * aItem2,
                                      bool & aIsDuplicate,
                                      bool & aContinue)
  {
    aIsDuplicate = false;
    aContinue = true;
    return NS_OK;
  }

  virtual nsresult ProcessBatch(Batch & aBatch) = 0;

  virtual nsresult CleanupBatch(Batch & aBatch)
  {
    return NS_OK;
  }

  // Friend declarations

  friend class sbRTQAddedEvent;
  friend class sbRTQIsBatchable;

  friend class sbAutoRequestHandling;
};



#endif