DrupalKernel.php 23.7 KB
Newer Older
1
2
3
4
5
6
7
8
9
<?php

/**
 * @file
 * Definition of Drupal\Core\DrupalKernel.
 */

namespace Drupal\Core;

10
use Drupal\Core\PhpStorage\PhpStorageFactory;
11
use Drupal\Core\Config\BootstrapConfigStorageFactory;
12
use Drupal\Core\Config\NullStorage;
13
use Drupal\Core\CoreServiceProvider;
14
use Drupal\Core\DependencyInjection\ContainerBuilder;
15
use Drupal\Core\DependencyInjection\ServiceProviderInterface;
16
use Drupal\Core\DependencyInjection\YamlFileLoader;
17
use Drupal\Core\Extension\ExtensionDiscovery;
18
use Drupal\Core\Language\Language;
19
use Symfony\Component\Config\Loader\LoaderInterface;
20
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
21
use Symfony\Component\DependencyInjection\Dumper\PhpDumper;
22
23
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
24
use Symfony\Component\HttpKernel\HttpKernelInterface;
25
use Symfony\Component\HttpKernel\TerminableInterface;
26
use Composer\Autoload\ClassLoader;
27
28
29

/**
 * The DrupalKernel class is the core of Drupal itself.
30
31
 *
 * This class is responsible for building the Dependency Injection Container and
32
33
34
35
36
37
38
39
 * also deals with the registration of service providers. It allows registered
 * service providers to add their services to the container. Core provides the
 * CoreServiceProvider, which, in addition to registering any core services that
 * cannot be registered in the core.services.yaml file, adds any compiler passes
 * needed by core, e.g. for processing tagged services. Each module can add its
 * own service provider, i.e. a class implementing
 * Drupal\Core\DependencyInjection\ServiceProvider, to register services to the
 * container, or modify existing services.
40
 */
41
42
class DrupalKernel implements DrupalKernelInterface, TerminableInterface {

43
  const CONTAINER_BASE_CLASS = '\Drupal\Core\DependencyInjection\Container';
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

  /**
   * Holds the container instance.
   *
   * @var \Symfony\Component\DependencyInjection\ContainerInterface
   */
  protected $container;

  /**
   * The environment, e.g. 'testing', 'install'.
   *
   * @var string
   */
  protected $environment;

  /**
   * Whether the kernel has been booted.
   *
   * @var bool
   */
64
  protected $booted;
65

66
67
68
69
  /**
   * Holds the list of enabled modules.
   *
   * @var array
70
71
   *   An associative array whose keys are module names and whose values are
   *   ignored.
72
73
74
75
   */
  protected $moduleList;

  /**
76
   * Holds an updated list of enabled modules.
77
   *
78
79
80
81
82
83
84
   * @var array
   *   An associative array whose keys are module names and whose values are
   *   ignored.
   */
  protected $newModuleList;

  /**
85
   * List of available modules and installation profiles.
86
   *
87
   * @var \Drupal\Core\Extension\Extension[]
88
   */
89
  protected $moduleData = array();
90
91
92
93
94
95
96
97

  /**
   * PHP code storage object to use for the compiled container.
   *
   * @var \Drupal\Component\PhpStorage\PhpStorageInterface
   */
  protected $storage;

98
99
100
  /**
   * The classloader object.
   *
101
   * @var \Composer\Autoload\ClassLoader
102
103
104
   */
  protected $classLoader;

105
106
107
108
109
110
111
112
113
114
115
116
117
118
  /**
   * Config storage object used for reading enabled modules configuration.
   *
   * @var \Drupal\Core\Config\StorageInterface
   */
  protected $configStorage;

  /**
   * Whether the container can be dumped.
   *
   * @var bool
   */
  protected $allowDumping;

119
120
121
122
123
124
125
  /**
   * Whether the container can be loaded.
   *
   * @var bool
   */
  protected $allowLoading;

126
127
128
129
130
131
132
  /**
   * Whether the container needs to be dumped once booting is complete.
   *
   * @var bool
   */
  protected $containerNeedsDumping;

133
  /**
134
135
136
137
138
139
   * List of discovered services.yml pathnames.
   *
   * This is a nested array whose top-level keys are 'app' and 'site', denoting
   * the origin of a service provider. Site-specific providers have to be
   * collected separately, because they need to be processed last, so as to be
   * able to override services from application service providers.
140
141
142
143
144
   *
   * @var array
   */
  protected $serviceYamls;

145
  /**
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
   * List of discovered service provider class names.
   *
   * This is a nested array whose top-level keys are 'app' and 'site', denoting
   * the origin of a service provider. Site-specific providers have to be
   * collected separately, because they need to be processed last, so as to be
   * able to override services from application service providers.
   *
   * @var array
   */
  protected $serviceProviderClasses;

