Update to Drupal 8.2.2. For more information, see https://www.drupal.org/project/drupal/releases/8.2.2

core/modules/content_moderation/src/Entity/ContentModerationState.php

@@ -4,7 +4,6 @@ namespace Drupal\content_moderation\Entity;
 
 use Drupal\content_moderation\ContentModerationStateInterface;
 use Drupal\Core\Entity\ContentEntityBase;
-use Drupal\Core\Entity\EntityChangedTrait;
 use Drupal\Core\Entity\EntityTypeInterface;
 use Drupal\Core\Field\BaseFieldDefinition;
 use Drupal\Core\TypedData\TranslatableInterface;
@@ -42,8 +41,6 @@ use Drupal\user\UserInterface;
  */
 class ContentModerationState extends ContentEntityBase implements ContentModerationStateInterface {
 
-  use EntityChangedTrait;
-
   /**
    * {@inheritdoc}
    */

core/modules/content_moderation/src/EntityOperations.php

@@ -4,7 +4,6 @@ namespace Drupal\content_moderation;
 
 use Drupal\content_moderation\Entity\ContentModerationState;
 use Drupal\Core\DependencyInjection\ContainerInjectionInterface;
-use Drupal\Core\Entity\ContentEntityInterface;
 use Drupal\Core\Entity\Display\EntityViewDisplayInterface;
 use Drupal\Core\Entity\EntityInterface;
 use Drupal\Core\Entity\EntityTypeManagerInterface;
@@ -77,32 +76,6 @@ class EntityOperations implements ContainerInjectionInterface {
     );
   }
 
-  /**
-   * Determines the default moderation state on load for an entity.
-   *
-   * This method is only applicable when an entity is loaded that has
-   * no moderation state on it, but should. In those cases, failing to set
-   * one may result in NULL references elsewhere when other code tries to check
-   * the moderation state of the entity.
-   *
-   * The amount of indirection here makes performance a concern, but
-   * given how Entity API works I don't know how else to do it.
-   * This reliably gets us *A* valid state. However, that state may be
-   * not the ideal one. Suggestions on how to better select the default
-   * state here are welcome.
-   *
-   * @param \Drupal\Core\Entity\ContentEntityInterface $entity
-   *   The entity for which we want a default state.
-   *
-   * @return string
-   *   The default state for the given entity.
-   */
-  protected function getDefaultLoadStateId(ContentEntityInterface $entity) {
-    return $this->moderationInfo
-      ->loadBundleEntity($entity->getEntityType()->getBundleEntityType(), $entity->bundle())
-      ->getThirdPartySetting('content_moderation', 'default_moderation_state');
-  }
-
   /**
    * Acts on an entity and set published status based on the moderation state.
    *
@@ -170,8 +143,8 @@ class EntityOperations implements ContainerInjectionInterface {
     $moderation_state = $entity->moderation_state->target_id;
     /** @var \Drupal\Core\Entity\ContentEntityInterface $entity */
     if (!$moderation_state) {
-      $moderation_state = $this->moderationInfo
-        ->loadBundleEntity($entity->getEntityType()->getBundleEntityType(), $entity->bundle())
+      $moderation_state = $this->entityTypeManager
+        ->getStorage($entity->getEntityType()->getBundleEntityType())->load($entity->bundle())
         ->getThirdPartySetting('content_moderation', 'default_moderation_state');
     }
 

core/modules/content_moderation/src/ModerationInformation.php

@@ -49,21 +49,15 @@ class ModerationInformation implements ModerationInformationInterface {
     return $entity_type->hasHandlerClass('moderation');
   }
 
