RendererBubblingTest.php

<?php


/**
 * @file
 * Contains \Drupal\Tests\Core\Render\RendererBubblingTest.
 */
namespace Drupal\Tests\Core\Render;

use Drupal\Core\Cache\MemoryBackend;
use Drupal\Core\KeyValueStore\KeyValueMemoryFactory;
use Drupal\Core\Security\TrustedCallbackInterface;
use Drupal\Core\State\State;
use Drupal\Core\Cache\Cache;

/**
 * @coversDefaultClass \Drupal\Core\Render\Renderer
 * @group Render
 */
class RendererBubblingTest extends RendererTestBase {
    
    /**
     * {@inheritdoc}
     */
    protected function setUp() : void {
        // Disable the required cache contexts, so that this test can test just the
        // bubbling behavior.
        $this->rendererConfig['required_cache_contexts'] = [];
        parent::setUp();
    }
    
    /**
     * Tests bubbling of assets when NOT using #pre_render callbacks.
     */
    public function testBubblingWithoutPreRender() {
        $this->setUpRequest();
        $this->setupMemoryCache();
        $this->cacheContextsManager
            ->expects($this->any())
            ->method('convertTokensToKeys')
            ->willReturnArgument(0);
        // Create an element with a child and subchild. Each element loads a
        // different library using #attached.
        $element = [
            '#type' => 'container',
            '#cache' => [
                'keys' => [
                    'simpletest',
                    'renderer',
                    'children_attached',
                ],
            ],
            '#attached' => [
                'library' => [
                    'test/parent',
                ],
            ],
            '#title' => 'Parent',
        ];
        $element['child'] = [
            '#type' => 'container',
            '#attached' => [
                'library' => [
                    'test/child',
                ],
            ],
            '#title' => 'Child',
        ];
        $element['child']['subchild'] = [
            '#attached' => [
                'library' => [
                    'test/subchild',
                ],
            ],
            '#markup' => 'Subchild',
        ];
        // Render the element and verify the presence of #attached JavaScript.
        $this->renderer
            ->renderRoot($element);
        $expected_libraries = [
            'test/parent',
            'test/child',
            'test/subchild',
        ];
        $this->assertEquals($element['#attached']['library'], $expected_libraries, 'The element, child and subchild #attached libraries are included.');
        // Load the element from cache and verify the presence of the #attached
        // JavaScript.
        $element = [
            '#cache' => [
                'keys' => [
                    'simpletest',
                    'renderer',
                    'children_attached',
                ],
            ],
        ];
        // Verify that the element was retrieved from the cache.
        $this->assertNotEmpty($this->renderer
            ->renderRoot($element));
        $this->assertEquals($element['#attached']['library'], $expected_libraries, 'The element, child and subchild #attached libraries are included.');
    }
    
    /**
     * Tests cache context bubbling with a custom cache bin.
     */
    public function testContextBubblingCustomCacheBin() {
        $bin = $this->randomMachineName();
        $this->setUpRequest();
        $this->memoryCache = new MemoryBackend();
        $custom_cache = new MemoryBackend();
        $this->cacheFactory
            ->expects($this->atLeastOnce())
            ->method('get')
            ->with($bin)
            ->willReturnCallback(function ($requested_bin) use ($bin, $custom_cache) {
            if ($requested_bin === $bin) {
                return $custom_cache;
            }
            else {
                throw new \Exception();
            }
        });
        $this->cacheContextsManager
            ->expects($this->any())
            ->method('convertTokensToKeys')
            ->willReturnArgument(0);
        $build = [
            '#cache' => [
                'keys' => [
                    'parent',
                ],
                'contexts' => [
                    'foo',
                ],
                'bin' => $bin,
            ],
            '#markup' => 'parent',
            'child' => [
                '#cache' => [
                    'contexts' => [
                        'bar',
                    ],
                    'max-age' => 3600,
                ],
            ],
        ];
        $this->renderer
            ->renderRoot($build);
        $this->assertRenderCacheItem('parent:foo', [
            '#cache_redirect' => TRUE,
            '#cache' => [
                'keys' => [
                    'parent',
                ],
                'contexts' => [
                    'foo',
                    'bar',
                ],
                'tags' => [],
                'bin' => $bin,
                'max-age' => 3600,
            ],
        ], $bin);
    }
    
