//
// DO NOT EDIT.  THIS FILE IS GENERATED FROM ../../../dist/idl/nsIDownloadManager.idl
//


/// `interface nsIDownloadManagerResult : nsISupports`
///


// The actual type definition for the interface. This struct has methods
// declared on it which will call through its vtable. You never want to pass
// this type around by value, always pass it behind a reference.

#[repr(C)]
pub struct nsIDownloadManagerResult {
    vtable: *const nsIDownloadManagerResultVTable,

    /// This field is a phantomdata to ensure that the VTable type and any
    /// struct containing it is not safe to send across threads, as XPCOM is
    /// generally not threadsafe.
    ///
    /// XPCOM interfaces in general are not safe to send across threads.
    __nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
}

// Implementing XpCom for an interface exposes its IID, which allows for easy
// use of the `.query_interface<T>` helper method. This also defines that
// method for nsIDownloadManagerResult.
unsafe impl XpCom for nsIDownloadManagerResult {
    const IID: nsIID = nsID(0x0c07ffeb, 0x791b, 0x49f3,
        [0xae, 0x38, 0x2c, 0x33, 0x1f, 0xd5, 0x5a, 0x52]);
}

// We need to implement the RefCounted trait so we can be used with `RefPtr`.
// This trait teaches `RefPtr` how to manage our memory.
unsafe impl RefCounted for nsIDownloadManagerResult {
    #[inline]
    unsafe fn addref(&self) {
        self.AddRef();
    }
    #[inline]
    unsafe fn release(&self) {
        self.Release();
    }
}

// This trait is implemented on all types which can be coerced to from nsIDownloadManagerResult.
// It is used in the implementation of `fn coerce<T>`. We hide it from the
// documentation, because it clutters it up a lot.
#[doc(hidden)]
pub trait nsIDownloadManagerResultCoerce {
    /// Cheaply cast a value of this type from a `nsIDownloadManagerResult`.
    fn coerce_from(v: &nsIDownloadManagerResult) -> &Self;
}

// The trivial implementation: We can obviously coerce ourselves to ourselves.
impl nsIDownloadManagerResultCoerce for nsIDownloadManagerResult {
    #[inline]
    fn coerce_from(v: &nsIDownloadManagerResult) -> &Self {
        v
    }
}

impl nsIDownloadManagerResult {
    /// Cast this `nsIDownloadManagerResult` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIDownloadManagerResultCoerce>(&self) -> &T {
        T::coerce_from(self)
    }
}

// Every interface struct type implements `Deref` to its base interface. This
// causes methods on the base interfaces to be directly avaliable on the
// object. For example, you can call `.AddRef` or `.QueryInterface` directly
// on any interface which inherits from `nsISupports`.
impl ::std::ops::Deref for nsIDownloadManagerResult {
    type Target = nsISupports;
    #[inline]
    fn deref(&self) -> &nsISupports {
        unsafe {
            ::std::mem::transmute(self)
        }
    }
}

// Ensure we can use .coerce() to cast to our base types as well. Any type which
// our base interface can coerce from should be coercable from us as well.
impl<T: nsISupportsCoerce> nsIDownloadManagerResultCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIDownloadManagerResult) -> &Self {
        T::coerce_from(v)
    }
}

// This struct represents the interface's VTable. A pointer to a statically
// allocated version of this struct is at the beginning of every nsIDownloadManagerResult
// object. It contains one pointer field for each method in the interface. In
// the case where we can't generate a binding for a method, we include a void
// pointer.
#[doc(hidden)]
#[repr(C)]
pub struct nsIDownloadManagerResultVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* void handleResult (in nsresult aStatus, in nsIDownload aDownload); */
    pub HandleResult: unsafe extern "system" fn (this: *const nsIDownloadManagerResult, aStatus: nsresult, aDownload: *const nsIDownload) -> nsresult,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsIDownloadManagerResult {

    /// ```text
    /// /**
    ///    * Process an asynchronous result from getDownloadByGUID.
    ///    *
    ///    * @param aStatus The result code of the operation:
    ///    *        * NS_OK: an item was found. No other success values are returned.
    ///    *        * NS_ERROR_NOT_AVAILABLE: no such item was found.
    ///    *        * Other error values are possible, but less well-defined.
    ///    */
    /// ```
    ///

    /// `void handleResult (in nsresult aStatus, in nsIDownload aDownload);`
    #[inline]
    pub unsafe fn HandleResult(&self, aStatus: nsresult, aDownload: *const nsIDownload) -> nsresult {
        ((*self.vtable).HandleResult)(self, aStatus, aDownload)
    }


}