  /**
   * List of instantiated service provider classes.
   *
   * @see \Drupal\Core\DrupalKernel::$serviceProviderClasses
161
162
163
164
165
   *
   * @var array
   */
  protected $serviceProviders;

166
167
168
169
  /**
   * Constructs a DrupalKernel object.
   *
   * @param string $environment
170
171
172
   *   String indicating the environment, e.g. 'prod' or 'dev'. Used by
   *   Symfony\Component\HttpKernel\Kernel::__construct(). Drupal does not use
   *   this value currently. Pass 'prod'.
173
   * @param \Composer\Autoload\ClassLoader $class_loader
174
   *   (optional) The classloader is only used if $storage is not given or
175
176
   *   the load from storage fails and a container rebuild is required. In
   *   this case, the loaded modules will be registered with this loader in
177
   *   order to be able to find the module serviceProviders.
178
179
180
   * @param bool $allow_dumping
   *   (optional) FALSE to stop the container from being written to or read
   *   from disk. Defaults to TRUE.
181
182
183
   * @param bool $allow_loading
   *   (optional) FALSE to prevent the kernel attempting to read the dependency
   *   injection container from disk. Defaults to $allow_dumping.
184
   */
185
  public function __construct($environment, ClassLoader $class_loader, $allow_dumping = TRUE, $allow_loading = NULL) {
186
    $this->environment = $environment;
187
    $this->booted = FALSE;
188
    $this->classLoader = $class_loader;
189
    $this->allowDumping = $allow_dumping;
190
    $this->allowLoading = isset($allow_loading) ? $allow_loading : $allow_dumping;
191
192
  }

193
  /**
194
   * {@inheritdoc}
195
196
197
   */
  public function boot() {
    if ($this->booted) {
198
      return;
199
    }
200
201
    $this->initializeContainer();
    $this->booted = TRUE;
202
203
204
    if ($this->containerNeedsDumping && !$this->dumpDrupalContainer($this->container, static::CONTAINER_BASE_CLASS)) {
      watchdog('DrupalKernel', 'Container cannot be written to disk');
    }
205
206
  }

207
  /**
208
   * {@inheritdoc}
209
   */
210
211
212
213
214
  public function shutdown() {
    if (FALSE === $this->booted) {
      return;
    }
    $this->booted = FALSE;
215
    $this->container = NULL;
216
217
218
219
220
221
222
223
224
225
226
227
228
  }

  /**
   * {@inheritdoc}
   */
  public function getContainer() {
    return $this->container;
  }

  /**
   * {@inheritdoc}
   */
  public function discoverServiceProviders() {
229
    $this->serviceYamls = array(
230
231
      'app' => array(),
      'site' => array(),
232
    );
233
234
235
236
237
238
    $this->serviceProviderClasses = array(
      'app' => array(),
      'site' => array(),
    );
    $this->serviceYamls['app']['core'] = 'core/core.services.yml';
    $this->serviceProviderClasses['app']['core'] = 'Drupal\Core\CoreServiceProvider';
239

240
    // Retrieve enabled modules and register their namespaces.
241
    if (!isset($this->moduleList)) {
242
243
      $extensions = $this->getConfigStorage()->read('core.extension');
      $this->moduleList = isset($extensions['module']) ? $extensions['module'] : array();
244
    }
245
    $module_filenames = $this->getModuleFileNames();
246
    $this->classLoaderAddMultiplePsr4($this->getModuleNamespacesPsr4($module_filenames));
247

248
    // Load each module's serviceProvider class.
249
    foreach ($this->moduleList as $module => $weight) {
katbailey's avatar
katbailey committed
250
      $camelized = ContainerBuilder::camelize($module);
251
252
      $name = "{$camelized}ServiceProvider";
      $class = "Drupal\\{$module}\\{$name}";
253
      if (class_exists($class)) {
254
        $this->serviceProviderClasses['app'][$module] = $class;
255
      }
256
      $filename = dirname($module_filenames[$module]) . "/$module.services.yml";
257
      if (file_exists($filename)) {
258
        $this->serviceYamls['app'][$module] = $filename;
259
      }
260
    }
261

262
    // Add site-specific service providers.
263
    if (!empty($GLOBALS['conf']['container_service_providers'])) {
264
265
266
267
      foreach ($GLOBALS['conf']['container_service_providers'] as $class) {
        if (class_exists($class)) {
          $this->serviceProviderClasses['site'][] = $class;
        }
268
269
      }
    }
270
    if (!empty($GLOBALS['conf']['container_yamls'])) {
271
272
      $this->serviceYamls['site'] = $GLOBALS['conf']['container_yamls'];
    }
273
    if (file_exists($site_services_yml = conf_path() . '/services.yml')) {
274
      $this->serviceYamls['site'][] = $site_services_yml;
275
    }
276
277
278
279
280
  }

