updated core from 8.4 to 8.5 : bug with login_destination

core/modules/serialization/src/Encoder/JsonEncoder.php

@@ -10,6 +10,10 @@ use Symfony\Component\Serializer\Encoder\JsonEncoder as BaseJsonEncoder;
 
 /**
  * Adds 'ajax to the supported content types of the JSON encoder'
+ *
+ * @internal
+ *   This encoder should not be used directly. Rather, use the `serializer`
+ *   service.
  */
 class JsonEncoder extends BaseJsonEncoder implements EncoderInterface, DecoderInterface {
 

core/modules/serialization/src/Encoder/XmlEncoder.php

@@ -12,6 +12,10 @@ use Symfony\Component\Serializer\Encoder\XmlEncoder as BaseXmlEncoder;
  *
  * This acts as a wrapper class for Symfony's XmlEncoder so that it is not
  * implementing NormalizationAwareInterface, and can be normalized externally.
+ *
+ * @internal
+ *   This encoder should not be used directly. Rather, use the `serializer`
+ *   service.
  */
 class XmlEncoder extends SerializerAwareEncoder implements EncoderInterface, DecoderInterface {
 

core/modules/serialization/src/EventSubscriber/DefaultExceptionSubscriber.php

@@ -2,6 +2,8 @@
 
 namespace Drupal\serialization\EventSubscriber;
 
+use Drupal\Core\Cache\CacheableDependencyInterface;
+use Drupal\Core\Cache\CacheableResponse;
 use Drupal\Core\EventSubscriber\HttpExceptionSubscriberBase;
 use Symfony\Component\HttpFoundation\Response;
 use Symfony\Component\HttpKernel\Event\GetResponseForExceptionEvent;
@@ -51,8 +53,12 @@ class DefaultExceptionSubscriber extends HttpExceptionSubscriberBase {
    */
   protected static function getPriority() {
     // This will fire after the most common HTML handler, since HTML requests
-    // are still more common than HTTP requests.
-    return -75;
+    // are still more common than HTTP requests. But it has a lower priority
+    // than \Drupal\Core\EventSubscriber\ExceptionJsonSubscriber::on4xx(), so
+    // that this also handles the 'json' format. Then all serialization formats
+    // (::getHandledFormats()) are handled by this exception subscriber, which
+    // results in better consistency.
+    return -70;
   }
 
   /**
@@ -67,14 +73,22 @@ class DefaultExceptionSubscriber extends HttpExceptionSubscriberBase {
     $request = $event->getRequest();
 
     $format = $request->getRequestFormat();
-    $content = ['message' => $event->getException()->getMessage()];
+    $content = ['message' => $exception->getMessage()];
     $encoded_content = $this->serializer->serialize($content, $format);
     $headers = $exception->getHeaders();
 
     // Add the MIME type from the request to send back in the header.
     $headers['Content-Type'] = $request->getMimeType($format);
 
-    $response = new Response($encoded_content, $exception->getStatusCode(), $headers);
+    // If the exception is cacheable, generate a cacheable response.
+    if ($exception instanceof CacheableDependencyInterface) {
+      $response = new CacheableResponse($encoded_content, $exception->getStatusCode(), $headers);
+      $response->addCacheableDependency($exception);
+    }
+    else {
+      $response = new Response($encoded_content, $exception->getStatusCode(), $headers);
+    }
+
     $event->setResponse($response);
   }
 

core/modules/serialization/src/Normalizer/CacheableNormalizerInterface.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Drupal\serialization\Normalizer;
+
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+
+/**
+ * Defines the interface for normalizers producing cacheable normalizations.
+ *
+ * @see cache
+ */
+interface CacheableNormalizerInterface extends NormalizerInterface {
+
+  /**
+   * Name of key for bubbling cacheability metadata via serialization context.
+   *
+   * @see \Symfony\Component\Serializer\Normalizer\NormalizerInterface::normalize()
+   * @see \Symfony\Component\Serializer\SerializerInterface::serialize()
+   * @see \Drupal\rest\EventSubscriber\ResourceResponseSubscriber::renderResponseBody()
+   */
+  const SERIALIZATION_CONTEXT_CACHEABILITY = 'cacheability';
+
+}

core/modules/serialization/src/Normalizer/ComplexDataNormalizer.php

@@ -2,6 +2,9 @@
 
 namespace Drupal\serialization\Normalizer;
 
+use Drupal\Core\TypedData\ComplexDataInterface;
+use Drupal\Core\TypedData\TypedDataInternalPropertiesHelper;
+
 /**
  * Converts the Drupal entity object structures to a normalized array.
  *
@@ -26,6 +29,13 @@ class ComplexDataNormalizer extends NormalizerBase {
    */
   public function normalize($object, $format = NULL, array $context = []) {
     $attributes = [];
+    // $object will not always match $supportedInterfaceOrClass.
+    // @see \Drupal\serialization\Normalizer\EntityNormalizer
+    // Other normalizers that extend this class may only provide $object that
+    // implements \Traversable.
+    if ($object instanceof ComplexDataInterface) {
+      $object = TypedDataInternalPropertiesHelper::getNonInternalProperties($object);
+    }
     /** @var \Drupal\Core\TypedData\TypedDataInterface $property */
     foreach ($object as $name => $property) {
       $attributes[$name] = $this->serializer->normalize($property, $format, $context);

core/modules/serialization/src/Normalizer/ConfigEntityNormalizer.php

@@ -18,7 +18,33 @@ class ConfigEntityNormalizer extends EntityNormalizer {
    * {@inheritdoc}
    */
   public function normalize($object, $format = NULL, array $context = []) {
-    return $object->toArray();
+    return static::getDataWithoutInternals($object->toArray());
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function denormalize($data, $class, $format = NULL, array $context = []) {
+    return parent::denormalize(static::getDataWithoutInternals($data), $class, $format, $context);
+  }
+
+  /**
+   * Gets the given data without the internal implementation details.
+   *
+   * @param array $data
+   *   The data that is either currently or about to be stored in configuration.
+   *
+   * @return array
+   *   The same data, but without internals. Currently, that is only the '_core'
+   *   key, which is reserved by Drupal core to handle complex edge cases
+   *   correctly. Data in the '_core' key is irrelevant to clients reading
+   *   configuration, and is not allowed to be set by clients writing
+   *   configuration: it is for Drupal core only, and managed by Drupal core.
+   *
+   * @see https://www.drupal.org/node/2653358
+   */
+  protected static function getDataWithoutInternals(array $data) {
+    return array_diff_key($data, ['_core' => TRUE]);
   }
 
 }

core/modules/serialization/src/Normalizer/ContentEntityNormalizer.php

@@ -2,6 +2,8 @@
 
 namespace Drupal\serialization\Normalizer;
 
+use Drupal\Core\TypedData\TypedDataInternalPropertiesHelper;
+
 /**
  * Normalizes/denormalizes Drupal content entities into an array structure.
  */
@@ -21,7 +23,8 @@ class ContentEntityNormalizer extends EntityNormalizer {
     ];
 
     $attributes = [];
-    foreach ($entity as $name => $field_items) {
+    /** @var \Drupal\Core\Entity\Entity $entity */
+    foreach (TypedDataInternalPropertiesHelper::getNonInternalProperties($entity->getTypedData()) as $name => $field_items) {
       if ($field_items->access('view', $context['account'])) {
         $attributes[$name] = $this->serializer->normalize($field_items, $format, $context);
       }

core/modules/serialization/src/Normalizer/NormalizerBase.php

@@ -2,13 +2,13 @@
 
 namespace Drupal\serialization\Normalizer;
 
-use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+use Drupal\Core\Cache\CacheableDependencyInterface;
 use Symfony\Component\Serializer\Normalizer\SerializerAwareNormalizer;
 
 /**
  * Base class for Normalizers.
  */
-abstract class NormalizerBase extends SerializerAwareNormalizer implements NormalizerInterface {
+abstract class NormalizerBase extends SerializerAwareNormalizer implements CacheableNormalizerInterface {
 
   /**
    * The interface or class that this Normalizer supports.
@@ -81,4 +81,18 @@ abstract class NormalizerBase extends SerializerAwareNormalizer implements Norma
     return in_array($format, (array) $this->format, TRUE);
   }
 
+  /**
+   * Adds cacheability if applicable.
+   *
+   * @param array $context
+   *   Context options for the normalizer.
+   * @param $data
+   *   The data that might have cacheability information.
+   */
+  protected function addCacheableDependency(array $context, $data) {
+    if ($data instanceof CacheableDependencyInterface && isset($context[static::SERIALIZATION_CONTEXT_CACHEABILITY])) {
+      $context[static::SERIALIZATION_CONTEXT_CACHEABILITY]->addCacheableDependency($data);
+    }
+  }
+
 }

core/modules/serialization/src/Normalizer/TimeStampItemNormalizerTrait.php

@@ -20,7 +20,7 @@ trait TimeStampItemNormalizerTrait {
    *
    * @var string[]
    *
-   * @see http://php.net/manual/en/datetime.createfromformat.php
+   * @see http://php.net/manual/datetime.createfromformat.php
    */
   protected $allowedFormats = [
     'UNIX timestamp' => 'U',

core/modules/serialization/src/Normalizer/TypedDataNormalizer.php

@@ -18,7 +18,13 @@ class TypedDataNormalizer extends NormalizerBase {
    * {@inheritdoc}
    */
   public function normalize($object, $format = NULL, array $context = []) {
-    return $object->getValue();
+    $this->addCacheableDependency($context, $object);
+    $value = $object->getValue();
+    // Support for stringable value objects: avoid numerous custom normalizers.
+    if (is_object($value) && method_exists($value, '__toString')) {
+      $value = (string) $value;
+    }
+    return $value;
   }
 
 }