Merge pull request #5948 from nextcloud/remove-explicit-declaration

Remove explicit type hints for Controller

apps/federation/lib/Middleware/AddServerMiddleware.php

 	 * @return JSONResponse
 	 * @throws \Exception
 	 */
-	public function afterException(Controller $controller, $methodName, \Exception $exception) {
+	public function afterException($controller, $methodName, \Exception $exception) {
 		if (($controller instanceof SettingsController) === false) {
 			throw $exception;
 		}

apps/files_sharing/lib/Middleware/OCSShareAPIMiddleware.php

 	 *
 	 * @throws OCSNotFoundException
 	 */
-	public function beforeController(Controller $controller, $methodName) {
+	public function beforeController($controller, $methodName) {
 		if ($controller instanceof ShareAPIController) {
 			if (!$this->shareManager->shareApiEnabled()) {
 				throw new OCSNotFoundException($this->l->t('Share API is disabled'));
 	 * @param Response $response
 	 * @return Response
 	 */
-	public function afterController(Controller $controller, $methodName, Response $response) {
+	public function afterController($controller, $methodName, Response $response) {
 		if ($controller instanceof ShareAPIController) {
 			/** @var ShareAPIController $controller */
 			$controller->cleanup();

apps/files_sharing/lib/Middleware/SharingCheckMiddleware.php

 	 * @throws S2SException
 	 * @throws ShareNotFound
 	 */
-	public function beforeController(Controller $controller, $methodName) {
+	public function beforeController($controller, $methodName) {
 		if(!$this->isSharingEnabled()) {
 			throw new NotFoundException('Sharing is disabled.');
 		}
 	 * @return NotFoundResponse
 	 * @throws \Exception
 	 */
-	public function afterException(Controller $controller, $methodName, \Exception $exception) {
+	public function afterException($controller, $methodName, \Exception $exception) {
 		if(is_a($exception, '\OCP\Files\NotFoundException')) {
 			return new NotFoundResponse();
 		}

apps/provisioning_api/lib/Middleware/ProvisioningApiMiddleware.php

 	 *
 	 * @throws NotSubAdminException
 	 */
-	public function beforeController(Controller $controller, $methodName) {
+	public function beforeController($controller, $methodName) {
 		if (!$this->isAdmin && !$this->reflector->hasAnnotation('NoSubAdminRequired') && !$this->isSubAdmin) {
 			throw new NotSubAdminException();
 		}
 	 * @throws \Exception
 	 * @return Response
 	 */
-	public function afterException(Controller $controller, $methodName, \Exception $exception) {
+	public function afterException($controller, $methodName, \Exception $exception) {
 		if ($exception instanceof NotSubAdminException) {
 			throw new OCSException($exception->getMessage(), \OCP\API::RESPOND_UNAUTHORISED);
 		}

core/Middleware/TwoFactorMiddleware.php

 	 * @param Controller $controller
 	 * @param string $methodName
 	 */
-	public function beforeController(Controller $controller, $methodName) {
+	public function beforeController($controller, $methodName) {
 		if ($this->reflector->hasAnnotation('PublicPage')) {
 			// Don't block public pages
 			return;
 		}
 	}
 
-	public function afterException(Controller $controller, $methodName, Exception $exception) {
+	public function afterException($controller, $methodName, Exception $exception) {
 		if ($exception instanceof TwoFactorAuthRequiredException) {
 			$params = [];
 			if (isset($this->request->server['REQUEST_URI'])) {

lib/private/AppFramework/Middleware/OCSMiddleware.php

 	 * @param Controller $controller
 	 * @param string $methodName
 	 */
-	public function beforeController(Controller $controller, $methodName) {
+	public function beforeController($controller, $methodName) {
 		if ($controller instanceof OCSController) {
 			if (substr_compare($this->request->getScriptName(), '/ocs/v2.php', -strlen('/ocs/v2.php')) === 0) {
 				$this->ocsVersion = 2;
 	 * @throws \Exception
 	 * @return BaseResponse
 	 */
-	public function afterException(Controller $controller, $methodName, \Exception $exception) {
+	public function afterException($controller, $methodName, \Exception $exception) {
 		if ($controller instanceof OCSController && $exception instanceof OCSException) {
 			$code = $exception->getCode();
 			if ($code === 0) {
 	 * @param Response $response
 	 * @return \OCP\AppFramework\Http\Response
 	 */
-	public function afterController(Controller $controller, $methodName, Response $response) {
+	public function afterController($controller, $methodName, Response $response) {
 		/*
 		 * If a different middleware has detected that a request unauthorized or forbidden
 		 * we need to catch the response and convert it to a proper OCS response.

lib/private/AppFramework/Middleware/Security/BruteForceMiddleware.php

 	/**
 	 * {@inheritDoc}
 	 */
-	public function beforeController(Controller $controller, $methodName) {
+	public function beforeController($controller, $methodName) {
 		parent::beforeController($controller, $methodName);
 
 		if($this->reflector->hasAnnotation('BruteForceProtection')) {
 	/**
 	 * {@inheritDoc}
 	 */
-	public function afterController(Controller $controller, $methodName, Response $response) {
+	public function afterController($controller, $methodName, Response $response) {
 		if($this->reflector->hasAnnotation('BruteForceProtection') && $response->isThrottled()) {
 			$action = $this->reflector->getAnnotationParameter('BruteForceProtection', 'action');
 			$ip = $this->request->getRemoteAddress();

lib/private/AppFramework/Middleware/Security/CORSMiddleware.php

 	 * @throws SecurityException
 	 * @since 6.0.0
 	 */
-	public function beforeController(Controller $controller, $methodName){
+	public function beforeController($controller, $methodName){
 		// ensure that @CORS annotated API routes are not used in conjunction
 		// with session authentication since this enables CSRF attack vectors
 		if ($this->reflector->hasAnnotation('CORS') &&
 	 * @return Response a Response object
 	 * @throws SecurityException
 	 */
-	public function afterController(Controller $controller, $methodName, Response $response){
+	public function afterController($controller, $methodName, Response $response){
 		// only react if its a CORS request and if the request sends origin and
 
 		if(isset($this->request->server['HTTP_ORIGIN']) &&
 	 * @throws \Exception the passed in exception if it can't handle it
 	 * @return Response a Response object or null in case that the exception could not be handled
 	 */
-	public function afterException(Controller $controller, $methodName, \Exception $exception){
+	public function afterException($controller, $methodName, \Exception $exception){
 		if($exception instanceof SecurityException){
 			$response =  new JSONResponse(['message' => $exception->getMessage()]);
 			if($exception->getCode() !== 0) {

lib/private/AppFramework/Middleware/Security/RateLimitingMiddleware.php

 	 * {@inheritDoc}
 	 * @throws RateLimitExceededException
 	 */
-	public function beforeController(Controller $controller, $methodName) {
+	public function beforeController($controller, $methodName) {
 		parent::beforeController($controller, $methodName);
 
 		$anonLimit = $this->reflector->getAnnotationParameter('AnonRateThrottle', 'limit');
 	/**
 	 * {@inheritDoc}
 	 */
-	public function afterException(Controller $controller, $methodName, \Exception $exception) {
+	public function afterException($controller, $methodName, \Exception $exception) {
 		if($exception instanceof RateLimitExceededException) {
 			if (stripos($this->request->getHeader('Accept'),'html') === false) {
 				$response = new JSONResponse(

lib/private/AppFramework/Middleware/Security/SecurityMiddleware.php

 	 * @param string $methodName the name of the method
 	 * @throws SecurityException when a security check fails
 	 */
-	public function beforeController(Controller $controller, $methodName) {
+	public function beforeController($controller, $methodName) {
 
 		// this will set the current navigation entry of the app, use this only
 		// for normal HTML requests and not for AJAX requests
 	 * @param Response $response
 	 * @return Response
 	 */
-	public function afterController(Controller $controller, $methodName, Response $response) {
+	public function afterController($controller, $methodName, Response $response) {
 		$policy = !is_null($response->getContentSecurityPolicy()) ? $response->getContentSecurityPolicy() : new ContentSecurityPolicy();
 
 		if (get_class($policy) === EmptyContentSecurityPolicy::class) {
 	 * @throws \Exception the passed in exception if it can't handle it
 	 * @return Response a Response object or null in case that the exception could not be handled
 	 */
-	public function afterException(Controller $controller, $methodName, \Exception $exception) {
+	public function afterException($controller, $methodName, \Exception $exception) {
 		if($exception instanceof SecurityException) {
 			if($exception instanceof StrictCookieMissingException) {
 				return new RedirectResponse(\OC::$WEBROOT);

lib/private/AppFramework/Middleware/SessionMiddleware.php

 	 * @param Controller $controller
 	 * @param string $methodName
 	 */
-	public function beforeController(Controller $controller, $methodName) {
+	public function beforeController($controller, $methodName) {
 		$useSession = $this->reflector->hasAnnotation('UseSession');
 		if (!$useSession) {
 			$this->session->close();
 	 * @param Response $response
 	 * @return Response
 	 */
-	public function afterController(Controller $controller, $methodName, Response $response){
+	public function afterController($controller, $methodName, Response $response){
 		$useSession = $this->reflector->hasAnnotation('UseSession');
 		if ($useSession) {
 			$this->session->close();

lib/public/AppFramework/Middleware.php

 	 *                           the controller
 	 * @since 6.0.0
 	 */
-	public function beforeController(Controller $controller, $methodName){
+	public function beforeController($controller, $methodName){
 
 	}
 
 	 * @return Response a Response object in case that the exception was handled
 	 * @since 6.0.0
 	 */
-	public function afterException(Controller $controller, $methodName, \Exception $exception){
+	public function afterException($controller, $methodName, \Exception $exception){
 		throw $exception;
 	}
 
 	 * @return Response a Response object
 	 * @since 6.0.0
 	 */
-	public function afterController(Controller $controller, $methodName, Response $response){
+	public function afterController($controller, $methodName, Response $response){
 		return $response;
 	}
 
 	 * @return string the output that should be printed
 	 * @since 6.0.0
 	 */
-	public function beforeOutput(Controller $controller, $methodName, $output){
+	public function beforeOutput($controller, $methodName, $output){
 		return $output;
 	}
 

settings/Middleware/SubadminMiddleware.php

 	 * @param string $methodName
 	 * @throws \Exception
 	 */
-	public function beforeController(Controller $controller, $methodName) {
+	public function beforeController($controller, $methodName) {
 		if(!$this->reflector->hasAnnotation('NoSubadminRequired')) {
 			if(!$this->isSubAdmin) {
 				throw new NotAdminException('Logged in user must be a subadmin');
 	 * @return TemplateResponse
 	 * @throws \Exception
 	 */
-	public function afterException(Controller $controller, $methodName, \Exception $exception) {
+	public function afterException($controller, $methodName, \Exception $exception) {
 		if($exception instanceof NotAdminException) {
 			$response = new TemplateResponse('core', '403', array(), 'guest');
 			$response->setStatus(Http::STATUS_FORBIDDEN);

tests/lib/AppFramework/Middleware/MiddlewareDispatcherTest.php

 		$this->beforeControllerThrowsEx = $beforeControllerThrowsEx;
 	}
 
-	public function beforeController(Controller $controller, $methodName){
+	public function beforeController($controller, $methodName){
 		self::$beforeControllerCalled++;
 		$this->beforeControllerOrder = self::$beforeControllerCalled;
 		$this->controller = $controller;
 		}
 	}
 
-	public function afterException(Controller $controller, $methodName, \Exception $exception){
+	public function afterException($controller, $methodName, \Exception $exception){
 		self::$afterExceptionCalled++;
 		$this->afterExceptionOrder = self::$afterExceptionCalled;
 		$this->controller = $controller;
 		parent::afterException($controller, $methodName, $exception);
 	}
 
-	public function afterController(Controller $controller, $methodName, Response $response){
+	public function afterController($controller, $methodName, Response $response){
 		self::$afterControllerCalled++;
 		$this->afterControllerOrder = self::$afterControllerCalled;
 		$this->controller = $controller;
 		return parent::afterController($controller, $methodName, $response);
 	}
 
-	public function beforeOutput(Controller $controller, $methodName, $output){
+	public function beforeOutput($controller, $methodName, $output){
 		self::$beforeOutputCalled++;
 		$this->beforeOutputOrder = self::$beforeOutputCalled;
 		$this->controller = $controller;