-  /**
-   * {@inheritdoc}
-   */
-  public function loadBundleEntity($bundle_entity_type_id, $bundle_id) {
-    if ($bundle_entity_type_id) {
-      return $this->entityTypeManager->getStorage($bundle_entity_type_id)->load($bundle_id);
-    }
-  }
-
   /**
    * {@inheritdoc}
    */
   public function shouldModerateEntitiesOfBundle(EntityTypeInterface $entity_type, $bundle) {
-    if ($bundle_entity = $this->loadBundleEntity($entity_type->getBundleEntityType(), $bundle)) {
-      return $bundle_entity->getThirdPartySetting('content_moderation', 'enabled', FALSE);
+    if ($this->canModerateEntitiesOfEntityType($entity_type)) {
+      $bundle_entity = $this->entityTypeManager->getStorage($entity_type->getBundleEntityType())->load($bundle);
+      if ($bundle_entity) {
+        return $bundle_entity->getThirdPartySetting('content_moderation', 'enabled', FALSE);
+      }
     }
     return FALSE;
   }

core/modules/content_moderation/src/ModerationInformationInterface.php

@@ -11,19 +11,6 @@ use Drupal\Core\Entity\EntityTypeInterface;
  */
 interface ModerationInformationInterface {
 
-  /**
-   * Loads a specific bundle entity.
-   *
-   * @param string $bundle_entity_type_id
-   *   The bundle entity type ID.
-   * @param string $bundle_id
-   *   The bundle ID.
-   *
-   * @return \Drupal\Core\Config\Entity\ConfigEntityInterface|null
-   *   The bundle entity.
-   */
-  public function loadBundleEntity($bundle_entity_type_id, $bundle_id);
-
   /**
    * Determines if an entity is moderated.
    *

core/modules/content_moderation/src/Plugin/Field/ModerationStateFieldItemList.php

@@ -57,8 +57,9 @@ class ModerationStateFieldItemList extends EntityReferenceFieldItemList {
     // It is possible that the bundle does not exist at this point. For example,
     // the node type form creates a fake Node entity to get default values.
     // @see \Drupal\node\NodeTypeForm::form()
-    $bundle_entity = \Drupal::service('content_moderation.moderation_information')
-      ->loadBundleEntity($entity->getEntityType()->getBundleEntityType(), $entity->bundle());
+    $bundle_entity = \Drupal::entityTypeManager()
+      ->getStorage($entity->getEntityType()->getBundleEntityType())
+      ->load($entity->bundle());
     if ($bundle_entity && ($default = $bundle_entity->getThirdPartySetting('content_moderation', 'default_moderation_state'))) {
       return ModerationState::load($default);
     }
@@ -71,7 +72,24 @@ class ModerationStateFieldItemList extends EntityReferenceFieldItemList {
     if ($index !== 0) {
       throw new \InvalidArgumentException('An entity can not have multiple moderation states at the same time.');
     }
+    $this->computeModerationFieldItemList();
+    return isset($this->list[$index]) ? $this->list[$index] : NULL;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIterator() {
+    $this->computeModerationFieldItemList();
+    return parent::getIterator();
+  }
+
+  /**
+   * Recalculate the moderation field item list.
+   */
+  protected function computeModerationFieldItemList() {
     // Compute the value of the moderation state.
+    $index = 0;
     if (!isset($this->list[$index]) || $this->list[$index]->isEmpty()) {
       $moderation_state = $this->getModerationState();
       // Do not store NULL values in the static cache.
@@ -79,8 +97,6 @@ class ModerationStateFieldItemList extends EntityReferenceFieldItemList {
         $this->list[$index] = $this->createItem($index, ['entity' => $moderation_state]);
       }
     }
-
-    return isset($this->list[$index]) ? $this->list[$index] : NULL;
   }
 
 }

core/modules/content_moderation/src/Plugin/Validation/Constraint/ModerationStateConstraintValidator.php

@@ -97,8 +97,8 @@ class ModerationStateConstraintValidator extends ConstraintValidator implements
       $new_state_id = $entity->moderation_state->target_id;
     }
     else {
-      $new_state_id = $default = $this->moderationInformation
-        ->loadBundleEntity($entity->getEntityType()->getBundleEntityType(), $entity->bundle())
+      $new_state_id = $default = $this->entityTypeManager
+        ->getStorage($entity->getEntityType()->getBundleEntityType())->load($entity->bundle())
         ->getThirdPartySetting('content_moderation', 'default_moderation_state');
     }
     if ($new_state_id) {

core/modules/content_moderation/tests/src/Kernel/ModerationStateFieldItemListTest.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace Drupal\Tests\content_moderation\Kernel;
+
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\node\Entity\Node;
+use Drupal\node\Entity\NodeType;
+
+/**
+ * @coversDefaultClass \Drupal\content_moderation\Plugin\Field\ModerationStateFieldItemList
+ *
+ * @group content_moderation
+ */
+class ModerationStateFieldItemListTest extends KernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $modules = [
+    'node',
+    'content_moderation',
+    'user',
+    'system',
+    'language',
+  ];
+
+  /**
+   * @var \Drupal\node\NodeInterface
+   */
+  protected $testNode;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+
+    $this->installSchema('node', 'node_access');
+    $this->installEntitySchema('node');
+    $this->installEntitySchema('user');
+    $this->installEntitySchema('content_moderation_state');
+    $this->installConfig('content_moderation');
+
+    $node_type = NodeType::create([
+      'type' => 'example',
+    ]);
+    $node_type->setThirdPartySetting('content_moderation', 'enabled', TRUE);
+    $node_type->setThirdPartySetting('content_moderation', 'allowed_moderation_states', ['draft']);
+    $node_type->setThirdPartySetting('content_moderation', 'default_moderation_state', 'draft');
+    $node_type->save();
+    $this->testNode = Node::create([
+      'type' => 'example',
+      'title' => 'Test title',
+    ]);
+    $this->testNode->save();
+    \Drupal::entityTypeManager()->getStorage('node')->resetCache();
+    $this->testNode = Node::load($this->testNode->id());
+  }
+
+  /**
+   * Test the field item list when accessing an index.
+   */
+  public function testArrayIndex() {
+    $this->assertEquals('draft', $this->testNode->moderation_state[0]->entity->id());
+  }
+
+  /**
+   * Test the field item list when iterating.
+   */
+  public function testArrayIteration() {
+    $states = [];
+    foreach ($this->testNode->moderation_state as $item) {
+      $states[] = $item->entity->id();
+    }
+    $this->assertEquals(['draft'], $states);
+  }
+
+}

core/modules/content_moderation/tests/src/Unit/ModerationInformationTest.php

@@ -2,6 +2,7 @@
 
 namespace Drupal\Tests\content_moderation\Unit;
 
+use Drupal\content_moderation\Entity\Handler\ModerationHandler;
 use Drupal\Core\Config\Entity\ConfigEntityInterface;
 use Drupal\Core\Entity\ContentEntityInterface;
 use Drupal\Core\Entity\ContentEntityType;
@@ -70,6 +71,7 @@ class ModerationInformationTest extends \PHPUnit_Framework_TestCase {
     $entity_type = new ContentEntityType([
       'id' => 'test_entity_type',
       'bundle_entity_type' => 'entity_test_bundle',
+      'handlers' => ['moderation' => ModerationHandler::class],
     ]);
     $entity = $this->prophesize(ContentEntityInterface::class);
     $entity->getEntityType()->willReturn($entity_type);
@@ -104,6 +106,7 @@ class ModerationInformationTest extends \PHPUnit_Framework_TestCase {
     $entity_type = new ContentEntityType([
       'id' => 'test_entity_type',
       'bundle_entity_type' => 'entity_test_bundle',
+      'handlers' => ['moderation' => ModerationHandler::class],
     ]);
 
     $moderation_information = new ModerationInformation($this->setupModerationEntityManager($status), $this->getUser());