    /**
     * Tests cache context bubbling in edge cases, because it affects the CID.
     *
     * ::testBubblingWithPrerender() already tests the common case.
     *
     * @dataProvider providerTestContextBubblingEdgeCases
     */
    public function testContextBubblingEdgeCases(array $element, array $expected_top_level_contexts, array $expected_cache_items) {
        $this->setUpRequest();
        $this->setupMemoryCache();
        $this->cacheContextsManager
            ->expects($this->any())
            ->method('convertTokensToKeys')
            ->willReturnArgument(0);
        $this->renderer
            ->renderRoot($element);
        $this->assertEqualsCanonicalizing($expected_top_level_contexts, $element['#cache']['contexts'], 'Expected cache contexts found.');
        foreach ($expected_cache_items as $cid => $expected_cache_item) {
            $this->assertRenderCacheItem($cid, $expected_cache_item);
        }
    }
    public function providerTestContextBubblingEdgeCases() {
        $data = [];
        // Cache contexts of inaccessible children aren't bubbled (because those
        // children are not rendered at all).
        $test_element = [
            '#cache' => [
                'keys' => [
                    'parent',
                ],
                'contexts' => [],
            ],
            '#markup' => 'parent',
            'child' => [
                '#access' => FALSE,
                '#cache' => [
                    'contexts' => [
                        'foo',
                    ],
                ],
            ],
        ];
        $expected_cache_items = [
            'parent' => [
                '#attached' => [],
                '#cache' => [
                    'contexts' => [],
                    'tags' => [],
                    'max-age' => Cache::PERMANENT,
                ],
                '#markup' => 'parent',
            ],
        ];
        $data[] = [
            $test_element,
            [],
            $expected_cache_items,
        ];
        // Assert cache contexts are sorted when they are used to generate a CID.
        // (Necessary to ensure that different render arrays where the same keys +
        // set of contexts are present point to the same cache item. Regardless of
        // the contexts' order. A sad necessity because PHP doesn't have sets.)
        $test_element = [
            '#cache' => [
                'keys' => [
                    'set_test',
                ],
                'contexts' => [],
            ],
        ];
        $expected_cache_items = [
            'set_test:bar:baz:foo' => [
                '#attached' => [],
                '#cache' => [
                    'contexts' => [],
                    'tags' => [],
                    'max-age' => Cache::PERMANENT,
                ],
                '#markup' => '',
            ],
        ];
        $context_orders = [
            [
                'foo',
                'bar',
                'baz',
            ],
            [
                'foo',
                'baz',
                'bar',
            ],
            [
                'bar',
                'foo',
                'baz',
            ],
            [
                'bar',
                'baz',
                'foo',
            ],
            [
                'baz',
                'foo',
                'bar',
            ],
            [
                'baz',
                'bar',
                'foo',
            ],
        ];
        foreach ($context_orders as $context_order) {
            $test_element['#cache']['contexts'] = $context_order;
            $expected_cache_items['set_test:bar:baz:foo']['#cache']['contexts'] = $context_order;
            $data[] = [
                $test_element,
                $context_order,
                $expected_cache_items,
            ];
        }
        // A parent with a certain set of cache contexts is unaffected by a child
        // that has a subset of those contexts.
        $test_element = [
            '#cache' => [
                'keys' => [
                    'parent',
                ],
                'contexts' => [
                    'foo',
                    'bar',
                    'baz',
                ],
            ],
            '#markup' => 'parent',
            'child' => [
                '#cache' => [
                    'contexts' => [
                        'foo',
                        'baz',
                    ],
                    'max-age' => 3600,
                ],
            ],
        ];
        $expected_cache_items = [
            'parent:bar:baz:foo' => [
                '#attached' => [],
                '#cache' => [
                    'contexts' => [
                        'foo',
                        'bar',
                        'baz',
                    ],
                    'tags' => [],
                    'max-age' => 3600,
                ],
                '#markup' => 'parent',
            ],
        ];
        $data[] = [
            $test_element,
            [
                'bar',
                'baz',
                'foo',
            ],
            $expected_cache_items,
        ];
        // A parent with a certain set of cache contexts that is a subset of the
        // cache contexts of a child gets a redirecting cache item for the cache ID
        // created pre-bubbling (without the child's additional cache contexts). It
        // points to a cache item with a post-bubbling cache ID (i.e. with the
        // child's additional cache contexts).
        // Furthermore, the redirecting cache item also includes the children's
        // cache tags, since changes in the children may cause those children to get
        // different cache contexts and therefore cause different cache contexts to
        // be stored in the redirecting cache item.
        $test_element = [
            '#cache' => [
                'keys' => [
                    'parent',
                ],
                'contexts' => [
                    'foo',
                ],
                'tags' => [
                    'yar',
                    'har',
                ],
            ],
            '#markup' => 'parent',
            'child' => [
                '#cache' => [
                    'contexts' => [
                        'bar',
                    ],
                    'tags' => [
                        'fiddle',
                        'dee',
                    ],
                ],
                '#markup' => '',
            ],
        ];
        $expected_cache_items = [
            'parent:foo' => [
                '#cache_redirect' => TRUE,
                '#cache' => [
                    // The keys + contexts this redirects to.
'keys' => [
                        'parent',
                    ],
                    'contexts' => [
                        'foo',
                        'bar',
                    ],
                    'tags' => [
                        'yar',
                        'har',
                        'fiddle',
                        'dee',
                    ],
                    'bin' => 'render',
                    'max-age' => Cache::PERMANENT,
                ],
            ],
            'parent:bar:foo' => [
                '#attached' => [],
                '#cache' => [
                    'contexts' => [
                        'foo',
                        'bar',
                    ],
                    'tags' => [
                        'yar',
                        'har',
                        'fiddle',
                        'dee',
                    ],
                    'max-age' => Cache::PERMANENT,
                ],
                '#markup' => 'parent',
            ],
        ];
        $data[] = [
            $test_element,
            [
                'bar',
                'foo',
            ],
            $expected_cache_items,
        ];
        // Ensure that bubbleable metadata has been collected from children and set
        // correctly to the main level of the render array. That ensures that correct
        // bubbleable metadata exists if render array gets rendered multiple times.
        $test_element = [
            '#cache' => [
                'keys' => [
                    'parent',
                ],
                'tags' => [
                    'yar',
                    'har',
                ],
            ],
            '#markup' => 'parent',
            'child' => [
                '#render_children' => TRUE,
                'subchild' => [
                    '#cache' => [
                        'contexts' => [
                            'foo',
                        ],
                        'tags' => [
                            'fiddle',
                            'dee',
                        ],
                    ],
                    '#attached' => [
                        'library' => [
                            'foo/bar',
                        ],
                    ],
                    '#markup' => '',
                ],
            ],
        ];
        $expected_cache_items = [
            'parent:foo' => [
                '#attached' => [
                    'library' => [
                        'foo/bar',
                    ],
                ],
                '#cache' => [
                    'contexts' => [
                        'foo',
                    ],
                    'tags' => [
                        'yar',
                        'har',
                        'fiddle',
                        'dee',
                    ],
                    'max-age' => Cache::PERMANENT,
                ],
                '#markup' => 'parent',
            ],
        ];
        $data[] = [
            $test_element,
            [
                'foo',
            ],
            $expected_cache_items,
        ];
        return $data;
    }
    
