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


/// `interface mozIAsyncFavicons : 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 mozIAsyncFavicons {
    vtable: *const mozIAsyncFaviconsVTable,

    /// 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 mozIAsyncFavicons.
unsafe impl XpCom for mozIAsyncFavicons {
    const IID: nsIID = nsID(0xa9c81797, 0x9133, 0x4823,
        [0xb5, 0x5f, 0x36, 0x46, 0xe6, 0x7c, 0xfd, 0x41]);
}

// 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 mozIAsyncFavicons {
    #[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 mozIAsyncFavicons.
// 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 mozIAsyncFaviconsCoerce {
    /// Cheaply cast a value of this type from a `mozIAsyncFavicons`.
    fn coerce_from(v: &mozIAsyncFavicons) -> &Self;
}

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

impl mozIAsyncFavicons {
    /// Cast this `mozIAsyncFavicons` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: mozIAsyncFaviconsCoerce>(&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 mozIAsyncFavicons {
    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> mozIAsyncFaviconsCoerce for T {
    #[inline]
    fn coerce_from(v: &mozIAsyncFavicons) -> &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 mozIAsyncFavicons
// 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 mozIAsyncFaviconsVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* mozIPlacesPendingOperation setAndFetchFaviconForPage (in nsIURI aPageURI, in nsIURI aFaviconURI, in boolean aForceReload, in unsigned long aFaviconLoadType, [optional] in nsIFaviconDataCallback aCallback, [optional] in nsIPrincipal aLoadingPrincipal, [optional] in unsigned long long aRequestContextID); */
    pub SetAndFetchFaviconForPage: unsafe extern "system" fn (this: *const mozIAsyncFavicons, aPageURI: *const nsIURI, aFaviconURI: *const nsIURI, aForceReload: bool, aFaviconLoadType: libc::uint32_t, aCallback: *const nsIFaviconDataCallback, aLoadingPrincipal: *const nsIPrincipal, aRequestContextID: libc::uint64_t, _retval: *mut *const mozIPlacesPendingOperation) -> nsresult,

    /* void replaceFaviconData (in nsIURI aFaviconURI, [array, size_is (aDataLen), const] in octet aData, in unsigned long aDataLen, in AUTF8String aMimeType, [optional] in PRTime aExpiration); */
    pub ReplaceFaviconData: unsafe extern "system" fn (this: *const mozIAsyncFavicons, aFaviconURI: *const nsIURI, aData: *const libc::uint8_t, aDataLen: libc::uint32_t, aMimeType: &::nsstring::nsACString, aExpiration: PRTime) -> nsresult,

    /* void replaceFaviconDataFromDataURL (in nsIURI aFaviconURI, in AString aDataURL, [optional] in PRTime aExpiration, [optional] in nsIPrincipal aLoadingPrincipal); */
    pub ReplaceFaviconDataFromDataURL: unsafe extern "system" fn (this: *const mozIAsyncFavicons, aFaviconURI: *const nsIURI, aDataURL: &::nsstring::nsAString, aExpiration: PRTime, aLoadingPrincipal: *const nsIPrincipal) -> nsresult,

    /* void getFaviconURLForPage (in nsIURI aPageURI, in nsIFaviconDataCallback aCallback, [optional] in unsigned short aPreferredWidth); */
    pub GetFaviconURLForPage: unsafe extern "system" fn (this: *const mozIAsyncFavicons, aPageURI: *const nsIURI, aCallback: *const nsIFaviconDataCallback, aPreferredWidth: libc::uint16_t) -> nsresult,

    /* void getFaviconDataForPage (in nsIURI aPageURI, in nsIFaviconDataCallback aCallback, [optional] in unsigned short aPreferredWidth); */
    pub GetFaviconDataForPage: unsafe extern "system" fn (this: *const mozIAsyncFavicons, aPageURI: *const nsIURI, aCallback: *const nsIFaviconDataCallback, aPreferredWidth: libc::uint16_t) -> nsresult,

    /* void copyFavicons (in nsIURI aFromPageURI, in nsIURI aToPageURI, in unsigned long aFaviconLoadType, [optional] in nsIFaviconDataCallback aCallback); */
    pub CopyFavicons: unsafe extern "system" fn (this: *const mozIAsyncFavicons, aFromPageURI: *const nsIURI, aToPageURI: *const nsIURI, aFaviconLoadType: libc::uint32_t, aCallback: *const nsIFaviconDataCallback) -> 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 mozIAsyncFavicons {

    /// ```text
    /// /**
    ///    * Declares that a given page uses a favicon with the given URI and
    ///    * attempts to fetch and save the icon data by loading the favicon URI
    ///    * through an async network request.
    ///    *
    ///    * If the icon data already exists, we won't try to reload the icon unless
    ///    * aForceReload is true.  Similarly, if the icon is in the failed favicon
    ///    * cache we won't do anything unless aForceReload is true, in which case
    ///    * we'll try to reload the favicon.
    ///    *
    ///    * This function will only save favicons for pages that are already stored in
    ///    * the database, like visited pages or bookmarks.  For any other URIs, it
    ///    * will succeed but do nothing.  This function will also ignore the error
    ///    * page favicon URI (see FAVICON_ERRORPAGE_URL below).
    ///    *
    ///    * Icons that fail to load will automatically be added to the failed favicon
    ///    * cache, and this function will not save favicons for non-bookmarked URIs
    ///    * when history is disabled.
    ///    *
    ///    * @note This function is identical to
    ///    *       nsIFaviconService::setAndLoadFaviconForPage.
    ///    *
    ///    * @param aPageURI
    ///    *        URI of the page whose favicon is being set.
    ///    * @param aFaviconURI
    ///    *        URI of the favicon to associate with the page.
    ///    * @param aForceReload
    ///    *        If aForceReload is false, we try to reload the favicon only if we
    ///    *        don't have it or it has expired from the cache.  Setting
    ///    *        aForceReload to true causes us to reload the favicon even if we
    ///    *        have a usable copy.
    ///    * @param aFaviconLoadType
    ///    *        Set to FAVICON_LOAD_PRIVATE if the favicon is loaded from a private
    ///    *        browsing window.  Set to FAVICON_LOAD_NON_PRIVATE otherwise.
    ///    * @param [optional] aCallback
    ///    *        Once we're done setting and/or fetching the favicon, we invoke this
    ///    *        callback.
    ///    * @param [optional] aLoadingPrincipal
    ///    *        Principal of the page whose favicon is being set. If this argument
    ///    *        is omitted, the loadingPrincipal defaults to the nullPrincipal.
    ///    * @param [optional] aRequestContextID
    ///    *        used to inform Necko of how to link the
    ///    *        favicon request with other requests in the same tab.
    ///    *
    ///    * @see nsIFaviconDataCallback in nsIFaviconService.idl.
    ///    */
    /// ```
    ///

    /// `mozIPlacesPendingOperation setAndFetchFaviconForPage (in nsIURI aPageURI, in nsIURI aFaviconURI, in boolean aForceReload, in unsigned long aFaviconLoadType, [optional] in nsIFaviconDataCallback aCallback, [optional] in nsIPrincipal aLoadingPrincipal, [optional] in unsigned long long aRequestContextID);`
    #[inline]
    pub unsafe fn SetAndFetchFaviconForPage(&self, aPageURI: *const nsIURI, aFaviconURI: *const nsIURI, aForceReload: bool, aFaviconLoadType: libc::uint32_t, aCallback: *const nsIFaviconDataCallback, aLoadingPrincipal: *const nsIPrincipal, aRequestContextID: libc::uint64_t, _retval: *mut *const mozIPlacesPendingOperation) -> nsresult {
        ((*self.vtable).SetAndFetchFaviconForPage)(self, aPageURI, aFaviconURI, aForceReload, aFaviconLoadType, aCallback, aLoadingPrincipal, aRequestContextID, _retval)
    }


    /// ```text
    /// /**
    ///    * Sets the data for a given favicon URI either by replacing existing data in
    ///    * the database or taking the place of otherwise fetched icon data when
    ///    * calling setAndFetchFaviconForPage later.
    ///    *
    ///    * Favicon data for favicon URIs that are not associated with a page URI via
    ///    * setAndFetchFaviconForPage will be stored in memory, but may be expired at
    ///    * any time, so you should make an effort to associate favicon URIs with page
    ///    * URIs as soon as possible.
    ///    *
    ///    * It's better to not use this function for chrome: icon URIs since you can
    ///    * reference the chrome image yourself. getFaviconLinkForIcon/Page will ignore
    ///    * any associated data if the favicon URI is "chrome:" and just return the
    ///    * same chrome URI.
    ///    *
    ///    * This function does NOT send out notifications that the data has changed.
    ///    * Pages using this favicons that are visible in history or bookmarks views
    ///    * will keep the old icon until they have been refreshed by other means.
    ///    *
    ///    * This function tries to optimize the favicon size, if it is bigger
    ///    * than a defined limit we will try to convert it to a 16x16 png image.
    ///    * If the conversion fails and favicon is still bigger than our max accepted
    ///    * size it won't be saved.
    ///    *
    ///    * @param aFaviconURI
    ///    *        URI of the favicon whose data is being set.
    ///    * @param aData
    ///    *        Binary contents of the favicon to save
    ///    * @param aDataLength
    ///    *        Length of binary data
    ///    * @param aMimeType
    ///    *        MIME type of the data to store.  This is important so that we know
    ///    *        what to report when the favicon is used.  You should always set this
    ///    *        param unless you are clearing an icon.
    ///    * @param [optional] aExpiration
    ///    *        Time in microseconds since the epoch when this favicon expires.
    ///    *        Until this time, we won't try to load it again.
    ///    * @throws NS_ERROR_FAILURE
    ///    *         Thrown if the favicon is overbloated and won't be saved to the db.
    ///    */
    /// ```
    ///

    /// `void replaceFaviconData (in nsIURI aFaviconURI, [array, size_is (aDataLen), const] in octet aData, in unsigned long aDataLen, in AUTF8String aMimeType, [optional] in PRTime aExpiration);`
    #[inline]
    pub unsafe fn ReplaceFaviconData(&self, aFaviconURI: *const nsIURI, aData: *const libc::uint8_t, aDataLen: libc::uint32_t, aMimeType: &::nsstring::nsACString, aExpiration: PRTime) -> nsresult {
        ((*self.vtable).ReplaceFaviconData)(self, aFaviconURI, aData, aDataLen, aMimeType, aExpiration)
    }


    /// ```text
    /// /**
    ///    * Same as replaceFaviconData but the data is provided by a string
    ///    * containing a data URL.
    ///    *
    ///    * @see replaceFaviconData
    ///    *
    ///    * @param aFaviconURI
    ///    *        URI of the favicon whose data is being set.
    ///    * @param aDataURL
    ///    *        string containing a data URL that represents the contents of
    ///    *        the favicon to save
    ///    * @param [optional] aExpiration
    ///    *        Time in microseconds since the epoch when this favicon expires.
    ///    *        Until this time, we won't try to load it again.
    ///    * @param [optional] aLoadingPrincipal
    ///    *        Principal of the page whose favicon is being set. If this argument
    ///    *        is omitted, the loadingPrincipal defaults to the nullPrincipal.
    ///    * @throws NS_ERROR_FAILURE
    ///    *         Thrown if the favicon is overbloated and won't be saved to the db.
    ///    */
    /// ```
    ///

    /// `void replaceFaviconDataFromDataURL (in nsIURI aFaviconURI, in AString aDataURL, [optional] in PRTime aExpiration, [optional] in nsIPrincipal aLoadingPrincipal);`
    #[inline]
    pub unsafe fn ReplaceFaviconDataFromDataURL(&self, aFaviconURI: *const nsIURI, aDataURL: &::nsstring::nsAString, aExpiration: PRTime, aLoadingPrincipal: *const nsIPrincipal) -> nsresult {
        ((*self.vtable).ReplaceFaviconDataFromDataURL)(self, aFaviconURI, aDataURL, aExpiration, aLoadingPrincipal)
    }


    /// ```text
    /// /**
    ///    * Retrieves the favicon URI associated to the given page, if any.
    ///    *
    ///    * @param aPageURI
    ///    *        URI of the page whose favicon URI we're looking up.
    ///    * @param aCallback
    ///    *        This callback is always invoked to notify the result of the lookup.
    ///    *        The aURI parameter will be the favicon URI, or null when no favicon
    ///    *        is associated with the page or an error occurred while fetching it.
    ///    *        aDataLen will be always 0, aData will be an empty array, and
    ///    *        aMimeType will be an empty string, regardless of whether a favicon
    ///    *        was found.
    ///    * @param [optional] aPreferredWidth
    ///    *        The preferred icon width, 0 for the biggest available.
    ///    *
    ///    * @note If a favicon specific to this page cannot be found, this will try to
    ///    *       fallback to the /favicon.ico for the root domain.
    ///    *
    ///    * @see nsIFaviconDataCallback in nsIFaviconService.idl.
    ///    */
    /// ```
    ///

    /// `void getFaviconURLForPage (in nsIURI aPageURI, in nsIFaviconDataCallback aCallback, [optional] in unsigned short aPreferredWidth);`
    #[inline]
    pub unsafe fn GetFaviconURLForPage(&self, aPageURI: *const nsIURI, aCallback: *const nsIFaviconDataCallback, aPreferredWidth: libc::uint16_t) -> nsresult {
        ((*self.vtable).GetFaviconURLForPage)(self, aPageURI, aCallback, aPreferredWidth)
    }


    /// ```text
    /// /**
    ///    * Retrieves the favicon URI and data associated to the given page, if any.
    ///    * If the page icon is not available, it will try to return the root domain
    ///    * icon data, when it's known.
    ///    *
    ///    * @param aPageURI
    ///    *        URI of the page whose favicon URI and data we're looking up.
    ///    * @param aCallback
    ///    *        This callback is always invoked to notify the result of the lookup.  The aURI
    ///    *        parameter will be the favicon URI, or null when no favicon is
    ///    *        associated with the page or an error occurred while fetching it.  If
    ///    *        aURI is not null, the other parameters may contain the favicon data.
    ///    *        However, if no favicon data is currently associated with the favicon
    ///    *        URI, aDataLen will be 0, aData will be an empty array, and aMimeType
    ///    *        will be an empty string.
    ///    * @param [optional] aPreferredWidth
    ///    *        The preferred icon width, 0 for the biggest available.
    ///    * @note If a favicon specific to this page cannot be found, this will try to
    ///    *       fallback to the /favicon.ico for the root domain.
    ///    *
    ///    * @see nsIFaviconDataCallback in nsIFaviconService.idl.
    ///    */
    /// ```
    ///

    /// `void getFaviconDataForPage (in nsIURI aPageURI, in nsIFaviconDataCallback aCallback, [optional] in unsigned short aPreferredWidth);`
    #[inline]
    pub unsafe fn GetFaviconDataForPage(&self, aPageURI: *const nsIURI, aCallback: *const nsIFaviconDataCallback, aPreferredWidth: libc::uint16_t) -> nsresult {
        ((*self.vtable).GetFaviconDataForPage)(self, aPageURI, aCallback, aPreferredWidth)
    }


    /// ```text
    /// /**
    ///    * Copies cached favicons from a page to another one.
    ///    *
    ///    * @param aFromPageURI
    ///    *        URI of the originating page.
    ///    * @param aToPageURI
    ///    *        URI of the destination page.
    ///    * @param aFaviconLoadType
    ///    *        Set to FAVICON_LOAD_PRIVATE if the copy is started from a private
    ///    *        browsing window.  Set to FAVICON_LOAD_NON_PRIVATE otherwise.
    ///    * @param [optional] aCallback
    ///    *        Once we're done copying the favicon, we invoke this callback.
    ///    *        If a copy has been done, the callback will report one of the
    ///    *        favicons uri as aFaviconURI, otherwise all the params will be null.
    ///    */
    /// ```
    ///

    /// `void copyFavicons (in nsIURI aFromPageURI, in nsIURI aToPageURI, in unsigned long aFaviconLoadType, [optional] in nsIFaviconDataCallback aCallback);`
    #[inline]
    pub unsafe fn CopyFavicons(&self, aFromPageURI: *const nsIURI, aToPageURI: *const nsIURI, aFaviconLoadType: libc::uint32_t, aCallback: *const nsIFaviconDataCallback) -> nsresult {
        ((*self.vtable).CopyFavicons)(self, aFromPageURI, aToPageURI, aFaviconLoadType, aCallback)
    }


}