/// `interface nsIDownloadManager : nsISupports`
///


// The actual type definition for the interface. This struct has methods
// declared on it which will call through its vtable. You never want to pass
// this type around by value, always pass it behind a reference.

#[repr(C)]
pub struct nsIDownloadManager {
    vtable: *const nsIDownloadManagerVTable,

    /// This field is a phantomdata to ensure that the VTable type and any
    /// struct containing it is not safe to send across threads, as XPCOM is
    /// generally not threadsafe.
    ///
    /// XPCOM interfaces in general are not safe to send across threads.
    __nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
}

// Implementing XpCom for an interface exposes its IID, which allows for easy
// use of the `.query_interface<T>` helper method. This also defines that
// method for nsIDownloadManager.
unsafe impl XpCom for nsIDownloadManager {
    const IID: nsIID = nsID(0xb29aac15, 0x7ec4, 0x4ab3,
        [0xa5, 0x3b, 0x08, 0xf7, 0x8a, 0xed, 0x3b, 0x34]);
}

// We need to implement the RefCounted trait so we can be used with `RefPtr`.
// This trait teaches `RefPtr` how to manage our memory.
unsafe impl RefCounted for nsIDownloadManager {
    #[inline]
    unsafe fn addref(&self) {
        self.AddRef();
    }
    #[inline]
    unsafe fn release(&self) {
        self.Release();
    }
}

// This trait is implemented on all types which can be coerced to from nsIDownloadManager.
// It is used in the implementation of `fn coerce<T>`. We hide it from the
// documentation, because it clutters it up a lot.
#[doc(hidden)]
pub trait nsIDownloadManagerCoerce {
    /// Cheaply cast a value of this type from a `nsIDownloadManager`.
    fn coerce_from(v: &nsIDownloadManager) -> &Self;
}

// The trivial implementation: We can obviously coerce ourselves to ourselves.
impl nsIDownloadManagerCoerce for nsIDownloadManager {
    #[inline]
    fn coerce_from(v: &nsIDownloadManager) -> &Self {
        v
    }
}

impl nsIDownloadManager {
    /// Cast this `nsIDownloadManager` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIDownloadManagerCoerce>(&self) -> &T {
        T::coerce_from(self)
    }
}

// Every interface struct type implements `Deref` to its base interface. This
// causes methods on the base interfaces to be directly avaliable on the
// object. For example, you can call `.AddRef` or `.QueryInterface` directly
// on any interface which inherits from `nsISupports`.
impl ::std::ops::Deref for nsIDownloadManager {
    type Target = nsISupports;
    #[inline]
    fn deref(&self) -> &nsISupports {
        unsafe {
            ::std::mem::transmute(self)
        }
    }
}

// Ensure we can use .coerce() to cast to our base types as well. Any type which
// our base interface can coerce from should be coercable from us as well.
impl<T: nsISupportsCoerce> nsIDownloadManagerCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIDownloadManager) -> &Self {
        T::coerce_from(v)
    }
}