    /**
     * Tests the self-healing of the redirect with conditional cache contexts.
     */
    public function testConditionalCacheContextBubblingSelfHealing() {
        $current_user_role =& $this->currentUserRole;
        $this->setUpRequest();
        $this->setupMemoryCache();
        $test_element = [
            '#cache' => [
                'keys' => [
                    'parent',
                ],
                'tags' => [
                    'a',
                ],
            ],
            '#markup' => 'parent',
            'child' => [
                '#cache' => [
                    'contexts' => [
                        'user.roles',
                    ],
                    'tags' => [
                        'b',
                    ],
                ],
                'grandchild' => [
                    '#access_callback' => function () use (&$current_user_role) {
                        // Only role A cannot access this subtree.
                        return $current_user_role !== 'A';
                    },
                    '#cache' => [
                        'contexts' => [
                            'foo',
                        ],
                        'tags' => [
                            'c',
                        ],
                        // A lower max-age; the redirecting cache item should be updated.
'max-age' => 1800,
                    ],
                    'grandgrandchild' => [
                        '#access_callback' => function () use (&$current_user_role) {
                            // Only role C can access this subtree.
                            return $current_user_role === 'C';
                        },
                        '#cache' => [
                            'contexts' => [
                                'bar',
                            ],
                            'tags' => [
                                'd',
                            ],
                            // A lower max-age; the redirecting cache item should be updated.
'max-age' => 300,
                        ],
                    ],
                ],
            ],
        ];
        // Request 1: role A, the grandchild isn't accessible => bubbled cache
        // contexts: user.roles.
        $element = $test_element;
        $current_user_role = 'A';
        $this->renderer
            ->renderRoot($element);
        $this->assertRenderCacheItem('parent', [
            '#cache_redirect' => TRUE,
            '#cache' => [
                'keys' => [
                    'parent',
                ],
                'contexts' => [
                    'user.roles',
                ],
                'tags' => [
                    'a',
                    'b',
                ],
                'bin' => 'render',
                'max-age' => Cache::PERMANENT,
            ],
        ]);
        $this->assertRenderCacheItem('parent:r.A', [
            '#attached' => [],
            '#cache' => [
                'contexts' => [
                    'user.roles',
                ],
                'tags' => [
                    'a',
                    'b',
                ],
                'max-age' => Cache::PERMANENT,
            ],
            '#markup' => 'parent',
        ]);
        // Request 2: role B, the grandchild is accessible => bubbled cache
        // contexts: foo, user.roles + merged max-age: 1800.
        $element = $test_element;
        $current_user_role = 'B';
        $this->renderer
            ->renderRoot($element);
        $this->assertRenderCacheItem('parent', [
            '#cache_redirect' => TRUE,
            '#cache' => [
                'keys' => [
                    'parent',
                ],
                'contexts' => [
                    'user.roles',
                    'foo',
                ],
                'tags' => [
                    'a',
                    'b',
                    'c',
                ],
                'bin' => 'render',
                'max-age' => 1800,
            ],
        ]);
        $this->assertRenderCacheItem('parent:foo:r.B', [
            '#attached' => [],
            '#cache' => [
                'contexts' => [
                    'user.roles',
                    'foo',
                ],
                'tags' => [
                    'a',
                    'b',
                    'c',
                ],
                'max-age' => 1800,
            ],
            '#markup' => 'parent',
        ]);
        // Request 3: role A again, the grandchild is inaccessible again => bubbled
        // cache contexts: user.roles; but that's a subset of the already-bubbled
        // cache contexts, so nothing is actually changed in the redirecting cache
        // item. However, the cache item we were looking for in request 1 is
        // technically the same one we're looking for now (it's the exact same
        // request), but with one additional cache context. This is necessary to
        // avoid "cache ping-pong". (Requests 1 and 3 are identical, but without the
        // right merging logic to handle request 2, the redirecting cache item would
        // toggle between only the 'user.roles' cache context and both the 'foo'
        // and 'user.roles' cache contexts, resulting in a cache miss every time.)
        $element = $test_element;
        $current_user_role = 'A';
        $this->renderer
            ->renderRoot($element);
        $this->assertRenderCacheItem('parent', [
            '#cache_redirect' => TRUE,
            '#cache' => [
                'keys' => [
                    'parent',
                ],
                'contexts' => [
                    'user.roles',
                    'foo',
                ],
                'tags' => [
                    'a',
                    'b',
                    'c',
                ],
                'bin' => 'render',
                'max-age' => 1800,
            ],
        ]);
        $this->assertRenderCacheItem('parent:foo:r.A', [
            '#attached' => [],
            '#cache' => [
                'contexts' => [
                    'user.roles',
                    'foo',
                ],
                'tags' => [
                    'a',
                    'b',
                ],
                // Note that the max-age here is unaffected. When role A, the grandchild
                // is never rendered, so neither is its max-age of 1800 present here,
                // despite 1800 being the max-age of the redirecting cache item.
'max-age' => Cache::PERMANENT,
            ],
            '#markup' => 'parent',
        ]);
        // Request 4: role C, both the grandchild and the grandgrandchild are
        // accessible => bubbled cache contexts: foo, bar, user.roles + merged
        // max-age: 300.
        $element = $test_element;
        $current_user_role = 'C';
        $this->renderer
            ->renderRoot($element);
        $final_parent_cache_item = [
            '#cache_redirect' => TRUE,
            '#cache' => [
                'keys' => [
                    'parent',
                ],
                'contexts' => [
                    'user.roles',
                    'foo',
                    'bar',
                ],
                'tags' => [
                    'a',
                    'b',
                    'c',
                    'd',
                ],
                'bin' => 'render',
                'max-age' => 300,
            ],
        ];
        $this->assertRenderCacheItem('parent', $final_parent_cache_item);
        $this->assertRenderCacheItem('parent:bar:foo:r.C', [
            '#attached' => [],
            '#cache' => [
                'contexts' => [
                    'user.roles',
                    'foo',
                    'bar',
                ],
                'tags' => [
                    'a',
                    'b',
                    'c',
                    'd',
                ],
                'max-age' => 300,
            ],
            '#markup' => 'parent',
        ]);
        // Request 5: role A again, verifying the merging like we did for request 3.
        $element = $test_element;
        $current_user_role = 'A';
        $this->renderer
            ->renderRoot($element);
        $this->assertRenderCacheItem('parent', $final_parent_cache_item);
        $this->assertRenderCacheItem('parent:bar:foo:r.A', [
            '#attached' => [],
            '#cache' => [
                'contexts' => [
                    'user.roles',
                    'foo',
                    'bar',
                ],
                'tags' => [
                    'a',
                    'b',
                ],
                // Note that the max-age here is unaffected. When role A, the grandchild
                // is never rendered, so neither is its max-age of 1800 present here,
                // nor the grandgrandchild's max-age of 300, despite 300 being the
                // max-age of the redirecting cache item.
'max-age' => Cache::PERMANENT,
            ],
            '#markup' => 'parent',
        ]);
        // Request 6: role B again, verifying the merging like we did for request 3.
        $element = $test_element;
        $current_user_role = 'B';
        $this->renderer
            ->renderRoot($element);
        $this->assertRenderCacheItem('parent', $final_parent_cache_item);
        $this->assertRenderCacheItem('parent:bar:foo:r.B', [
            '#attached' => [],
            '#cache' => [
                'contexts' => [
                    'user.roles',
                    'foo',
                    'bar',
                ],
                'tags' => [
                    'a',
                    'b',
                    'c',
                ],
                // Note that the max-age here is unaffected. When role B, the
                // grandgrandchild is never rendered, so neither is its max-age of 300
                // present here, despite 300 being the max-age of the redirecting cache
                // item.
'max-age' => 1800,
            ],
            '#markup' => 'parent',
        ]);
    }
    
