Struct xpcom::interfaces::nsICookiePermission

#[repr(C)]
pub struct nsICookiePermission { /* fields omitted */ }

interface nsICookiePermission : nsISupports

/**
 * An interface to test for cookie permissions
 */

Methods

impl nsICookiePermission

pub fn coerce<T: nsICookiePermissionCoerce>(&self) -> &T

Cast this nsICookiePermission to one of its base interfaces.

impl nsICookiePermission

pub const ACCESS_DEFAULT: i64

ACCESS_DEFAULT: i64 = 0

/**
   * nsCookieAccess values
   */

pub const ACCESS_ALLOW: i64

ACCESS_ALLOW: i64 = 1

pub const ACCESS_DENY: i64

ACCESS_DENY: i64 = 2

pub const ACCESS_SESSION: i64

ACCESS_SESSION: i64 = 8

/**
   * additional values for nsCookieAccess which may not match
   * nsIPermissionManager. Keep 3-7 available to allow nsIPermissionManager to
   * add values without colliding. ACCESS_SESSION is not directly returned by
   * any methods on this interface.
   */

pub const ACCESS_ALLOW_FIRST_PARTY_ONLY: i64

ACCESS_ALLOW_FIRST_PARTY_ONLY: i64 = 9

pub const ACCESS_LIMIT_THIRD_PARTY: i64

ACCESS_LIMIT_THIRD_PARTY: i64 = 10

pub unsafe fn SetAccess(
    &self,
    aURI: *const nsIURI,
    aAccess: nsCookieAccess
) -> nsresult

/**
   * setAccess
   *
   * this method is called to block cookie access for the given URI.  this
   * may result in other URIs being blocked as well (e.g., URIs which share
   * the same host name).
   *
   * @param aURI
   *        the URI to block
   * @param aAccess
   *        the new cookie access for the URI.
   */

void setAccess (in nsIURI aURI, in nsCookieAccess aAccess);

pub unsafe fn CanAccess(
    &self,
    aPrincipal: *const nsIPrincipal,
    _retval: *mut nsCookieAccess
) -> nsresult

/**
   * canAccess
   *
   * this method is called to test whether or not the given URI/channel may
   * access the cookie database, either to set or get cookies.
   *
   * @param aPrincipal
   *        the principal trying to access cookies.
   *
   * @return one of the following nsCookieAccess values:
   *         ACCESS_DEFAULT, ACCESS_ALLOW, ACCESS_DENY, or
   *         ACCESS_ALLOW_FIRST_PARTY_ONLY
   */

nsCookieAccess canAccess (in nsIPrincipal aPrincipal);

pub unsafe fn CanSetCookie(
    &self,
    aURI: *const nsIURI,
    aChannel: *const nsIChannel,
    aCookie: *const nsICookie2,
    aIsSession: *mut bool,
    aExpiry: *mut int64_t,
    _retval: *mut bool
) -> nsresult

/**
   * canSetCookie
   *
   * this method is called to test whether or not the given URI/channel may
   * set a specific cookie.  this method is always preceded by a call to
   * canAccess. it may modify the isSession and expiry attributes of the
   * cookie via the aIsSession and aExpiry parameters, in order to limit
   * or extend the lifetime of the cookie. this is useful, for instance, to
   * downgrade a cookie to session-only if it fails to meet certain criteria.
   *
   * @param aURI
   *        the URI trying to set the cookie
   * @param aChannel
   *        the channel corresponding to aURI
   * @param aCookie
   *        the cookie being added to the cookie database
   * @param aIsSession
   *        when canSetCookie is invoked, this is the current isSession attribute
   *        of the cookie. canSetCookie may leave this value unchanged to
   *        preserve this attribute of the cookie.
   * @param aExpiry
   *        when canSetCookie is invoked, this is the current expiry time of
   *        the cookie. canSetCookie may leave this value unchanged to
   *        preserve this attribute of the cookie.
   *
   * @return true if the cookie can be set.
   */

boolean canSetCookie (in nsIURI aURI, in nsIChannel aChannel, in nsICookie2 aCookie, inout boolean aIsSession, inout int64_t aExpiry);

Methods from Deref<Target = nsISupports>

pub fn coerce<T: nsISupportsCoerce>(&self) -> &T

Cast this nsISupports to one of its base interfaces.

pub unsafe fn QueryInterface(
    &self,
    uuid: &nsIID,
    result: *mut *mut c_void
) -> nsresult

void QueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result);

pub unsafe fn AddRef(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt AddRef ();

pub unsafe fn Release(&self) -> nsrefcnt

[noscript,notxpcom] nsrefcnt Release ();

Trait Implementations

impl XpCom for nsICookiePermission

const IID: nsIID

IID: nsIID = nsID(299750637, 36699, 16563, [178, 160, 39, 194, 14, 161, 200, 141])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for nsICookiePermission

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for nsICookiePermission

type Target = nsISupports

The resulting type after dereferencing.

fn deref(&self) -> &nsISupports

Dereferences the value.