  /**
   * {@inheritdoc}
   */
281
282
  public function getServiceProviders($origin) {
    return $this->serviceProviders[$origin];
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
  }

  /**
   * {@inheritdoc}
   */
  public function terminate(Request $request, Response $response) {
    if (FALSE === $this->booted) {
      return;
    }

    if ($this->getHttpKernel() instanceof TerminableInterface) {
      $this->getHttpKernel()->terminate($request, $response);
    }
  }

  /**
   * {@inheritdoc}
   */
301
302
303
304
  public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = TRUE) {
    if (FALSE === $this->booted) {
      $this->boot();
    }
305

306
    return $this->getHttpKernel()->handle($request, $type, $catch);
307
308
  }

309
310
311
312
313
314
  /**
   * Returns module data on the filesystem.
   *
   * @param $module
   *   The name of the module.
   *
315
316
   * @return \Drupal\Core\Extension\Extension|bool
   *   Returns an Extension object if the module is found, FALSE otherwise.
317
318
319
   */
  protected function moduleData($module) {
    if (!$this->moduleData) {
320
      // First, find profiles.
321
322
323
324
325
      $listing = new ExtensionDiscovery();
      $listing->setProfileDirectories(array());
      $all_profiles = $listing->scan('profile');
      $profiles = array_intersect_key($all_profiles, $this->moduleList);

326
327
      // If a module is within a profile directory but specifies another
      // profile for testing, it needs to be found in the parent profile.
328
      $settings = $this->getConfigStorage()->read('simpletest.settings');
329
330
      $parent_profile = !empty($settings['parent_profile']) ? $settings['parent_profile'] : NULL;
      if ($parent_profile && !isset($profiles[$parent_profile])) {
331
332
        // In case both profile directories contain the same extension, the
        // actual profile always has precedence.
333
        $profiles = array($parent_profile => $all_profiles[$parent_profile]) + $profiles;
334
      }
335
336
337
338
339
340

      $profile_directories = array_map(function ($profile) {
        return $profile->getPath();
      }, $profiles);
      $listing->setProfileDirectories($profile_directories);

341
      // Now find modules.
342
      $this->moduleData = $profiles + $listing->scan('module');
343
344
345
346
    }
    return isset($this->moduleData[$module]) ? $this->moduleData[$module] : FALSE;
  }

347
348
  /**
   * Implements Drupal\Core\DrupalKernelInterface::updateModules().
349
350
351
   *
   * @todo Remove obsolete $module_list parameter. Only $module_filenames is
   *   needed.
352
   */
353
  public function updateModules(array $module_list, array $module_filenames = array()) {
354
    $this->newModuleList = $module_list;
355
356
    foreach ($module_filenames as $name => $extension) {
      $this->moduleData[$name] = $extension;
357
    }
358
359
360
361
362
363

    // This method is called whenever the list of modules changed. Therefore
    // disable loading of a dumped container from the disk, because it is
    // guaranteed to be out of date and needs to be rebuilt anyway.
    $this->allowLoading = FALSE;

364
365
    // If we haven't yet booted, we don't need to do anything: the new module
    // list will take effect when boot() is called. If we have already booted,
366
    // then reboot in order to refresh the serviceProvider list and container.
367
368
369
370
371
    if ($this->booted) {
      $this->booted = FALSE;
      $this->boot();
    }
  }
