Set deletion for browser’s cookie about RememberMe.
193614
private function unsetRememberMe(): bool {
		
		$this->rememberMe = NULL;
		if (!$this->store()) {
			return FALSE;
		}
		
		return setcookie(static::getRememberMeCookieName(), '', -1, '/');
		
	}
1346801
def revert(self, filename=None,
               ignore_discard=False, ignore_expires=False):
        
        if filename is None:
            if self.filename is not None: filename = self.filename
            else: raise ValueError(MISSING_FILENAME_TEXT)

        self._cookies_lock.acquire()
        try:

            old_state = copy.deepcopy(self._cookies)
            self._cookies = {}
            try:
                self.load(filename, ignore_discard, ignore_expires)
            except (LoadError, IOError):
                self._cookies = old_state
                raise

        finally:
            self._cookies_lock.release()
1331959
def del_cookie(self, name: str, *,
                   domain: Optional[str]=None,
                   path: str='/') -> None:
        
        # TODO: do we need domain/path here?
        self._cookies.pop(name, None)
        self.set_cookie(name, '', max_age=0,
                        expires="Thu, 01 Jan 1970 00:00:00 GMT",
                        domain=domain, path=path)
144529
def set_cookie(  # type: ignore
            self,
            key: str,
            value: AnyStr='',
            max_age: Optional[Union[int, timedelta]]=None,
            expires: Optional[datetime]=None,
            path: str='/',
            domain: Optional[str]=None,
            secure: bool=False,
            httponly: bool=False,
    ) -> None:
        
        if isinstance(value, bytes):
            value = value.decode()  # type: ignore
        cookie = create_cookie(key, value, max_age, expires, path, domain, secure, httponly)  # type: ignore  # noqa: E501
        self.headers.add('Set-Cookie', cookie.output(header=''))
549019
protected function getAuthCookie($rememberMe)
    {
        $authCookieExpiry = $rememberMe ? time() + $this->authCookieValidTime : 0;
        $cookie = new Cookie($this->authCookieName, $authCookieExpiry, $this->authCookiePath);
        return $cookie;
    }
930809
function deleteCookie(cookieName) {
  if (getCookie(cookieName)) {
    document.cookie = cookieName + '=; Path=/; Expires=Thu, 01 Jan 1970 00:00:01 GMT;';
    _logger2.default.debug({
      description: 'Cookie deleted.', cookieName: cookieName, func: 'deleteCookie'
    });
  } else {
    _logger2.default.warn({
      description: 'Cookie cannot be deleted because it does not exist.',
      cookieName: cookieName, func: 'deleteCookie', obj: 'cookiesUtil'
    });
  }
}
840670
protected function setRememberMeCookie(): void
	{
		if($this->options['cookie_options']['secure'] && !$this->request->isSecure())
		{
			throw new RuntimeException('Attempted to set a secure cookie over a non-secure connection.');
		}

		$this->response->getCookies()->addSigned($this->options['auth_key'], $this->user->getAccessToken(), (3600 * 24 * 365), $this->options['cookie_options']);
	}
1022853
function setCookie(cookieName, cookieValue, expDays) {
  var d = new Date();
  d.setTime(d.getTime() + expDays * 24 * 60 * 60 * 1000);
  var expires = 'expires=' + d.toUTCString();
  try {
    document.cookie = cookieName + '=' + cookieValue + '; Path=/; ' + expires;
  } catch (e) {
    _logger2.default.warn({
      description: 'Cookie cannot be set because browser is not capable.',
      cookieName: cookieName, func: 'setCookie', obj: 'cookiesUtil'
    });
  }
}
274689
def delete_cookie(self, key, path='/', domain=None):
        
        self.set_cookie(key, value='', max_age=0, path=path, domain=domain,
                        expires=datetime.utcfromtimestamp(0))
910244
def _set_cookies(self, cookies):
        
        cookie_dict = helpers.parse_cookies_str(cookies)
        self.s.cookies.update(cookie_dict)
1210853
function(name, cookie) {
    if (typeof cookie === 'undefined') {
      cookie = this.cookies[name]
    }
    var now = new Date()
    if (cookie && cookie.expires && now > cookie.expires) {
      delete this.cookies[name]
      return false
    }
    return true
  }
240381
def set_browser_id
      until cookies[Authie.config.browser_id_cookie_name]
        proposed_browser_id = SecureRandom.uuid
        unless Session.where(:browser_id => proposed_browser_id).exists?
          cookies[Authie.config.browser_id_cookie_name] = {
            :value => proposed_browser_id,
            :expires => 5.years.from_now,
            :httponly => true,
            :secure => @controller.request.ssl?
          }
          # Dispatch an event when the browser ID is set.
          Authie.config.events.dispatch(:set_browser_id, proposed_browser_id)
        end
      end
    end
250376
public void clearReferrerURLCookie(HttpServletRequest req, HttpServletResponse res, String cookieName) {

        String url = CookieHelper.getCookieValue(req.getCookies(), cookieName);
        if (url != null && url.length() > 0) {
            invalidateReferrerURLCookie(req, res, cookieName);
        }
    }
823015
public function delete()
    {
        if ($this->getName()) {
            unset($_COOKIE[$this->getName()]);
            setcookie($this->getName(), null, time() - 3600, '/');
        }
        return;
    }
873812
def set(self, name, value, domain, **kwargs):
        

        if domain == 'localhost':
            domain = ''

        self.cookiejar.set_cookie(create_cookie(name, value, domain, **kwargs))
94868
public function setRememberMe($rememberMe)
    {
        $this->rememberMe = $rememberMe;
        $this->storage->setTokenRememberMe($rememberMe);

        return $this;
    }
643549
def clean_cookie(self):
        """"""
        if not self.is_cookie_necessary:
            return self
        headers = self.request.get('headers', {})
        cookies = SimpleCookie(headers['Cookie'])
        for k, v in cookies.items():
            new_cookie = '; '.join(
                [i.OutputString() for i in cookies.values() if i != v])
            new_request = deepcopy(self.request)
            new_request['headers']['Cookie'] = new_cookie
            self._add_task('Cookie', k, new_request)
        return self