Merge "Declare visibility on class properties of LoginForm"
authorjenkins-bot <jenkins-bot@gerrit.wikimedia.org>
Wed, 26 Mar 2014 15:49:49 +0000 (15:49 +0000)
committerGerrit Code Review <gerrit@wikimedia.org>
Wed, 26 Mar 2014 15:49:49 +0000 (15:49 +0000)
1  2 
includes/specials/SpecialUserlogin.php

@@@ -43,26 -43,38 +43,38 @@@ class LoginForm extends SpecialPage 
        const NEED_TOKEN = 12;
        const WRONG_TOKEN = 13;
  
-       var $mUsername, $mPassword, $mRetype, $mReturnTo, $mCookieCheck, $mPosted;
-       var $mAction, $mCreateaccount, $mCreateaccountMail;
-       var $mLoginattempt, $mRemember, $mEmail, $mDomain, $mLanguage;
-       var $mSkipCookieCheck, $mReturnToQuery, $mToken, $mStickHTTPS;
-       var $mType, $mReason, $mRealName;
-       var $mAbortLoginErrorMsg = null;
+       public $mAbortLoginErrorMsg = null;
+       protected $mUsername;
+       protected $mPassword;
+       protected $mRetype;
+       protected $mReturnTo;
+       protected $mCookieCheck;
+       protected $mPosted;
+       protected $mAction;
+       protected $mCreateaccount;
+       protected $mCreateaccountMail;
+       protected $mLoginattempt;
+       protected $mRemember;
+       protected $mEmail;
+       protected $mDomain;
+       protected $mLanguage;
+       protected $mSkipCookieCheck;
+       protected $mReturnToQuery;
+       protected $mToken;
+       protected $mStickHTTPS;
+       protected $mType;
+       protected $mReason;
+       protected $mRealName;
        private $mTempPasswordUsed;
        private $mLoaded = false;
        private $mSecureLoginUrl;
  
-       /**
-        * @ var WebRequest
-        */
+       /** @var WebRequest */
        private $mOverrideRequest = null;
  