372

373
  /**
374
   * Returns the classname based on environment.
375
376
377
378
379
   *
   * @return string
   *   The class name.
   */
  protected function getClassName() {
380
    $parts = array('service_container', $this->environment);
381
382
383
    return implode('_', $parts);
  }

384
385
386
387
388
389
390
391
392
393
394
395

  /**
   * Returns the kernel parameters.
   *
   * @return array An array of kernel parameters
   */
  protected function getKernelParameters() {
    return array(
      'kernel.environment' => $this->environment,
    );
  }

396
397
398
  /**
   * Initializes the service container.
   */
399
  protected function initializeContainer() {
400
    $this->containerNeedsDumping = FALSE;
401
    $persist = $this->getServicesToPersist();
402
    // The request service requires custom persisting logic, since it is also
403
    // potentially scoped.
404
405
406
407
408
409
410
411
    $request_scope = FALSE;
    if (isset($this->container)) {
      if ($this->container->isScopeActive('request')) {
        $request_scope = TRUE;
      }
      if ($this->container->initialized('request')) {
        $request = $this->container->get('request');
      }
412
    }
413
    $this->container = NULL;
414
415
416
    $class = $this->getClassName();
    $cache_file = $class . '.php';

417
    if ($this->allowLoading) {
418
419
      // First, try to load.
      if (!class_exists($class, FALSE)) {
420
        $this->storage()->load($cache_file);
421
422
423
424
425
      }
      // If the load succeeded or the class already existed, use it.
      if (class_exists($class, FALSE)) {
        $fully_qualified_class_name = '\\' . $class;
        $this->container = new $fully_qualified_class_name;
426
        $this->persistServices($persist);
427
428
      }
    }
429
430
431
432
433
434
435
436
437
    // First check whether the list of modules changed in this request.
    if (isset($this->newModuleList)) {
      if (isset($this->container) && isset($this->moduleList) && array_keys($this->moduleList) !== array_keys($this->newModuleList)) {
        unset($this->container);
      }
      $this->moduleList = $this->newModuleList;
      unset($this->newModuleList);
    }
    if (isset($this->container)) {
438
439
      // All namespaces must be registered before we attempt to use any service
      // from the container.
440
      $this->classLoaderAddMultiplePsr4($this->container->getParameter('container.namespaces'));
441
    }
442
    else {
443
      $this->container = $this->buildContainer();
444
      $this->persistServices($persist);
445
446
447
448
449
450
451
452

      // The namespaces are marked as persistent, so objects like the annotated
      // class discovery still has the right object. We may have updated the
      // list of modules, so set it.
      if ($this->container->initialized('container.namespaces')) {
        $this->container->get('container.namespaces')->exchangeArray($this->container->getParameter('container.namespaces'));
      }

453
454
      if ($this->allowDumping) {
        $this->containerNeedsDumping = TRUE;
455
456
457
      }
    }

458
    $this->container->set('kernel', $this);
459

460
461
    // Set the class loader which was registered as a synthetic service.
    $this->container->set('class_loader', $this->classLoader);
462
    // If we have a request set it back to the new container.
463
    if ($request_scope) {
464
      $this->container->enterScope('request');
465
466
    }
    if (isset($request)) {
467
468
      $this->container->set('request', $request);
    }
469
    \Drupal::setContainer($this->container);
470
  }
471

472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
  /**
   * Returns service instances to persist from an old container to a new one.
   */
  protected function getServicesToPersist() {
    $persist = array();
    if (isset($this->container)) {
      foreach ($this->container->getParameter('persistIds') as $id) {
        // It's pointless to persist services not yet initialized.
        if ($this->container->initialized($id)) {
          $persist[$id] = $this->container->get($id);
        }
      }
    }
    return $persist;
  }

  /**
   * Moves persistent service instances into a new container.
   */
  protected function persistServices(array $persist) {
    foreach ($persist as $id => $object) {
      // Do not override services already set() on the new container, for
      // example 'service_container'.
      if (!$this->container->initialized($id)) {
        $this->container->set($id, $object);
      }
    }
  }

501
502
503
504
505
  /**
   * Builds the service container.
   *
   * @return ContainerBuilder The compiled service container
   */