    /**
     * Tests bubbling of bubbleable metadata added by #pre_render callbacks.
     *
     * @dataProvider providerTestBubblingWithPrerender
     */
    public function testBubblingWithPrerender($test_element) {
        $this->setUpRequest();
        $this->setupMemoryCache();
        // Mock the State service.
        $memory_state = new State(new KeyValueMemoryFactory());
        \Drupal::getContainer()->set('state', $memory_state);
        $this->controllerResolver
            ->expects($this->any())
            ->method('getControllerFromDefinition')
            ->willReturnArgument(0);
        // Simulate the theme system/Twig: a recursive call to Renderer::render(),
        // just like the theme system or a Twig template would have done.
        $this->themeManager
            ->expects($this->any())
            ->method('render')
            ->willReturnCallback(function ($hook, $vars) {
            return $this->renderer
                ->render($vars['foo']);
        });
        // ::bubblingPreRender() verifies that a #pre_render callback for a render
        // array that is cacheable and …
        // - … is cached does NOT get called. (Also mock a render cache item.)
        // - … is not cached DOES get called.
        \Drupal::state()->set('bubbling_nested_pre_render_cached', FALSE);
        \Drupal::state()->set('bubbling_nested_pre_render_uncached', FALSE);
        $this->memoryCache
            ->set('cached_nested', [
            '#markup' => 'Cached nested!',
            '#attached' => [],
            '#cache' => [
                'contexts' => [],
                'tags' => [],
            ],
        ]);
        // Simulate the rendering of an entire response (i.e. a root call).
        $output = $this->renderer
            ->renderRoot($test_element);
        // First, assert the render array is of the expected form.
        $this->assertEquals('Cache context!Cache tag!Asset!Placeholder!barquxNested!Cached nested!', trim($output), 'Expected HTML generated.');
        $this->assertEquals([
            'child.cache_context',
        ], $test_element['#cache']['contexts'], 'Expected cache contexts found.');
        $this->assertEquals([
            'child:cache_tag',
        ], $test_element['#cache']['tags'], 'Expected cache tags found.');
        $expected_attached = [
            'drupalSettings' => [
                'foo' => 'bar',
            ],
            'placeholders' => [],
        ];
        $this->assertEquals($expected_attached, $test_element['#attached'], 'Expected attachments found.');
        // Second, assert that #pre_render callbacks are only executed if they don't
        // have a render cache hit (and hence a #pre_render callback for a render
        // cached item cannot bubble more metadata).
        $this->assertTrue(\Drupal::state()->get('bubbling_nested_pre_render_uncached'));
        $this->assertFalse(\Drupal::state()->get('bubbling_nested_pre_render_cached'));
    }
    
