Code Coverage for /Users/ericduran/Sites/drupal/drupal/core/lib/Drupal/Core/EventSubscriber/EarlyRenderingControllerWrapperSubscriber.php

	Code Coverage
	Classes and Traits			Functions and Methods				Lines
Total	0.00% covered (danger)	0.00%	0 / 1	0.00% covered (danger)	0.00%	0 / 5	CRAP	0.00% covered (danger)	0.00%	0 / 35
EarlyRenderingControllerWrapperSubscriber	0.00% covered (danger)	0.00%	0 / 1	0.00% covered (danger)	0.00%	0 / 5	156	0.00% covered (danger)	0.00%	0 / 35
__construct				0.00% covered (danger)	0.00%	0 / 1	2	0.00% covered (danger)	0.00%	0 / 3
onController				0.00% covered (danger)	0.00%	0 / 1	2	0.00% covered (danger)	0.00%	0 / 5
anonymous function				0.00% covered (danger)	0.00%	0 / 1	2	0.00% covered (danger)	0.00%	0 / 2
wrapControllerExecutionInRenderContext				0.00% covered (danger)	0.00%	0 / 1	72	0.00% covered (danger)	0.00%	0 / 1
getSubscribedEvents				0.00% covered (danger)	0.00%	0 / 1	2	0.00% covered (danger)	0.00%	0 / 3