506
  protected function buildContainer() {
507
    $this->initializeServiceProviders();
508
    $container = $this->getContainerBuilder();
509
    $container->set('kernel', $this);
510
    $container->setParameter('container.modules', $this->getModulesParameter());
511
512

    // Get a list of namespaces and put it onto the container.
513
    $namespaces = $this->getModuleNamespacesPsr4($this->getModuleFileNames());
514
515
516
517
    // Add all components in \Drupal\Core and \Drupal\Component that have a
    // Plugin directory.
    foreach (array('Core', 'Component') as $parent_directory) {
      $path = DRUPAL_ROOT . '/core/lib/Drupal/' . $parent_directory;
518
      $parent_namespace = 'Drupal\\' . $parent_directory;
519
      foreach (new \DirectoryIterator($path) as $component) {
520
        if (!$component->isDot() && $component->isDir() && is_dir($component->getPathname() . '/Plugin')) {
521
          $namespaces[$parent_namespace . '\\' . $component->getFilename()] = $path . '/' . $component->getFilename();
522
523
524
        }
      }
    }
525
526
    $container->setParameter('container.namespaces', $namespaces);

527
528
529
530
531
532
    // Store the default language values on the container. This is so that the
    // default language can be configured using the configuration factory. This
    // avoids the circular dependencies that would created by
    // \Drupal\language\LanguageServiceProvider::alter() and allows the default
    // language to not be English in the installer.
    $default_language_values = Language::$defaultValues;
533
534
535
536
    if ($system = $this->getConfigStorage()->read('system.site')) {
      if ($default_language_values['id'] != $system['langcode']) {
        $default_language_values = array('id' => $system['langcode'], 'default' => TRUE);
      }
537
538
539
    }
    $container->setParameter('language.default_values', $default_language_values);

540
    // Register synthetic services.
541
    $container->register('class_loader')->setSynthetic(TRUE);
542
543
    $container->register('kernel', 'Symfony\Component\HttpKernel\KernelInterface')->setSynthetic(TRUE);
    $container->register('service_container', 'Symfony\Component\DependencyInjection\ContainerInterface')->setSynthetic(TRUE);
544
545

    // Register application services.
546
    $yaml_loader = new YamlFileLoader($container);
547
548
549
550
551
552
553
554
555
556
    foreach ($this->serviceYamls['app'] as $filename) {
      $yaml_loader->load($filename);
    }
    foreach ($this->serviceProviders['app'] as $provider) {
      if ($provider instanceof ServiceProviderInterface) {
        $provider->register($container);
      }
    }
    // Register site-specific service overrides.
    foreach ($this->serviceYamls['site'] as $filename) {
557
558
      $yaml_loader->load($filename);
    }
559
    foreach ($this->serviceProviders['site'] as $provider) {
560
561
562
      if ($provider instanceof ServiceProviderInterface) {
        $provider->register($container);
      }
563
    }
564
565
566
567
568
569
570
571
572
573
574
575
576

    // Identify all services whose instances should be persisted when rebuilding
    // the container during the lifetime of the kernel (e.g., during a kernel
    // reboot). Include synthetic services, because by definition, they cannot
    // be automatically reinstantiated. Also include services tagged to persist.
    $persist_ids = array();
    foreach ($container->getDefinitions() as $id => $definition) {
      if ($definition->isSynthetic() || $definition->getTag('persist')) {
        $persist_ids[] = $id;
      }
    }
    $container->setParameter('persistIds', $persist_ids);

577
    $container->compile();
578
579
    return $container;
  }
580

581
582
583
584
585
586
  /**
   * Registers all service providers to the kernel.
   *
   * @throws \LogicException
   */
  protected function initializeServiceProviders() {
587
588
589
590
591
592
593
594
    $this->discoverServiceProviders();
    $this->serviceProviders = array(
      'app' => array(),
      'site' => array(),
    );
    foreach ($this->serviceProviderClasses as $origin => $classes) {
      foreach ($classes as $name => $class) {
        $this->serviceProviders[$origin][$name] = new $class;
595
596
597
598
      }
    }
  }

599
600
601
602
603
  /**
   * Gets a new ContainerBuilder instance used to build the service container.
   *
   * @return ContainerBuilder
   */
604
  protected function getContainerBuilder() {
605
606
607
    return new ContainerBuilder(new ParameterBag($this->getKernelParameters()));
  }