// This struct represents the interface's VTable. A pointer to a statically
// allocated version of this struct is at the beginning of every nsIDownloadManager
// object. It contains one pointer field for each method in the interface. In
// the case where we can't generate a binding for a method, we include a void
// pointer.
#[doc(hidden)]
#[repr(C)]
pub struct nsIDownloadManagerVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* nsIDownload addDownload (in short aDownloadType, in nsIURI aSource, in nsIURI aTarget, in AString aDisplayName, in nsIMIMEInfo aMIMEInfo, in PRTime aStartTime, in nsIFile aTempFile, in nsICancelable aCancelable, in boolean aIsPrivate); */
    pub AddDownload: unsafe extern "system" fn (this: *const nsIDownloadManager, aDownloadType: libc::int16_t, aSource: *const nsIURI, aTarget: *const nsIURI, aDisplayName: &::nsstring::nsAString, aMIMEInfo: *const nsIMIMEInfo, aStartTime: PRTime, aTempFile: *const nsIFile, aCancelable: *const nsICancelable, aIsPrivate: bool, _retval: *mut *const nsIDownload) -> nsresult,

    /* nsIDownload getDownload (in unsigned long aID); */
    pub GetDownload: unsafe extern "system" fn (this: *const nsIDownloadManager, aID: libc::uint32_t, _retval: *mut *const nsIDownload) -> nsresult,

    /* void getDownloadByGUID (in ACString aGUID, in nsIDownloadManagerResult aCallback); */
    pub GetDownloadByGUID: unsafe extern "system" fn (this: *const nsIDownloadManager, aGUID: &::nsstring::nsACString, aCallback: *const nsIDownloadManagerResult) -> nsresult,

    /* void cancelDownload (in unsigned long aID); */
    pub CancelDownload: unsafe extern "system" fn (this: *const nsIDownloadManager, aID: libc::uint32_t) -> nsresult,

    /* void removeDownload (in unsigned long aID); */
    pub RemoveDownload: unsafe extern "system" fn (this: *const nsIDownloadManager, aID: libc::uint32_t) -> nsresult,

    /* void removeDownloadsByTimeframe (in long long aBeginTime, in long long aEndTime); */
    pub RemoveDownloadsByTimeframe: unsafe extern "system" fn (this: *const nsIDownloadManager, aBeginTime: libc::int64_t, aEndTime: libc::int64_t) -> nsresult,

    /* void pauseDownload (in unsigned long aID); */
    pub PauseDownload: unsafe extern "system" fn (this: *const nsIDownloadManager, aID: libc::uint32_t) -> nsresult,

    /* void resumeDownload (in unsigned long aID); */
    pub ResumeDownload: unsafe extern "system" fn (this: *const nsIDownloadManager, aID: libc::uint32_t) -> nsresult,

    /* void retryDownload (in unsigned long aID); */
    pub RetryDownload: unsafe extern "system" fn (this: *const nsIDownloadManager, aID: libc::uint32_t) -> nsresult,

    /* readonly attribute mozIStorageConnection DBConnection; */
    pub GetDBConnection: unsafe extern "system" fn (this: *const nsIDownloadManager, aDBConnection: *mut *const mozIStorageConnection) -> nsresult,

    /* readonly attribute mozIStorageConnection privateDBConnection; */
    pub GetPrivateDBConnection: unsafe extern "system" fn (this: *const nsIDownloadManager, aPrivateDBConnection: *mut *const mozIStorageConnection) -> nsresult,

    /* readonly attribute boolean canCleanUp; */
    pub GetCanCleanUp: unsafe extern "system" fn (this: *const nsIDownloadManager, aCanCleanUp: *mut bool) -> nsresult,

    /* readonly attribute boolean canCleanUpPrivate; */
    pub GetCanCleanUpPrivate: unsafe extern "system" fn (this: *const nsIDownloadManager, aCanCleanUpPrivate: *mut bool) -> nsresult,

    /* void cleanUp (); */
    pub CleanUp: unsafe extern "system" fn (this: *const nsIDownloadManager) -> nsresult,

    /* void cleanUpPrivate (); */
    pub CleanUpPrivate: unsafe extern "system" fn (this: *const nsIDownloadManager) -> nsresult,

    /* readonly attribute long activeDownloadCount; */
    pub GetActiveDownloadCount: unsafe extern "system" fn (this: *const nsIDownloadManager, aActiveDownloadCount: *mut libc::int32_t) -> nsresult,

    /* readonly attribute long activePrivateDownloadCount; */
    pub GetActivePrivateDownloadCount: unsafe extern "system" fn (this: *const nsIDownloadManager, aActivePrivateDownloadCount: *mut libc::int32_t) -> nsresult,

    /* readonly attribute nsISimpleEnumerator activeDownloads; */
    pub GetActiveDownloads: unsafe extern "system" fn (this: *const nsIDownloadManager, aActiveDownloads: *mut *const nsISimpleEnumerator) -> nsresult,

    /* readonly attribute nsISimpleEnumerator activePrivateDownloads; */
    pub GetActivePrivateDownloads: unsafe extern "system" fn (this: *const nsIDownloadManager, aActivePrivateDownloads: *mut *const nsISimpleEnumerator) -> nsresult,

    /* void addListener (in nsIDownloadProgressListener aListener); */
    pub AddListener: unsafe extern "system" fn (this: *const nsIDownloadManager, aListener: *const nsIDownloadProgressListener) -> nsresult,

    /* void addPrivacyAwareListener (in nsIDownloadProgressListener aListener); */
    pub AddPrivacyAwareListener: unsafe extern "system" fn (this: *const nsIDownloadManager, aListener: *const nsIDownloadProgressListener) -> nsresult,

    /* void removeListener (in nsIDownloadProgressListener aListener); */
    pub RemoveListener: unsafe extern "system" fn (this: *const nsIDownloadManager, aListener: *const nsIDownloadProgressListener) -> nsresult,

    /* readonly attribute nsIFile defaultDownloadsDirectory; */
    pub GetDefaultDownloadsDirectory: unsafe extern "system" fn (this: *const nsIDownloadManager, aDefaultDownloadsDirectory: *mut *const nsIFile) -> nsresult,

    /* readonly attribute nsIFile userDownloadsDirectory; */
    pub GetUserDownloadsDirectory: unsafe extern "system" fn (this: *const nsIDownloadManager, aUserDownloadsDirectory: *mut *const nsIFile) -> nsresult,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsIDownloadManager {
    /// ```text
    /// /**
    ///    * Download type for generic file download.
    ///    */
    /// ```
    ///

    pub const DOWNLOAD_TYPE_DOWNLOAD: i64 = 0;

    /// ```text
    /// /**
    ///    * Download state for uninitialized download object.
    ///    */
    /// ```
    ///

    pub const DOWNLOAD_NOTSTARTED: i64 = -1;

    /// ```text
    /// /**
    ///    * Download is currently transferring data.
    ///    */
    /// ```
    ///

    pub const DOWNLOAD_DOWNLOADING: i64 = 0;

    /// ```text
    /// /**
    ///    * Download completed including any processing of the target
    ///    * file.  (completed)
    ///    */
    /// ```
    ///

    pub const DOWNLOAD_FINISHED: i64 = 1;

    /// ```text
    /// /**
    ///    * Transfer failed due to error. (completed)
    ///    */
    /// ```
    ///

    pub const DOWNLOAD_FAILED: i64 = 2;

    /// ```text
    /// /**
    ///    * Download was canceled by the user. (completed)
    ///    */
    /// ```
    ///

    pub const DOWNLOAD_CANCELED: i64 = 3;

    /// ```text
    /// /**
    ///    * Transfer was paused by the user.
    ///    */
    /// ```
    ///

    pub const DOWNLOAD_PAUSED: i64 = 4;

    /// ```text
    /// /**
    ///    * Download is active but data has not yet been received.
    ///    */
    /// ```
    ///

    pub const DOWNLOAD_QUEUED: i64 = 5;

    /// ```text
    /// /**
    ///    * Transfer request was blocked by parental controls proxies. (completed)
    ///    */
    /// ```
    ///

    pub const DOWNLOAD_BLOCKED_PARENTAL: i64 = 6;

    /// ```text
    /// /**
    ///    * Transferred download is being scanned by virus scanners.
    ///    */
    /// ```
    ///

    pub const DOWNLOAD_SCANNING: i64 = 7;

    /// ```text
    /// /**
    ///    * A virus was detected in the download. The target will most likely
    ///    * no longer exist. (completed)
    ///    */
    /// ```
    ///

    pub const DOWNLOAD_DIRTY: i64 = 8;

    /// ```text
    /// /**
    ///    * Win specific: Request was blocked by zone policy settings.
    ///    * (see bug #416683) (completed)
    ///    */
    /// ```
    ///

    pub const DOWNLOAD_BLOCKED_POLICY: i64 = 9;

    /// ```text
    /// /**
    ///    * Creates an nsIDownload and adds it to be managed by the download manager.
    ///    *
    ///    * @param aSource The source URI of the transfer. Must not be null.
    ///    *
    ///    * @param aTarget The target URI of the transfer. Must not be null.
    ///    *
    ///    * @param aDisplayName The user-readable description of the transfer.
    ///    *                     Can be empty.
    ///    *
    ///    * @param aMIMEInfo The MIME info associated with the target,
    ///    *                  including MIME type and helper app when appropriate.
    ///    *                  This parameter is optional.
    ///    *
    ///    * @param startTime Time when the download started
    ///    *
    ///    * @param aTempFile The location of a temporary file; i.e. a file in which
    ///    *                  the received data will be stored, but which is not
    ///    *                  equal to the target file. (will be moved to the real
        ///    *                  target by the DownloadManager, when the download is
        ///    *                  finished). This will be null for all callers except for
    ///    *                  nsExternalHelperAppHandler. Addons should generally pass
    ///    *                  null for aTempFile. This will be moved to the real target
    ///    *                  by the download manager when the download is finished,
    ///    *                  and the action indicated by aMIMEInfo will be executed.
    ///    *
    ///    * @param aCancelable An object that can be used to abort the download.
    ///    *                    Must not be null.
    ///    *
    ///    * @param aIsPrivate Used to determine the privacy status of the new download.
    ///    *                   If true, the download is stored in a manner that leaves
    ///    *                   no permanent trace outside of the current private session.
    ///    *
    ///    * @return The newly created download item with the passed-in properties.
    ///    *
    ///    * @note This does not actually start a download.  If you want to add and
    ///    *       start a download, you need to create an nsIWebBrowserPersist, pass it
    ///    *       as the aCancelable object, call this method, set the progressListener
    ///    *       as the returned download object, then call saveURI.
    ///    */
    /// ```
    ///

    /// `nsIDownload addDownload (in short aDownloadType, in nsIURI aSource, in nsIURI aTarget, in AString aDisplayName, in nsIMIMEInfo aMIMEInfo, in PRTime aStartTime, in nsIFile aTempFile, in nsICancelable aCancelable, in boolean aIsPrivate);`
    #[inline]
    pub unsafe fn AddDownload(&self, aDownloadType: libc::int16_t, aSource: *const nsIURI, aTarget: *const nsIURI, aDisplayName: &::nsstring::nsAString, aMIMEInfo: *const nsIMIMEInfo, aStartTime: PRTime, aTempFile: *const nsIFile, aCancelable: *const nsICancelable, aIsPrivate: bool, _retval: *mut *const nsIDownload) -> nsresult {
        ((*self.vtable).AddDownload)(self, aDownloadType, aSource, aTarget, aDisplayName, aMIMEInfo, aStartTime, aTempFile, aCancelable, aIsPrivate, _retval)
    }


    /// ```text
    /// /**
    ///    * Retrieves a download managed by the download manager.  This can be one that
    ///    * is in progress, or one that has completed in the past and is stored in the
    ///    * database.
    ///    *
    ///    * @param aID The unique ID of the download.
    ///    * @return The download with the specified ID.
    ///    * @throws NS_ERROR_NOT_AVAILABLE if the download is not in the database.
    ///    */
    /// ```
    ///

    /// `nsIDownload getDownload (in unsigned long aID);`
    #[inline]
    pub unsafe fn GetDownload(&self, aID: libc::uint32_t, _retval: *mut *const nsIDownload) -> nsresult {
        ((*self.vtable).GetDownload)(self, aID, _retval)
    }


    /// ```text
    /// /**
    ///    * Retrieves a download managed by the download manager.  This can be one that
    ///    * is in progress, or one that has completed in the past and is stored in the
    ///    * database.  The result of this method is returned via an asynchronous callback,
    ///    * the parameter of which will be an nsIDownload object, or null if none exists
    ///    * with the provided GUID.
    ///    *
    ///    * @param aGUID The unique GUID of the download.
    ///    * @param aCallback The callback to invoke with the result of the search.
    ///    */
    /// ```
    ///

    /// `void getDownloadByGUID (in ACString aGUID, in nsIDownloadManagerResult aCallback);`
    #[inline]
    pub unsafe fn GetDownloadByGUID(&self, aGUID: &::nsstring::nsACString, aCallback: *const nsIDownloadManagerResult) -> nsresult {
        ((*self.vtable).GetDownloadByGUID)(self, aGUID, aCallback)
    }


    /// ```text
    /// /**
    ///    * Cancels the download with the specified ID if it's currently in-progress.
    ///    * This calls cancel(NS_BINDING_ABORTED) on the nsICancelable provided by the
    ///    * download.
    ///    *
    ///    * @param aID The unique ID of the download.
    ///    * @throws NS_ERROR_FAILURE if the download is not in-progress.
    ///    */
    /// ```
    ///

    /// `void cancelDownload (in unsigned long aID);`
    #[inline]
    pub unsafe fn CancelDownload(&self, aID: libc::uint32_t) -> nsresult {
        ((*self.vtable).CancelDownload)(self, aID)
    }


    /// ```text
    /// /**
    ///    * Removes the download with the specified id if it's not currently
    ///    * in-progress.  Whereas cancelDownload simply cancels the transfer, but
    ///    * retains information about it, removeDownload removes all knowledge of it.
    ///    *
    ///    * Also notifies observers of the "download-manager-remove-download-guid"
    ///    * topic with the download guid as the subject to allow any DM consumers to
    ///    * react to the removal.
    ///    *
    ///    * Also may notify observers of the "download-manager-remove-download" topic
    ///    * with the download id as the subject, if the download removed is public
    ///    * or if global private browsing mode is in use. This notification is deprecated;
    ///    * the guid notification should be relied upon instead.
    ///    *
    ///    * @param aID The unique ID of the download.
    ///    * @throws NS_ERROR_FAILURE if the download is active.
    ///    */
    /// ```
    ///

    /// `void removeDownload (in unsigned long aID);`
    #[inline]
    pub unsafe fn RemoveDownload(&self, aID: libc::uint32_t) -> nsresult {
        ((*self.vtable).RemoveDownload)(self, aID)
    }


    /// ```text
    /// /**
    ///    * Removes all inactive downloads that were started inclusively within the
    ///    * specified time frame.
    ///    *
    ///    * @param aBeginTime
    ///    *        The start time to remove downloads by in microseconds.
    ///    * @param aEndTime
    ///    *        The end time to remove downloads by in microseconds.
    ///    */
    /// ```
    ///

    /// `void removeDownloadsByTimeframe (in long long aBeginTime, in long long aEndTime);`
    #[inline]
    pub unsafe fn RemoveDownloadsByTimeframe(&self, aBeginTime: libc::int64_t, aEndTime: libc::int64_t) -> nsresult {
        ((*self.vtable).RemoveDownloadsByTimeframe)(self, aBeginTime, aEndTime)
    }


    /// ```text
    /// /**
    ///    * Pause the specified download.
    ///    *
    ///    * @param aID The unique ID of the download.
    ///    * @throws NS_ERROR_FAILURE if the download is not in-progress.
    ///    */
    /// ```
    ///

    /// `void pauseDownload (in unsigned long aID);`
    #[inline]
    pub unsafe fn PauseDownload(&self, aID: libc::uint32_t) -> nsresult {
        ((*self.vtable).PauseDownload)(self, aID)
    }


    /// ```text
    /// /**
    ///    * Resume the specified download.
    ///    *
    ///    * @param aID The unique ID of the download.
    ///    * @throws NS_ERROR_FAILURE if the download is not in-progress.
    ///    */
    /// ```
    ///

    /// `void resumeDownload (in unsigned long aID);`
    #[inline]
    pub unsafe fn ResumeDownload(&self, aID: libc::uint32_t) -> nsresult {
        ((*self.vtable).ResumeDownload)(self, aID)
    }


    /// ```text
    /// /**
    ///    * Retries a failed download.
    ///    *
    ///    * @param aID The unique ID of the download.
    ///    * @throws NS_ERROR_NOT_AVAILALE if the download id is not known.
    ///    * @throws NS_ERROR_FAILURE if the download is not in the following states:
    ///    *           nsIDownloadManager::DOWNLOAD_CANCELED
    ///    *           nsIDownloadManager::DOWNLOAD_FAILED
    ///    */
    /// ```
    ///

    /// `void retryDownload (in unsigned long aID);`
    #[inline]
    pub unsafe fn RetryDownload(&self, aID: libc::uint32_t) -> nsresult {
        ((*self.vtable).RetryDownload)(self, aID)
    }


    /// ```text
    /// /**
    ///    * The database connection to the downloads database.
    ///    */
    /// ```
    ///

    /// `readonly attribute mozIStorageConnection DBConnection;`
    #[inline]
    pub unsafe fn GetDBConnection(&self, aDBConnection: *mut *const mozIStorageConnection) -> nsresult {
        ((*self.vtable).GetDBConnection)(self, aDBConnection)
    }



    /// `readonly attribute mozIStorageConnection privateDBConnection;`
    #[inline]
    pub unsafe fn GetPrivateDBConnection(&self, aPrivateDBConnection: *mut *const mozIStorageConnection) -> nsresult {
        ((*self.vtable).GetPrivateDBConnection)(self, aPrivateDBConnection)
    }


    /// ```text
    /// /**
    ///    * Whether or not there are downloads that can be cleaned up (removed)
    ///    * i.e. downloads that have completed, have failed or have been canceled.
    ///    * In global private browsing mode, this reports the status of the relevant
    ///    * private or public downloads. In per-window mode, it only reports for
    ///    * public ones.
    ///    */
    /// ```
    ///

    /// `readonly attribute boolean canCleanUp;`
    #[inline]
    pub unsafe fn GetCanCleanUp(&self, aCanCleanUp: *mut bool) -> nsresult {
        ((*self.vtable).GetCanCleanUp)(self, aCanCleanUp)
    }


    /// ```text
    /// /**
    ///    * Whether or not there are private downloads that can be cleaned up (removed)
    ///    * i.e. downloads that have completed, have failed or have been canceled.
    ///    */
    /// ```
    ///

    /// `readonly attribute boolean canCleanUpPrivate;`
    #[inline]
    pub unsafe fn GetCanCleanUpPrivate(&self, aCanCleanUpPrivate: *mut bool) -> nsresult {
        ((*self.vtable).GetCanCleanUpPrivate)(self, aCanCleanUpPrivate)
    }


    /// ```text
    /// /**
    ///    * Removes completed, failed, and canceled downloads from the list.
    ///    * In global private browsing mode, this operates on the relevant
    ///    * private or public downloads. In per-window mode, it only operates
    ///    * on public ones.
    ///    *
    ///    * Also notifies observers of the "download-manager-remove-download-gui"
    ///    * and "download-manager-remove-download" topics with a null subject to
    ///    * allow any DM consumers to react to the removals.
    ///    */
    /// ```
    ///

    /// `void cleanUp ();`
    #[inline]
    pub unsafe fn CleanUp(&self, ) -> nsresult {
        ((*self.vtable).CleanUp)(self, )
    }


    /// ```text
    /// /**
    ///    * Removes completed, failed, and canceled downloads from the list
    ///    * of private downloads.
    ///    *
    ///    * Also notifies observers of the "download-manager-remove-download-gui"
    ///    * and "download-manager-remove-download" topics with a null subject to
    ///    * allow any DM consumers to react to the removals.
    ///    */
    /// ```
    ///

    /// `void cleanUpPrivate ();`
    #[inline]
    pub unsafe fn CleanUpPrivate(&self, ) -> nsresult {
        ((*self.vtable).CleanUpPrivate)(self, )
    }


    /// ```text
    /// /**
    ///    * The number of files currently being downloaded.
    ///    *
    ///    * In global private browsing mode, this reports the status of the relevant
    ///    * private or public downloads. In per-window mode, it only reports public
    ///    * ones.
    ///    */
    /// ```
    ///

    /// `readonly attribute long activeDownloadCount;`
    #[inline]
    pub unsafe fn GetActiveDownloadCount(&self, aActiveDownloadCount: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetActiveDownloadCount)(self, aActiveDownloadCount)
    }


    /// ```text
    /// /**
    ///    * The number of private files currently being downloaded.
    ///    */
    /// ```
    ///

    /// `readonly attribute long activePrivateDownloadCount;`
    #[inline]
    pub unsafe fn GetActivePrivateDownloadCount(&self, aActivePrivateDownloadCount: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).GetActivePrivateDownloadCount)(self, aActivePrivateDownloadCount)
    }


    /// ```text
    /// /**
    ///    * An enumeration of active nsIDownloads
    ///    *
    ///    * In global private browsing mode, this reports the status of the relevant
    ///    * private or public downloads. In per-window mode, it only reports public
    ///    * ones.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsISimpleEnumerator activeDownloads;`
    #[inline]
    pub unsafe fn GetActiveDownloads(&self, aActiveDownloads: *mut *const nsISimpleEnumerator) -> nsresult {
        ((*self.vtable).GetActiveDownloads)(self, aActiveDownloads)
    }


    /// ```text
    /// /**
    ///    * An enumeration of active private nsIDownloads
    ///    */
    /// ```
    ///

    /// `readonly attribute nsISimpleEnumerator activePrivateDownloads;`
    #[inline]
    pub unsafe fn GetActivePrivateDownloads(&self, aActivePrivateDownloads: *mut *const nsISimpleEnumerator) -> nsresult {
        ((*self.vtable).GetActivePrivateDownloads)(self, aActivePrivateDownloads)
    }


    /// ```text
    /// /**
    ///    * Adds a listener to the download manager. It is expected that this
    ///    * listener will only access downloads via their deprecated integer id attribute,
    ///    * and when global private browsing compatibility mode is disabled, this listener
    ///    * will receive no notifications for downloads marked private.
    ///    */
    /// ```
    ///

    /// `void addListener (in nsIDownloadProgressListener aListener);`
    #[inline]
    pub unsafe fn AddListener(&self, aListener: *const nsIDownloadProgressListener) -> nsresult {
        ((*self.vtable).AddListener)(self, aListener)
    }


    /// ```text
    /// /**
    ///    * Adds a listener to the download manager. This listener must be able to
    ///    * understand and use the guid attribute of downloads for all interactions
    ///    * with the download manager.
    ///    */
    /// ```
    ///

    /// `void addPrivacyAwareListener (in nsIDownloadProgressListener aListener);`
    #[inline]
    pub unsafe fn AddPrivacyAwareListener(&self, aListener: *const nsIDownloadProgressListener) -> nsresult {
        ((*self.vtable).AddPrivacyAwareListener)(self, aListener)
    }


    /// ```text
    /// /**
    ///    * Removes a listener from the download manager.
    ///    */
    /// ```
    ///

    /// `void removeListener (in nsIDownloadProgressListener aListener);`
    #[inline]
    pub unsafe fn RemoveListener(&self, aListener: *const nsIDownloadProgressListener) -> nsresult {
        ((*self.vtable).RemoveListener)(self, aListener)
    }


    /// ```text
    /// /**
    ///    * Returns the platform default downloads directory.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIFile defaultDownloadsDirectory;`
    #[inline]
    pub unsafe fn GetDefaultDownloadsDirectory(&self, aDefaultDownloadsDirectory: *mut *const nsIFile) -> nsresult {
        ((*self.vtable).GetDefaultDownloadsDirectory)(self, aDefaultDownloadsDirectory)
    }


    /// ```text
    /// /**
    ///    * Returns the user configured downloads directory.
    ///    * The path is dependent on two user configurable prefs
    ///    * set in preferences:
    ///    *
    ///    * browser.download.folderList
    ///    *   Indicates the location users wish to save downloaded
    ///    *   files too.
    ///    *   Values:
    ///    *     0 - The desktop is the default download location.
    ///    *     1 - The system's downloads folder is the default download location.
    ///    *     2 - The default download location is elsewhere as specified in
    ///    *         browser.download.dir. If invalid, userDownloadsDirectory
    ///    *         will fallback on defaultDownloadsDirectory.
    ///    *
    ///    * browser.download.dir -
    ///    *   A local path the user may have selected at some point
    ///    *   where downloaded files are saved. The use of which is
    ///    *   enabled when folderList equals 2.
    ///    */
    /// ```
    ///

    /// `readonly attribute nsIFile userDownloadsDirectory;`
    #[inline]
    pub unsafe fn GetUserDownloadsDirectory(&self, aUserDownloadsDirectory: *mut *const nsIFile) -> nsresult {
        ((*self.vtable).GetUserDownloadsDirectory)(self, aUserDownloadsDirectory)
    }


}