    /**
     * Provides two test elements: one without, and one with the theme system.
     *
     * @return array
     */
    public function providerTestBubblingWithPrerender() {
        $data = [];
        // Test element without theme.
        $data[] = [
            [
                'foo' => [
                    '#pre_render' => [
                        __NAMESPACE__ . '\\BubblingTest::bubblingPreRender',
                    ],
                ],
            ],
        ];
        // Test element with theme.
        $data[] = [
            [
                '#theme' => 'common_test_render_element',
                'foo' => [
                    '#pre_render' => [
                        __NAMESPACE__ . '\\BubblingTest::bubblingPreRender',
                    ],
                ],
            ],
        ];
        return $data;
    }
    
    /**
     * Tests that an element's cache keys cannot be changed during its rendering.
     */
    public function testOverWriteCacheKeys() {
        $this->setUpRequest();
        $this->setupMemoryCache();
        // Ensure a logic exception
        $data = [
            '#cache' => [
                'keys' => [
                    'llama',
                    'bar',
                ],
            ],
            '#pre_render' => [
                __NAMESPACE__ . '\\BubblingTest::bubblingCacheOverwritePrerender',
            ],
        ];
        $this->expectException(\LogicException::class);
        $this->expectExceptionMessage('Cache keys may not be changed after initial setup. Use the contexts property instead to bubble additional metadata.');
        $this->renderer
            ->renderRoot($data);
    }

}
class BubblingTest implements TrustedCallbackInterface {
    