1	<?php
2
3	/**
4	* @file
5	* Contains \Drupal\Core\EventSubscriber\EarlyRenderingControllerWrapperSubscriber.
6	*/
7
8	namespace Drupal\Core\EventSubscriber;
9
10	use Drupal\Core\Ajax\AjaxResponse;
11	use Drupal\Core\Cache\CacheableDependencyInterface;
12	use Drupal\Core\Cache\CacheableResponseInterface;
13	use Drupal\Core\Controller\ControllerResolverInterface;
14	use Drupal\Core\Render\AttachmentsInterface;
15	use Drupal\Core\Render\BubbleableMetadata;
16	use Drupal\Core\Render\RenderContext;
17	use Drupal\Core\Render\RendererInterface;
18	use Symfony\Component\EventDispatcher\EventSubscriberInterface;
19	use Symfony\Component\HttpKernel\Event\FilterControllerEvent;
20	use Symfony\Component\HttpKernel\KernelEvents;
21
22	/**
23	* Subscriber that wraps controllers, to handle early rendering.
24	*
25	* When controllers call drupal_render() (RendererInterface::render()) outside
26	* of a render context, we call that "early rendering". Controllers should
27	* return only render arrays, but we cannot prevent controllers from doing early
28	* rendering. The problem with early rendering is that the bubbleable metadata
29	* (cacheability & attachments) are lost.
30	*
31	* This can lead to broken pages (missing assets), stale pages (missing cache
32	* tags causing a page not to be invalidated) or even security problems (missing
33	* cache contexts causing a cached page not to be varied sufficiently).
34	*
35	* This event subscriber wraps all controller executions in a closure that sets
36	* up a render context. Consequently, any early rendering will have their
37	* bubbleable metadata (assets & cacheability) stored on that render context.
38	*
39	* If the render context is empty, then the controller either did not do any
40	* rendering at all, or used the RendererInterface::renderRoot() or
41	* ::renderPlain() methods. In that case, no bubbleable metadata is lost.
42	*
43	* If the render context is not empty, then the controller did use
44	* drupal_render(), and bubbleable metadata was collected. This bubbleable
45	* metadata is then merged onto the render array.
46	*
47	* In other words: this just exists to ease the transition to Drupal 8: it
48	* allows controllers that return render arrays (the majority) and
49	* \Drupal\Core\Ajax\AjaxResponse\AjaxResponse objects (a sizable minority that
50	* often involve a fair amount of rendering) to still do early rendering. But
51	* controllers that return any other kind of response are already expected to
52	* do the right thing, so if early rendering is detected in such a case, an
53	* exception is thrown.
54	*
55	* @see \Drupal\Core\Render\RendererInterface
56	* @see \Drupal\Core\Render\Renderer
57	*
58	* @todo Remove in Drupal 9.0.0, by disallowing early rendering.
59	*/
60	class EarlyRenderingControllerWrapperSubscriber implements EventSubscriberInterface {
61
62	/**
63	* The controller resolver.
64	*
65	* @var \Drupal\Core\Controller\ControllerResolverInterface
66	*/
67	protected $controllerResolver;
68
69	/**
70	* The renderer.
71	*
72	* @var \Drupal\Core\Render\RendererInterface
73	*/
74	protected $renderer;
75
76	/**
77	* Constructs a new EarlyRenderingControllerWrapperSubscriber instance.
78	*
79	* @param \Drupal\Core\Controller\ControllerResolverInterface $controller_resolver
80	* The controller resolver.
81	* @param \Drupal\Core\Render\RendererInterface $renderer
82	* The renderer.
83	*/
84	public function __construct(ControllerResolverInterface $controller_resolver, RendererInterface $renderer) {
85	$this->controllerResolver = $controller_resolver;
86	$this->renderer = $renderer;
87	}
88
89	/**
90	* Ensures bubbleable metadata from early rendering is not lost.
91	*
92	* @param \Symfony\Component\HttpKernel\Event\FilterControllerEvent $event
93	* The controller event.
94	*/
95	public function onController(FilterControllerEvent $event) {
96	$controller = $event->getController();
97
98	// See \Symfony\Component\HttpKernel\HttpKernel::handleRaw().
99	$arguments = $this->controllerResolver->getArguments($event->getRequest(), $controller);
100
101	$event->setController(function() use ($controller, $arguments) {
102	return $this->wrapControllerExecutionInRenderContext($controller, $arguments);
103	});
104	}
105
106	/**
107	* Wraps a controller execution in a render context.
108	*
109	* @param callable $controller
110	* The controller to execute.
111	* @param array $arguments
112	* The arguments to pass to the controller.
113	*
114	* @return mixed
115	* The return value of the controller.
116	*
117	* @throws \LogicException
118	* When early rendering has occurred in a controller that returned a
119	* Response or domain object that cares about attachments or cacheability.
120	*
121	* @see \Symfony\Component\HttpKernel\HttpKernel::handleRaw()
122	*/
123	protected function wrapControllerExecutionInRenderContext($controller, array $arguments) {
124	$context = new RenderContext();
125
126	$response = $this->renderer->executeInRenderContext($context, function() use ($controller, $arguments) {
127	// Now call the actual controller, just like HttpKernel does.
128	return call_user_func_array($controller, $arguments);
129	});
130
131	// If early rendering happened, i.e. if code in the controller called
132	// drupal_render() outside of a render context, then the bubbleable metadata
133	// for that is stored in the current render context.
134	if (!$context->isEmpty()) {
135	/** @var \Drupal\Core\Render\BubbleableMetadata $early_rendering_bubbleable_metadata */
136	$early_rendering_bubbleable_metadata = $context->pop();
137
138	// If a render array or AjaxResponse is returned by the controller, merge
139	// the "lost" bubbleable metadata.
140	if (is_array($response)) {
141	BubbleableMetadata::createFromRenderArray($response)
142	->merge($early_rendering_bubbleable_metadata)
143	->applyTo($response);
144	}
145	elseif ($response instanceof AjaxResponse) {
146	$response->addAttachments($early_rendering_bubbleable_metadata->getAttachments());
147	// @todo Make AjaxResponse cacheable in
148	// https://www.drupal.org/node/956186. Meanwhile, allow contrib
149	// subclasses to be.
150	if ($response instanceof CacheableResponseInterface) {
151	$response->addCacheableDependency($early_rendering_bubbleable_metadata);
152	}
153	}
154	// If a non-Ajax Response or domain object is returned and it cares about
155	// attachments or cacheability, then throw an exception: early rendering
156	// is not permitted in that case. It is the developer's responsibility
157	// to not use early rendering.
158	elseif ($response instanceof AttachmentsInterface \|\| $response instanceof CacheableResponseInterface \|\| $response instanceof CacheableDependencyInterface) {
159	throw new \LogicException(sprintf('The controller result claims to be providing relevant cache metadata, but leaked metadata was detected. Please ensure you are not rendering content too early. Returned object class: %s.', get_class($response)));
160	}
161	else {
162	// A Response or domain object is returned that does not care about
163	// attachments nor cacheability; for instance, a RedirectResponse. It is
164	// safe to discard any early rendering metadata.
165	}
166	}
167
168	return $response;
169	}
170
171	/**
172	* {@inheritdoc}
173	*/
174	public static function getSubscribedEvents() {
175	$events[KernelEvents::CONTROLLER][] = ['onController'];
176
177	return $events;
178	}
179
180	}