-       /**
-        * Effective request; set at the beginning of load
-        *
-        * @var WebRequest $mRequest
-        */
+       /** @var WebRequest Effective request; set at the beginning of load */
        private $mRequest = null;
  
        /**
                $this->mCookieCheck = $request->getVal( 'wpCookieCheck' );
                $this->mPosted = $request->wasPosted();
                $this->mCreateaccountMail = $request->getCheck( 'wpCreateaccountMail' )
 -                                                                      && $wgEnableEmail;
 +                      && $wgEnableEmail;
                $this->mCreateaccount = $request->getCheck( 'wpCreateaccount' ) && !$this->mCreateaccountMail;
                $this->mLoginattempt = $request->getCheck( 'wpLoginattempt' );
                $this->mAction = $request->getVal( 'action' );
                # 2. Do not return to PasswordReset after a successful password change
                #    but goto Wiki start page (Main_Page) instead ( bug 33997 )
                $returnToTitle = Title::newFromText( $this->mReturnTo );
 -              if ( is_object( $returnToTitle ) && (
 -                      $returnToTitle->isSpecial( 'Userlogout' )
 -                      || $returnToTitle->isSpecial( 'PasswordReset' ) ) ) {
 +              if ( is_object( $returnToTitle )
 +                      && ( $returnToTitle->isSpecial( 'Userlogout' )
 +                              || $returnToTitle->isSpecial( 'PasswordReset' ) )
 +              ) {
                        $this->mReturnTo = '';
                        $this->mReturnToQuery = '';
                }
                                $this->getOutput()->redirect( $url );
                                // Since we only do this redir to change proto, always vary
                                $this->getOutput()->addVaryHeader( 'X-Forwarded-Proto' );
 +
                                return;
                        } else {
                                // A wiki without HTTPS login support should set $wgServer to
  
                if ( !is_null( $this->mCookieCheck ) ) {
                        $this->onCookieRedirectCheck( $this->mCookieCheck );
 +
                        return;
                } elseif ( $this->mPosted ) {
                        if ( $this->mCreateaccount ) {
                                $this->addNewAccount();
 +
                                return;
                        } elseif ( $this->mCreateaccountMail ) {
                                $this->addNewAccountMailPassword();
 +
                                return;
                        } elseif ( ( 'submitlogin' == $this->mAction ) || $this->mLoginattempt ) {
                                $this->processLogin();
 +
                                return;
                        }
                }
        function addNewAccountMailPassword() {
                if ( $this->mEmail == '' ) {
                        $this->mainLoginForm( $this->msg( 'noemailcreate' )->escaped() );
 +
                        return;
                }
  
                if ( !$status->isGood() ) {
                        $error = $status->getMessage();
                        $this->mainLoginForm( $error->toString() );
 +
                        return;
                }
  
                if ( !$status->isGood() ) {
                        $error = $status->getMessage();
                        $this->mainLoginForm( $error->toString() );
 +
                        return false;
                }
  
                        wfRunHooks( 'AddNewAccount', array( $u, false ) );
                        $u->addNewUserLogEntry( 'create2', $this->mReason );
                }
 +
                return true;
        }
  
                # Request forgery checks.
                if ( !self::getCreateaccountToken() ) {
                        self::setCreateaccountToken();
 +
                        return Status::newFatal( 'nocookiesfornew' );
                }
  
                } elseif ( $creationBlock instanceof Block ) {
                        // Throws an ErrorPageError.
                        $this->userBlockedMessage( $creationBlock );
 +
                        // This should never be reached.
                        return false;
                }
                # Include checks that will include GlobalBlocking (Bug 38333)
                $permErrors = $this->getPageTitle()->getUserPermissionsErrors( 'createaccount', $currentUser, true );
                if ( count( $permErrors ) ) {
 -                              throw new PermissionsError( 'createaccount', $permErrors );
 +                      throw new PermissionsError( 'createaccount', $permErrors );
                }
  
                $ip = $this->getRequest()->getIP();
                                if ( !is_array( $valid ) ) {
                                        $valid = array( $valid, $wgMinimalPasswordLength );
                                }
 +
                                return call_user_func_array( 'Status::newFatal', $valid );
                        }
                }
                                // To return a different error code, return a Status object.
                                $abortError = new Message( 'createaccount-hook-aborted', array( $abortError ) );
                                $abortError->text();
 +
                                return Status::newFatal( $abortError );
                        } else {
                                // For MediaWiki 1.23+ and updated hooks, return the Status object
                }
  
                self::clearCreateaccountToken();
 +
                return $this->initUser( $u, false );
        }
  
                // If the user doesn't have a login token yet, set one.
                if ( !self::getLoginToken() ) {
                        self::setLoginToken();
 +
                        return self::NEED_TOKEN;
                }
                // If the user didn't pass a login token, tell them we need one
                // will effectively be using stale data.
                if ( $this->getUser()->getName() === $this->mUsername ) {
                        wfDebug( __METHOD__ . ": already logged in as {$this->mUsername}\n" );
 +
                        return self::SUCCESS;
                }
  
                $msg = null;
                if ( !wfRunHooks( 'AbortLogin', array( $u, $this->mPassword, &$abort, &$msg ) ) ) {
                        $this->mAbortLoginErrorMsg = $msg;
 +
                        return $abort;
                }
  
                        $retval = self::SUCCESS;
                }
                wfRunHooks( 'LoginAuthenticateAudit', array( $u, $this->mPassword, $retval ) );
 +
                return $retval;
        }
  
  
                if ( $this->getUser()->isBlockedFromCreateAccount() ) {
                        wfDebug( __METHOD__ . ": user is blocked from account creation\n" );
 +
                        return self::CREATE_BLOCKED;
                }
 +
                if ( !$wgAuth->autoCreate() ) {
                        return self::NOT_EXISTS;
                }
 +
                if ( !$wgAuth->userExists( $user->getName() ) ) {
                        wfDebug( __METHOD__ . ": user does not exist\n" );
 +
                        return self::NOT_EXISTS;
                }
 +
                if ( !$wgAuth->authenticate( $user->getName(), $this->mPassword ) ) {
                        wfDebug( __METHOD__ . ": \$wgAuth->authenticate() returned false, aborting\n" );
 +
                        return self::WRONG_PLUGIN_PASS;
                }
  
                        // Hook point to add extra creation throttles and blocks
                        wfDebug( "LoginForm::attemptAutoCreate: a hook blocked creation: $abortError\n" );
                        $this->mAbortLoginErrorMsg = $abortError;
 +
                        return self::ABORTED;
                }
  
                if ( !$status->isOK() ) {
                        $errors = $status->getErrorsByType( 'error' );
                        $this->mAbortLoginErrorMsg = $errors[0]['message'];
 +
                        return self::ABORTED;
                }
  
  
        function processLogin() {
                global $wgMemc, $wgLang, $wgSecureLogin, $wgPasswordAttemptThrottle,
 -                      $wgInvalidPasswordReset;
 +                         $wgInvalidPasswordReset;
  
                switch ( $this->authenticateUserData() ) {
                        case self::SUCCESS:
                        case self::THROTTLED:
                                $error = $this->mAbortLoginErrorMsg ?: 'login-throttled';
                                $this->mainLoginForm( $this->msg( $error )
 -                              ->params ( $this->getLanguage()->formatDuration( $wgPasswordAttemptThrottle['seconds'] ) )
 -                              ->text()
 +                                      ->params( $this->getLanguage()->formatDuration( $wgPasswordAttemptThrottle['seconds'] ) )
 +                                      ->text()
                                );
                                break;
                        case self::USER_BLOCKED:
                                throw new PermissionsError( 'createaccount', $permErrors );
                        } elseif ( $user->isBlockedFromCreateAccount() ) {
                                $this->userBlockedMessage( $user->isBlockedFromCreateAccount() );
 +
                                return;
                        } elseif ( wfReadOnly() ) {
                                throw new ReadOnlyError;
         */
        function hasSessionCookie() {
                global $wgDisableCookieCheck;
 +
                return $wgDisableCookieCheck ? true : $this->getRequest()->checkSessionCookie();
        }
  
         */
        public static function getLoginToken() {
                global $wgRequest;
 +
                return $wgRequest->getSessionData( 'wsLoginToken' );
        }
  
         */
        public static function getCreateaccountToken() {
                global $wgRequest;
 +
                return $wgRequest->getSessionData( 'wsCreateaccountToken' );
        }
  
                                        $links[] = $this->makeLanguageSelectorLink( $parts[0], trim( $parts[1] ) );
                                }
                        }
 +
                        return count( $links ) > 0 ? $this->msg( 'loginlanguagelabel' )->rawParams(
                                $this->getLanguage()->pipeList( $links ) )->escaped() : '';
                } else {