608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
  /**
   * Dumps the service container to PHP code in the config directory.
   *
   * This method is based on the dumpContainer method in the parent class, but
   * that method is reliant on the Config component which we do not use here.
   *
   * @param ContainerBuilder $container
   *   The service container.
   * @param string $baseClass
   *   The name of the container's base class
   *
   * @return bool
   *   TRUE if the container was successfully dumped to disk.
   */
  protected function dumpDrupalContainer(ContainerBuilder $container, $baseClass) {
623
    if (!$this->storage()->writeable()) {
624
625
626
627
      return FALSE;
    }
    // Cache the container.
    $dumper = new PhpDumper($container);
628
629
    $class = $this->getClassName();
    $content = $dumper->dump(array('class' => $class, 'base_class' => $baseClass));
630
    return $this->storage()->save($class . '.php', $content);
631
632
  }

633
634
635
636

  /**
   * Gets a http kernel from the container
   *
637
   * @return HttpKernel
638
639
640
641
642
   */
  protected function getHttpKernel() {
    return $this->container->get('http_kernel');
  }

643
644
645
646
647
648
649
650
651
652
653
654
  /**
   * Gets the PHP code storage object to use for the compiled container.
   *
   * @return \Drupal\Component\PhpStorage\PhpStorageInterface
   */
  protected function storage() {
    if (!isset($this->storage)) {
      $this->storage = PhpStorageFactory::get('service_container');
    }
    return $this->storage;
  }

655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
  /**
   * Returns the active configuration storage to use during building the container.
   *
   * @return \Drupal\Core\Config\StorageInterface
   */
  protected function getConfigStorage() {
    if (!isset($this->configStorage)) {
      // The active configuration storage may not exist yet; e.g., in the early
      // installer. Catch the exception thrown by config_get_config_directory().
      try {
        $this->configStorage = BootstrapConfigStorageFactory::get();
      }
      catch (\Exception $e) {
        $this->configStorage = new NullStorage();
      }
    }
    return $this->configStorage;
  }

674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
  /**
   * Returns an array of Extension class parameters for all enabled modules.
   *
   * @return array
   */
  protected function getModulesParameter() {
    $extensions = array();
    foreach ($this->moduleList as $name => $weight) {
      if ($data = $this->moduleData($name)) {
        $extensions[$name] = array(
          'type' => $data->getType(),
          'pathname' => $data->getPathname(),
          'filename' => $data->getExtensionFilename(),
        );
      }
    }
    return $extensions;
  }

693
  /**
694
695
696
697
698
   * Gets the file name for each enabled module.
   *
   * @return array
   *   Array where each key is a module name, and each value is a path to the
   *   respective *.module or *.profile file.
699
700
701
702
703
   */
  protected function getModuleFileNames() {
    $filenames = array();
    foreach ($this->moduleList as $module => $weight) {
      if ($data = $this->moduleData($module)) {
704
        $filenames[$module] = $data->getPathname();
705
706
707
708
709
      }
    }
    return $filenames;
  }

710
711
712
  /**
   * Gets the PSR-4 base directories for module namespaces.
   *
713
   * @param string[] $module_file_names
714
715
716
   *   Array where each key is a module name, and each value is a path to the
   *   respective *.module or *.profile file.
   *
717
   * @return string[]
718
   *   Array where each key is a module namespace like 'Drupal\system', and each
719
   *   value is the PSR-4 base directory associated with the module namespace.
720
721
722
723
   */
  protected function getModuleNamespacesPsr4($module_file_names) {
    $namespaces = array();
    foreach ($module_file_names as $module => $filename) {
724
      $namespaces["Drupal\\$module"] = DRUPAL_ROOT . '/' . dirname($filename) . '/src';
725
726
727
728
    }
    return $namespaces;
  }

729
730
731
732
733
734
735
736
  /**
   * Registers a list of namespaces with PSR-4 directories for class loading.
   *
   * @param array $namespaces
   *   Array where each key is a namespace like 'Drupal\system', and each value
   *   is either a PSR-4 base directory, or an array of PSR-4 base directories
   *   associated with this namespace.
   */
737
  protected function classLoaderAddMultiplePsr4(array $namespaces = array()) {
738
739
740
741
742
    foreach ($namespaces as $prefix => $paths) {
      $this->classLoader->addPsr4($prefix . '\\', $paths);
    }
  }

743
}