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


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

    /// 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 nsILoginManager.
unsafe impl XpCom for nsILoginManager {
    const IID: nsIID = nsID(0x38c7f6af, 0x7df9, 0x49c7,
        [0xb5, 0x58, 0x27, 0x76, 0xb2, 0x4e, 0x6c, 0xc1]);
}

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

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

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

    /* readonly attribute jsval initializationPromise; */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub GetInitializationPromise: *const ::libc::c_void,

    /* nsILoginInfo addLogin (in nsILoginInfo aLogin); */
    pub AddLogin: unsafe extern "system" fn (this: *const nsILoginManager, aLogin: *const nsILoginInfo, _retval: *mut *const nsILoginInfo) -> nsresult,

    /* void removeLogin (in nsILoginInfo aLogin); */
    pub RemoveLogin: unsafe extern "system" fn (this: *const nsILoginManager, aLogin: *const nsILoginInfo) -> nsresult,

    /* void modifyLogin (in nsILoginInfo oldLogin, in nsISupports newLoginData); */
    pub ModifyLogin: unsafe extern "system" fn (this: *const nsILoginManager, oldLogin: *const nsILoginInfo, newLoginData: *const nsISupports) -> nsresult,

    /* void removeAllLogins (); */
    pub RemoveAllLogins: unsafe extern "system" fn (this: *const nsILoginManager) -> nsresult,

    /* void getAllLogins ([optional] out unsigned long count, [array, size_is (count), retval] out nsILoginInfo logins); */
    pub GetAllLogins: unsafe extern "system" fn (this: *const nsILoginManager, count: *mut libc::uint32_t, logins: *mut *mut *const nsILoginInfo) -> nsresult,

    /* void getAllDisabledHosts ([optional] out unsigned long count, [array, size_is (count), retval] out wstring hostnames); */
    pub GetAllDisabledHosts: unsafe extern "system" fn (this: *const nsILoginManager, count: *mut libc::uint32_t, hostnames: *mut *mut *const libc::int16_t) -> nsresult,

    /* boolean getLoginSavingEnabled (in AString aHost); */
    pub GetLoginSavingEnabled: unsafe extern "system" fn (this: *const nsILoginManager, aHost: &::nsstring::nsAString, _retval: *mut bool) -> nsresult,

    /* void setLoginSavingEnabled (in AString aHost, in boolean isEnabled); */
    pub SetLoginSavingEnabled: unsafe extern "system" fn (this: *const nsILoginManager, aHost: &::nsstring::nsAString, isEnabled: bool) -> nsresult,

    /* void findLogins (out unsigned long count, in AString aHostname, in AString aActionURL, in AString aHttpRealm, [array, size_is (count), retval] out nsILoginInfo logins); */
    pub FindLogins: unsafe extern "system" fn (this: *const nsILoginManager, count: *mut libc::uint32_t, aHostname: &::nsstring::nsAString, aActionURL: &::nsstring::nsAString, aHttpRealm: &::nsstring::nsAString, logins: *mut *mut *const nsILoginInfo) -> nsresult,

    /* unsigned long countLogins (in AString aHostname, in AString aActionURL, in AString aHttpRealm); */
    pub CountLogins: unsafe extern "system" fn (this: *const nsILoginManager, aHostname: &::nsstring::nsAString, aActionURL: &::nsstring::nsAString, aHttpRealm: &::nsstring::nsAString, _retval: *mut libc::uint32_t) -> nsresult,

    /* void autoCompleteSearchAsync (in AString aSearchString, in nsIAutoCompleteResult aPreviousResult, in nsIDOMHTMLInputElement aElement, in nsIFormAutoCompleteObserver aListener); */
    pub AutoCompleteSearchAsync: unsafe extern "system" fn (this: *const nsILoginManager, aSearchString: &::nsstring::nsAString, aPreviousResult: *const nsIAutoCompleteResult, aElement: *const nsIDOMHTMLInputElement, aListener: *const nsIFormAutoCompleteObserver) -> nsresult,

    /* void stopSearch (); */
    pub StopSearch: unsafe extern "system" fn (this: *const nsILoginManager) -> nsresult,

    /* void searchLogins (out unsigned long count, in nsIPropertyBag matchData, [array, size_is (count), retval] out nsILoginInfo logins); */
    pub SearchLogins: unsafe extern "system" fn (this: *const nsILoginManager, count: *mut libc::uint32_t, matchData: *const nsIPropertyBag, logins: *mut *mut *const nsILoginInfo) -> nsresult,

    /* readonly attribute boolean uiBusy; */
    pub GetUiBusy: unsafe extern "system" fn (this: *const nsILoginManager, aUiBusy: *mut bool) -> nsresult,

    /* readonly attribute boolean isLoggedIn; */
    pub GetIsLoggedIn: unsafe extern "system" fn (this: *const nsILoginManager, aIsLoggedIn: *mut bool) -> 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 nsILoginManager {

    /// ```text
    /// /**
    ///    * This promise is resolved when initialization is complete, and is rejected
    ///    * in case initialization failed.  This includes the initial loading of the
    ///    * login data as well as any migration from previous versions.
    ///    *
    ///    * Calling any method of nsILoginManager before this promise is resolved
    ///    * might trigger the synchronous initialization fallback.
    ///    */
    /// ```
    ///

    /// `readonly attribute jsval initializationPromise;`
    const _GetInitializationPromise: () = ();

    /// ```text
    /// /**
    ///    * Store a new login in the login manager.
    ///    *
    ///    * @param aLogin
    ///    *        The login to be added.
    ///    * @return a clone of the login info with the guid set (even if it was not provided)
    ///    *
    ///    * Default values for the login's nsILoginMetaInfo properties will be
    ///    * created. However, if the caller specifies non-default values, they will
    ///    * be used instead.
    ///    */
    /// ```
    ///

    /// `nsILoginInfo addLogin (in nsILoginInfo aLogin);`
    #[inline]
    pub unsafe fn AddLogin(&self, aLogin: *const nsILoginInfo, _retval: *mut *const nsILoginInfo) -> nsresult {
        ((*self.vtable).AddLogin)(self, aLogin, _retval)
    }


    /// ```text
    /// /**
    ///    * Remove a login from the login manager.
    ///    *
    ///    * @param aLogin
    ///    *        The login to be removed.
    ///    *
    ///    * The specified login must exactly match a stored login. However, the
    ///    * values of any nsILoginMetaInfo properties are ignored.
    ///    */
    /// ```
    ///

    /// `void removeLogin (in nsILoginInfo aLogin);`
    #[inline]
    pub unsafe fn RemoveLogin(&self, aLogin: *const nsILoginInfo) -> nsresult {
        ((*self.vtable).RemoveLogin)(self, aLogin)
    }


    /// ```text
    /// /**
    ///    * Modify an existing login in the login manager.
    ///    *
    ///    * @param oldLogin
    ///    *        The login to be modified.
    ///    * @param newLoginData
    ///    *        The new login values (either a nsILoginInfo or nsIProperyBag)
    ///    *
    ///    * If newLoginData is a nsILoginInfo, all of the old login's nsILoginInfo
    ///    * properties are changed to the values from newLoginData (but the old
        ///    * login's nsILoginMetaInfo properties are unmodified).
    ///    *
    ///    * If newLoginData is a nsIPropertyBag, only the specified properties
    ///    * will be changed. The nsILoginMetaInfo properties of oldLogin can be
    ///    * changed in this manner.
    ///    *
    ///    * If the propertybag contains an item named "timesUsedIncrement", the
    ///    * login's timesUsed property will be incremented by the item's value.
    ///    */
    /// ```
    ///

    /// `void modifyLogin (in nsILoginInfo oldLogin, in nsISupports newLoginData);`
    #[inline]
    pub unsafe fn ModifyLogin(&self, oldLogin: *const nsILoginInfo, newLoginData: *const nsISupports) -> nsresult {
        ((*self.vtable).ModifyLogin)(self, oldLogin, newLoginData)
    }


    /// ```text
    /// /**
    ///    * Remove all logins known to login manager.
    ///    *
    ///    * The browser sanitization feature allows the user to clear any stored
    ///    * passwords. This interface allows that to be done without getting each
    ///    * login first (which might require knowing the master password).
    ///    *
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Fetch all logins in the login manager. An array is always returned;
    ///    * if there are no logins the array is empty.
    ///    *
    ///    * @param count
    ///    *        The number of elements in the array. JS callers can simply use
    ///    *        the array's .length property and omit this param.
    ///    * @param logins
    ///    *        An array of nsILoginInfo objects.
    ///    *
    ///    * NOTE: This can be called from JS as:
    ///    *       var logins = pwmgr.getAllLogins();
    ///    *       (|logins| is an array).
    ///    */
    /// ```
    ///

    /// `void getAllLogins ([optional] out unsigned long count, [array, size_is (count), retval] out nsILoginInfo logins);`
    #[inline]
    pub unsafe fn GetAllLogins(&self, count: *mut libc::uint32_t, logins: *mut *mut *const nsILoginInfo) -> nsresult {
        ((*self.vtable).GetAllLogins)(self, count, logins)
    }


    /// ```text
    /// /**
    ///    * Obtain a list of all hosts for which password saving is disabled.
    ///    *
    ///    * @param count
    ///    *        The number of elements in the array. JS callers can simply use
    ///    *        the array's .length property and omit this param.
    ///    * @param hostnames
    ///    *        An array of hostname strings, in origin URL format without a
    ///    *        pathname. For example: "https://www.site.com".
    ///    *
    ///    * NOTE: This can be called from JS as:
    ///    *       var logins = pwmgr.getDisabledAllLogins();
    ///    */
    /// ```
    ///

    /// `void getAllDisabledHosts ([optional] out unsigned long count, [array, size_is (count), retval] out wstring hostnames);`
    #[inline]
    pub unsafe fn GetAllDisabledHosts(&self, count: *mut libc::uint32_t, hostnames: *mut *mut *const libc::int16_t) -> nsresult {
        ((*self.vtable).GetAllDisabledHosts)(self, count, hostnames)
    }


    /// ```text
    /// /**
    ///    * Check to see if saving logins has been disabled for a host.
    ///    *
    ///    * @param aHost
    ///    *        The hostname to check. This argument should be in the origin
    ///    *        URL format, without a pathname. For example: "http://foo.com".
    ///    */
    /// ```
    ///

    /// `boolean getLoginSavingEnabled (in AString aHost);`
    #[inline]
    pub unsafe fn GetLoginSavingEnabled(&self, aHost: &::nsstring::nsAString, _retval: *mut bool) -> nsresult {
        ((*self.vtable).GetLoginSavingEnabled)(self, aHost, _retval)
    }


    /// ```text
    /// /**
    ///    * Disable (or enable) storing logins for the specified host. When
    ///    * disabled, the login manager will not prompt to store logins for
    ///    * that host. Existing logins are not affected.
    ///    *
    ///    * @param aHost
    ///    *        The hostname to set. This argument should be in the origin
    ///    *        URL format, without a pathname. For example: "http://foo.com".
    ///    * @param isEnabled
    ///    *        Specify if saving logins should be enabled (true) or
    ///    *        disabled (false)
    ///    */
    /// ```
    ///

    /// `void setLoginSavingEnabled (in AString aHost, in boolean isEnabled);`
    #[inline]
    pub unsafe fn SetLoginSavingEnabled(&self, aHost: &::nsstring::nsAString, isEnabled: bool) -> nsresult {
        ((*self.vtable).SetLoginSavingEnabled)(self, aHost, isEnabled)
    }


    /// ```text
    /// /**
    ///    * Search for logins matching the specified criteria. Called when looking
    ///    * for logins that might be applicable to a form or authentication request.
    ///    *
    ///    * @param count
    ///    *        The number of elements in the array. JS callers can simply use
    ///    *        the array's .length property, and supply an dummy object for
    ///    *        this out param. For example: |findLogins({}, hostname, ...)|
    ///    * @param aHostname
    ///    *        The hostname to restrict searches to, in URL format. For
    ///    *        example: "http://www.site.com".
    ///    *        To find logins for a given nsIURI, you would typically pass in
    ///    *        its prePath.
    ///    * @param aActionURL
    ///    *        For form logins, this argument should be the URL to which the
    ///    *        form will be submitted. For protocol logins, specify null.
    ///    *        An empty string ("") will match any value (except null).
    ///    * @param aHttpRealm
    ///    *        For protocol logins, this argument should be the HTTP Realm
    ///    *        for which the login applies. This is obtained from the
    ///    *        WWW-Authenticate header. See RFC2617. For form logins,
    ///    *        specify null.
    ///    *        An empty string ("") will match any value (except null).
    ///    * @param logins
    ///    *        An array of nsILoginInfo objects.
    ///    *
    ///    * NOTE: This can be called from JS as:
    ///    *       var logins = pwmgr.findLogins({}, hostname, ...);
    ///    *
    ///    */
    /// ```
    ///

    /// `void findLogins (out unsigned long count, in AString aHostname, in AString aActionURL, in AString aHttpRealm, [array, size_is (count), retval] out nsILoginInfo logins);`
    #[inline]
    pub unsafe fn FindLogins(&self, count: *mut libc::uint32_t, aHostname: &::nsstring::nsAString, aActionURL: &::nsstring::nsAString, aHttpRealm: &::nsstring::nsAString, logins: *mut *mut *const nsILoginInfo) -> nsresult {
        ((*self.vtable).FindLogins)(self, count, aHostname, aActionURL, aHttpRealm, logins)
    }


    /// ```text
    /// /**
    ///    * Search for logins matching the specified criteria, as with
    ///    * findLogins(). This interface only returns the number of matching
    ///    * logins (and not the logins themselves), which allows a caller to
    ///    * check for logins without causing the user to be prompted for a master
    ///    * password to decrypt the logins.
    ///    *
    ///    * @param aHostname
    ///    *        The hostname to restrict searches to. Specify an empty string
    ///    *        to match all hosts. A null value will not match any logins, and
    ///    *        will thus always return a count of 0.
    ///    * @param aActionURL
    ///    *        The URL to which a form login will be submitted. To match any
    ///    *        form login, specify an empty string. To not match any form
    ///    *        login, specify null.
    ///    * @param aHttpRealm
    ///    *        The HTTP Realm for which the login applies. To match logins for
    ///    *        any realm, specify an empty string. To not match logins for any
    ///    *        realm, specify null.
    ///    */
    /// ```
    ///

    /// `unsigned long countLogins (in AString aHostname, in AString aActionURL, in AString aHttpRealm);`
    #[inline]
    pub unsafe fn CountLogins(&self, aHostname: &::nsstring::nsAString, aActionURL: &::nsstring::nsAString, aHttpRealm: &::nsstring::nsAString, _retval: *mut libc::uint32_t) -> nsresult {
        ((*self.vtable).CountLogins)(self, aHostname, aActionURL, aHttpRealm, _retval)
    }


    /// ```text
    /// /**
    ///    * Generate results for a userfield autocomplete menu.
    ///    *
    ///    * NOTE: This interface is provided for use only by the FormFillController,
    ///    *       which calls it directly. This isn't really ideal, it should
    ///    *       probably be callback registered through the FFC.
    ///    */
    /// ```
    ///

    /// `void autoCompleteSearchAsync (in AString aSearchString, in nsIAutoCompleteResult aPreviousResult, in nsIDOMHTMLInputElement aElement, in nsIFormAutoCompleteObserver aListener);`
    #[inline]
    pub unsafe fn AutoCompleteSearchAsync(&self, aSearchString: &::nsstring::nsAString, aPreviousResult: *const nsIAutoCompleteResult, aElement: *const nsIDOMHTMLInputElement, aListener: *const nsIFormAutoCompleteObserver) -> nsresult {
        ((*self.vtable).AutoCompleteSearchAsync)(self, aSearchString, aPreviousResult, aElement, aListener)
    }


    /// ```text
    /// /**
    ///    * Stop a previously-started async search.
    ///    */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///    * Search for logins in the login manager. An array is always returned;
    ///    * if there are no logins the array is empty.
    ///    *
    ///    * @param count
    ///    *        The number of elements in the array. JS callers can simply use
    ///    *        the array's .length property, and supply an dummy object for
    ///    *        this out param. For example: |searchLogins({}, matchData)|
    ///    * @param matchData
    ///    *        The data used to search. This does not follow the same
    ///    *        requirements as findLogins for those fields. Wildcard matches are
    ///    *        simply not specified.
    ///    * @param logins
    ///    *        An array of nsILoginInfo objects.
    ///    *
    ///    * NOTE: This can be called from JS as:
    ///    *       var logins = pwmgr.searchLogins({}, matchData);
    ///    *       (|logins| is an array).
    ///    */
    /// ```
    ///

    /// `void searchLogins (out unsigned long count, in nsIPropertyBag matchData, [array, size_is (count), retval] out nsILoginInfo logins);`
    #[inline]
    pub unsafe fn SearchLogins(&self, count: *mut libc::uint32_t, matchData: *const nsIPropertyBag, logins: *mut *mut *const nsILoginInfo) -> nsresult {
        ((*self.vtable).SearchLogins)(self, count, matchData, logins)
    }


    /// ```text
    /// /**
    ///   * True when a master password prompt is being displayed.
    ///   */
    /// ```
    ///

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


    /// ```text
    /// /**
    ///   * True when the master password has already been entered, and so a caller
    ///   * can ask for decrypted logins without triggering a prompt.
    ///   */
    /// ```
    ///

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


}