    /**
     * #pre_render callback for testBubblingWithPrerender().
     */
    public static function bubblingPreRender($elements) {
        $elements += [
            'child_cache_context' => [
                '#cache' => [
                    'contexts' => [
                        'child.cache_context',
                    ],
                ],
                '#markup' => 'Cache context!',
            ],
            'child_cache_tag' => [
                '#cache' => [
                    'tags' => [
                        'child:cache_tag',
                    ],
                ],
                '#markup' => 'Cache tag!',
            ],
            'child_asset' => [
                '#attached' => [
                    'drupalSettings' => [
                        'foo' => 'bar',
                    ],
                ],
                '#markup' => 'Asset!',
            ],
            'child_placeholder' => [
                '#create_placeholder' => TRUE,
                '#lazy_builder' => [
                    __CLASS__ . '::bubblingPlaceholder',
                    [
                        'bar',
                        'qux',
                    ],
                ],
            ],
            'child_nested_pre_render_uncached' => [
                '#cache' => [
                    'keys' => [
                        'uncached_nested',
                    ],
                ],
                '#pre_render' => [
                    __CLASS__ . '::bubblingNestedPreRenderUncached',
                ],
            ],
            'child_nested_pre_render_cached' => [
                '#cache' => [
                    'keys' => [
                        'cached_nested',
                    ],
                ],
                '#pre_render' => [
                    __CLASS__ . '::bubblingNestedPreRenderCached',
                ],
            ],
        ];
        return $elements;
    }
    
    /**
     * #pre_render callback for testBubblingWithPrerender().
     */
    public static function bubblingNestedPreRenderUncached($elements) {
        \Drupal::state()->set('bubbling_nested_pre_render_uncached', TRUE);
        $elements['#markup'] = 'Nested!';
        return $elements;
    }
    
    /**
     * #pre_render callback for testBubblingWithPrerender().
     */
    public static function bubblingNestedPreRenderCached($elements) {
        \Drupal::state()->set('bubbling_nested_pre_render_cached', TRUE);
        return $elements;
    }
    
    /**
     * #lazy_builder callback for testBubblingWithPrerender().
     */
    public static function bubblingPlaceholder($foo, $baz) {
        return [
            '#markup' => 'Placeholder!' . $foo . $baz,
        ];
    }
    
    /**
     * #pre_render callback for testOverWriteCacheKeys().
     */
    public static function bubblingCacheOverwritePrerender($elements) {
        // Overwrite the #cache entry with new data.
        $elements['#cache'] = [
            'keys' => [
                'llama',
                'foo',
            ],
        ];
        $elements['#markup'] = 'Setting cache keys just now!';
        return $elements;
    }
    
    /**
     * {@inheritdoc}
     */
    public static function trustedCallbacks() {
        return [
            'bubblingPreRender',
            'bubblingNestedPreRenderUncached',
            'bubblingNestedPreRenderCached',
            'bubblingPlaceholder',
            'bubblingCacheOverwritePrerender',
        ];
    }

}