diff --git a/core/lib/Drupal/Core/Entity/ContentEntityBase.php b/core/lib/Drupal/Core/Entity/ContentEntityBase.php
index a9dd647..340bd28 100644
--- a/core/lib/Drupal/Core/Entity/ContentEntityBase.php
+++ b/core/lib/Drupal/Core/Entity/ContentEntityBase.php
@@ -213,6 +213,7 @@ protected function getLanguages() {
    */
   public function postCreate(EntityStorageInterface $storage) {
     $this->newRevision = TRUE;
+    $this->loadingCompleted = TRUE;
   }
 
   /**
@@ -680,6 +681,7 @@ protected function initializeTranslation($langcode) {
     $translation->fields = &$this->fields;
     $translation->translations = &$this->translations;
     $translation->enforceIsNew = &$this->enforceIsNew;
+    $translation->newRevision = &$this->newRevision;
     $translation->translationInitialize = FALSE;
     // Reset language-dependent properties.
     unset($translation->entityKeys['label']);
@@ -1012,4 +1014,43 @@ public static function bundleFieldDefinitions(EntityTypeInterface $entity_type,
     return array();
   }
 
+  /**
+   * {@inheritdoc}
+   */
+  public function hasTranslationChanges() {
+    if ($this->isNew()) {
+      return TRUE;
+    }
+
+    // $this->original only exists during save. See
+    // Drupal\Core\Entity\EntityStorageBase::save(). If it exists we re-use it
+    // here for performance reasons. But we need to clone $entity->original to
+    // avoid modifying it when calling getTranslation().
+    $original = ($this->original) ? clone $this->original : NULL;
+
+    if (!$original) {
+      $id = ($this->getOriginalId() !== NULL) ? $this->getOriginalId() : $this->id();
+      $original = \Drupal::entityManager()->getStorage($this->getEntityTypeId())->loadUnchanged($id);
+    }
+
+    $translated = count($this->translations) > 1;
+    if ($translated && !$original->hasTranslation($this->activeLangcode)) {
+      return TRUE;
+    }
+
+    $translation = ($translated) ? $original->getTranslation($this->language()->getId()) : $original;
+
+    foreach ($this->getFieldDefinitions() as $field_name => $field_definition) {
+      if (!$field_definition->isComputed() && (!$this->isTranslatable() || $field_definition->isTranslatable())) {
+        $items = $this->get($field_name)->filterEmptyItems();
+        $original_items = $translation->get($field_name)->filterEmptyItems();
+        if (!$items->equals($original_items)) {
+          return TRUE;
+        }
+      }
+    }
+
+    return FALSE;
+  }
+
 }
diff --git a/core/lib/Drupal/Core/Entity/EntityChangedInterface.php b/core/lib/Drupal/Core/Entity/EntityChangedInterface.php
index 5f031a3..550e759 100644
--- a/core/lib/Drupal/Core/Entity/EntityChangedInterface.php
+++ b/core/lib/Drupal/Core/Entity/EntityChangedInterface.php
@@ -37,4 +37,5 @@ public function getChangedTime();
    *   translations.
    */
   public function getChangedTimeAcrossTranslations();
+
 }
diff --git a/core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorage.php b/core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorage.php
index c780267..634aa99 100644
--- a/core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorage.php
+++ b/core/lib/Drupal/Core/Entity/Sql/SqlContentEntityStorage.php
@@ -458,6 +458,11 @@ protected function getFromStorage(array $ids = NULL) {
           $function = $module . '_' . $this->entityTypeId . '_storage_load';
           $function($entities);
         }
+
+        foreach ($entities as $entity) {
+          // Set a flag that entity loading from storage is completed.
+          $entity->loadingCompleted = TRUE;
+        }
       }
     }
 
diff --git a/core/lib/Drupal/Core/Field/Plugin/Field/FieldType/ChangedFlagItem.php b/core/lib/Drupal/Core/Field/Plugin/Field/FieldType/ChangedFlagItem.php
new file mode 100644
index 0000000..d028e09
--- /dev/null
+++ b/core/lib/Drupal/Core/Field/Plugin/Field/FieldType/ChangedFlagItem.php
@@ -0,0 +1,99 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\Core\Entity\Plugin\Field\FieldType\ChangedFlagItem.
+ */
+
+namespace Drupal\Core\Field\Plugin\Field\FieldType;
+
+use Drupal\Core\Field\FieldItemBase;
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
+use Drupal\Core\TypedData\DataDefinition;
+
+/**
+ * Defines the 'changed_flag' field type.
+ *
+ * @FieldType(
+ *   id = "changed_flag",
+ *   label = @Translation("Changed Flag"),
+ *   description = @Translation("Indicates if a entity is changed in the cureent revision."),
+ *   no_ui = TRUE,
+ *   default_formatter = "boolean"
+ * )
+ */
+class ChangedFlagItem extends FieldItemBase {
+
+  /**
+   * Flag that indicates if the field value is set manually via API.
+   *
+   * @var bool
+   */
+  protected $manuallySet = FALSE;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function onChange($property_name, $notify = TRUE) {
+    parent::onChange($property_name, $notify);
+    if (isset($this->getEntity()->loadingCompleted)) {
+      $this->manuallySet = TRUE;
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function preSave() {
+    parent::preSave();
+
+    if (!$this->manuallySet) {
+      $entity = $this->getEntity();
+
+      if ($entity->isNew()) {
+        $this->value = 1;
+      }
+      elseif (!$this->value || $entity->isNewRevision()) {
+        $this->value = (int) $entity->hasTranslationChanges();
+      }
+    }
+
+    // Reset the manuallySet flag.
+    $this->manuallySet = FALSE;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function propertyDefinitions(FieldStorageDefinitionInterface $field_definition) {
+    $properties['value'] = DataDefinition::create('boolean')
+      ->setLabel(t('Changed'))
+      ->setRequired(TRUE);
+
+    return $properties;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function schema(FieldStorageDefinitionInterface $field_definition) {
+    return array(
+      'columns' => array(
+        'value' => array(
+          'type' => 'int',
+          'size' => 'tiny',
+        ),
+      ),
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function applyDefaultValue($notify = TRUE) {
+    parent::applyDefaultValue($notify);
+    $this->setValue(array('value' => 0), $notify);
+    return $this;
+  }
+
+}
diff --git a/core/lib/Drupal/Core/Field/Plugin/Field/FieldType/ChangedItem.php b/core/lib/Drupal/Core/Field/Plugin/Field/FieldType/ChangedItem.php
index 1a120f8..8a3d420 100644
--- a/core/lib/Drupal/Core/Field/Plugin/Field/FieldType/ChangedItem.php
+++ b/core/lib/Drupal/Core/Field/Plugin/Field/FieldType/ChangedItem.php
@@ -26,6 +26,23 @@
 class ChangedItem extends CreatedItem {
 
   /**
+   * Flag that indicates if the field value is set manually via API.
+   *
+   * @var bool
+   */
+  protected $manuallySet = FALSE;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function onChange($property_name, $notify = TRUE) {
+    parent::onChange($property_name, $notify);
+    if (isset($this->getEntity()->loadingCompleted)) {
+      $this->manuallySet = TRUE;
+    }
+  }
+
+  /**
    * {@inheritdoc}
    */
   public function preSave() {
@@ -35,41 +52,31 @@ public function preSave() {
     if (!$this->value) {
       $this->value = REQUEST_TIME;
     }
-    else {
+    elseif (!$this->manuallySet) {
       // On an existing entity the changed timestamp will only be set to request
       // time automatically if at least one other field value of the entity has
       // changed. This detection doesn't run on new entities and will be turned
       // off if the changed timestamp is set manually before save, for example
       // during migrations or using
       // \Drupal\content_translation\ContentTranslationMetadataWrapperInterface::setChangedTime().
-      // @todo Knowing if the current translation was modified or not is
-      //   generally useful. There's a follow-up issue to reduce the nesting
-      //   here and to offer an accessor for this information. See
-      //   https://www.drupal.org/node/2453153
       $entity = $this->getEntity();
       if (!$entity->isNew()) {
         $field_name = $this->getFieldDefinition()->getName();
         // Clone $entity->original to avoid modifying it when calling
         // getTranslation().
         $original = clone $entity->original;
-        $translatable = $this->getFieldDefinition()->isTranslatable();
-        if ($translatable) {
+        if ($this->getFieldDefinition()->isTranslatable()) {
           $original = $original->getTranslation($entity->language()->getId());
         }
-        if ($this->value == $original->get($field_name)->value) {
-          foreach ($entity->getFieldDefinitions() as $other_field_name => $other_field_definition) {
-            if ($other_field_name != $field_name && !$other_field_definition->isComputed() && (!$translatable || $other_field_definition->isTranslatable())) {
-              $items = $entity->get($other_field_name)->filterEmptyItems();
-              $original_items = $original->get($other_field_name)->filterEmptyItems();
-              if (!$items->equals($original_items)) {
-                $this->value = REQUEST_TIME;
-                break;
-              }
-            }
-          }
+
+        if ($this->value == $original->get($field_name)->value && $entity->hasTranslationChanges()) {
+          $this->value = REQUEST_TIME;
         }
       }
     }
-  }
+
+    // Reset the manuallySet flag.
+    $this->manuallySet = FALSE;
+ }
 
 }
diff --git a/core/lib/Drupal/Core/TypedData/TranslatableInterface.php b/core/lib/Drupal/Core/TypedData/TranslatableInterface.php
index 73b288d..f66dbad 100644
--- a/core/lib/Drupal/Core/TypedData/TranslatableInterface.php
+++ b/core/lib/Drupal/Core/TypedData/TranslatableInterface.php
@@ -105,4 +105,15 @@ public function removeTranslation($langcode);
    */
   public function isTranslatable();
 
+  /**
+   * Determines if the current translation of the entity has unsaved changes.
+   *
+   * If the entity is translatable only translatable fields will be checked
+   * for changes.
+   *
+   * @return bool
+   *   TRUE if the current translation of the entity has changes.
+   */
+  public function hasTranslationChanges();
+
 }
diff --git a/core/modules/block_content/src/Entity/BlockContent.php b/core/modules/block_content/src/Entity/BlockContent.php
index cf5e21a..8bbaf31 100644
--- a/core/modules/block_content/src/Entity/BlockContent.php
+++ b/core/modules/block_content/src/Entity/BlockContent.php
@@ -207,6 +207,13 @@ public static function baseFieldDefinitions(EntityTypeInterface $entity_type) {
       ->setTranslatable(TRUE)
       ->setRevisionable(TRUE);
 
+    $fields['revision_translation_affected'] = BaseFieldDefinition::create('changed_flag')
+      ->setLabel(t('Revision translation affected'))
+      ->setDescription(t('Indicates if the last edit of a translation belongs to current revison.'))
+      ->setReadOnly(TRUE)
+      ->setRevisionable(TRUE)
+      ->setTranslatable(TRUE);
+
     return $fields;
   }
 
diff --git a/core/modules/node/src/Entity/Node.php b/core/modules/node/src/Entity/Node.php
index 6dd1229..5036c00 100644
--- a/core/modules/node/src/Entity/Node.php
+++ b/core/modules/node/src/Entity/Node.php
@@ -494,6 +494,13 @@ public static function baseFieldDefinitions(EntityTypeInterface $entity_type) {
         ),
       ));
 
+    $fields['revision_translation_affected'] = BaseFieldDefinition::create('changed_flag')
+      ->setLabel(t('Revision translation affected'))
+      ->setDescription(t('Indicates if the last edit of a translation belongs to current revison.'))
+      ->setReadOnly(TRUE)
+      ->setRevisionable(TRUE)
+      ->setTranslatable(TRUE);
+
     return $fields;
   }
 
diff --git a/core/modules/system/src/Tests/Entity/ContentEntityChangedTest.php b/core/modules/system/src/Tests/Entity/ContentEntityChangedTest.php
index 13ec8b4..57d3350 100644
--- a/core/modules/system/src/Tests/Entity/ContentEntityChangedTest.php
+++ b/core/modules/system/src/Tests/Entity/ContentEntityChangedTest.php
@@ -7,6 +7,8 @@
 
 namespace Drupal\system\Tests\Entity;
 
+use Drupal\entity_test\Entity\EntityTestMulChanged;
+use Drupal\entity_test\Entity\EntityTestMulRevChanged;
 use Drupal\language\Entity\ConfigurableLanguage;
 
 /**
@@ -31,9 +33,13 @@ protected function setUp() {
 
     // Enable an additional language.
     ConfigurableLanguage::createFromLangcode('de')->save();
+    ConfigurableLanguage::createFromLangcode('fr')->save();
 
     $this->installEntitySchema('entity_test_mul_changed');
     $this->installEntitySchema('entity_test_mulrev_changed');
+
+    $this->mulChangedStorage = $this->entityManager->getStorage('entity_test_mul_changed');
+    $this->mulRevChangedStorage = $this->entityManager->getStorage('entity_test_mulrev_changed');
   }
 
   /**
@@ -43,8 +49,8 @@ public function testChanged() {
     $user1 = $this->createUser();
     $user2 = $this->createUser();
 
-    // Create some test entities.
-    $entity = entity_create('entity_test_mul_changed', array(
+    // Create a test entity.
+    $entity = EntityTestMulChanged::create(array(
       'name' => $this->randomString(),
       'user_id' => $user1->id(),
       'language' => 'en',
@@ -148,9 +154,7 @@ public function testChanged() {
     // At this point the changed time of the original language (en) is newer
     // than the changed time of the German translation. Now test that entity
     // queries work as expected.
-    $storage = $this->entityManager->getStorage('entity_test_mul_changed');
-
-    $query = $storage->getQuery();
+    $query = $this->mulChangedStorage->getQuery();
     $ids = $query->condition('changed', $changed_en)->execute();
 
     $this->assertEqual(
@@ -158,7 +162,7 @@ public function testChanged() {
       'Entity query can access changed time of original language.'
     );
 
-    $query = $storage->getQuery();
+    $query = $this->mulChangedStorage->getQuery();
     $ids = $query->condition('changed', $changed_en, '=', 'en')->execute();
 
     $this->assertEqual(
@@ -166,7 +170,7 @@ public function testChanged() {
       'Entity query can access changed time of original language by setting the original language as condition.'
     );
 
-    $query = $storage->getQuery();
+    $query = $this->mulChangedStorage->getQuery();
     $ids = $query->condition('changed', $changed_de, '=', 'en')->execute();
 
     $this->assertFalse(
@@ -174,7 +178,7 @@ public function testChanged() {
       'There\'s no original entity stored having the changed time of the German translation.'
     );
 
-    $query = $storage->getQuery();
+    $query = $this->mulChangedStorage->getQuery();
     $ids = $query->condition('changed', $changed_en)->condition('default_langcode', '1')->execute();
 
     $this->assertEqual(
@@ -182,7 +186,7 @@ public function testChanged() {
       'Entity query can access changed time of default language.'
     );
 
-    $query = $storage->getQuery();
+    $query = $this->mulChangedStorage->getQuery();
     $ids = $query->condition('changed', $changed_de)->condition('default_langcode', '1')->execute();
 
     $this->assertFalse(
@@ -190,7 +194,7 @@ public function testChanged() {
       'There\'s no entity stored using the default language having the changed time of the German translation.'
     );
 
-    $query = $storage->getQuery();
+    $query = $this->mulChangedStorage->getQuery();
     $ids = $query->condition('changed', $changed_de)->execute();
 
     $this->assertEqual(
@@ -198,7 +202,7 @@ public function testChanged() {
       'Entity query can access changed time of the German translation.'
     );
 
-    $query = $storage->getQuery();
+    $query = $this->mulChangedStorage->getQuery();
     $ids = $query->condition('changed', $changed_de, '=', 'de')->execute();
 
     $this->assertEqual(
@@ -206,7 +210,7 @@ public function testChanged() {
       'Entity query can access changed time of the German translation.'
     );
 
-    $query = $storage->getQuery();
+    $query = $this->mulChangedStorage->getQuery();
     $ids = $query->condition('changed', $changed_en, '=', 'de')->execute();
 
     $this->assertFalse(
@@ -214,7 +218,7 @@ public function testChanged() {
       'There\'s no German translation stored having the changed time of the original language.'
     );
 
-    $query = $storage->getQuery();
+    $query = $this->mulChangedStorage->getQuery();
     $ids = $query->condition('changed', $changed_de, '>')->execute();
 
     $this->assertEqual(
@@ -222,7 +226,7 @@ public function testChanged() {
       'Entity query can access changed time regardless of translation.'
     );
 
-    $query = $storage->getQuery();
+    $query = $this->mulChangedStorage->getQuery();
     $ids = $query->condition('changed', $changed_en, '<')->execute();
 
     $this->assertEqual(
@@ -230,7 +234,7 @@ public function testChanged() {
       'Entity query can access changed time regardless of translation.'
     );
 
-    $query = $storage->getQuery();
+    $query = $this->mulChangedStorage->getQuery();
     $ids = $query->condition('changed', 0, '>')->execute();
 
     $this->assertEqual(
@@ -238,7 +242,7 @@ public function testChanged() {
       'Entity query can access changed time regardless of translation.'
     );
 
-    $query = $storage->getQuery();
+    $query = $this->mulChangedStorage->getQuery();
     $ids = $query->condition('changed', $changed_en, '>')->execute();
 
     $this->assertFalse(
@@ -254,8 +258,8 @@ public function testRevisionChanged() {
     $user1 = $this->createUser();
     $user2 = $this->createUser();
 
-    // Create some test entities.
-    $entity = entity_create('entity_test_mulrev_changed', array(
+    // Create a test entity.
+    $entity = EntityTestMulRevChanged::create(array(
       'name' => $this->randomString(),
       'user_id' => $user1->id(),
       'language' => 'en',
@@ -281,6 +285,11 @@ public function testRevisionChanged() {
       'Changed time of original language is the same as changed time across all translations.'
     );
 
+    $this->assertTrue(
+      $this->getChangedFlag($entity),
+      'Changed flag of original language is set for a new entity.'
+    );
+
     $changed_en = $entity->getChangedTime();
 
     $entity->setNewRevision();
@@ -292,6 +301,11 @@ public function testRevisionChanged() {
       'Changed time of original language did not change.'
     );
 
+    $this->assertFalse(
+      $this->getChangedFlag($entity),
+      'Changed flag of original language is not set for new revision without changes.'
+    );
+
     $entity->setOwner($user2);
     $entity->setNewRevision();
     $entity->save();
@@ -301,6 +315,11 @@ public function testRevisionChanged() {
       'Changed time of original language has been updated by new revision.'
     );
 
+    $this->assertTrue(
+      $this->getChangedFlag($entity),
+      'Changed flag of original language is set for new revision with changes.'
+    );
+
     $changed_en = $entity->getChangedTime();
 
     $entity->addTranslation('de');
@@ -324,6 +343,16 @@ public function testRevisionChanged() {
       'Changed time of the German translation is the newest time across all translations.'
     );
 
+    $this->assertTrue(
+      $this->getChangedFlag($entity),
+      'Changed flag of original language is not reset by adding a new translation.'
+    );
+
+    $this->assertTrue(
+      $this->getChangedFlag($german),
+      'Changed flag of German translation is set when adding the translation.'
+    );
+
     $changed_de = $german->getChangedTime();
 
     $entity->setNewRevision();
@@ -340,6 +369,16 @@ public function testRevisionChanged() {
       'Changed time of the German translation did not change.'
     );
 
+    $this->assertFalse(
+      $this->getChangedFlag($entity),
+      'Changed flag of original language is not set for new revision without changes.'
+    );
+
+    $this->assertFalse(
+      $this->getChangedFlag($german),
+      'Changed flag of of the German translation is not set for new revision without changes.'
+    );
+
     $german->setOwner($user2);
     $entity->setNewRevision();
     $entity->save();
@@ -358,6 +397,116 @@ public function testRevisionChanged() {
       $german->getChangedTime(), $entity->getChangedTimeAcrossTranslations(),
       'Changed time of the German translation is the newest time across all translations.'
     );
+
+    $this->assertFalse(
+      $this->getChangedFlag($entity),
+      'Changed flag of original language is not set when changing the German Translation.'
+    );
+
+    $this->assertTrue(
+      $this->getChangedFlag($german),
+      'Changed flag of German translation is set when changing the German translation.'
+    );
+
+    $french = $entity->getTranslation('fr');
+
+    $entity->setNewRevision();
+    $entity->save();
+
+    $this->assertEqual(
+      $entity->getChangedTime(), $changed_en,
+      'Changed time of original language did not change.'
+    );
+
+    $this->assertTrue(
+      $french->getChangedTime() > $entity->getChangedTime(),
+      'Changed time of the French translation is newer then the original language.'
+    );
+
+    $this->assertTrue(
+      $french->getChangedTime() > $entity->getChangedTime(),
+      'Changed time of the French translation is newer then the German translation.'
+    );
+
+    $this->assertEqual(
+      $french->getChangedTime(), $entity->getChangedTimeAcrossTranslations(),
+      'Changed time of the French translation is the newest time across all translations.'
+    );
+
+    $this->assertFalse(
+      $this->getChangedFlag($entity),
+      'Changed flag of original language is reset by adding a new translation and a new revision.'
+    );
+
+    $this->assertFalse(
+      $this->getChangedFlag($german),
+      'Changed flag of German translation is reset by adding a new translation and a new revision.'
+    );
+
+    $this->assertTrue(
+      $this->getChangedFlag($french),
+      'Changed flag of French translation is set when adding the translation and a new revision.'
+    );
+
+    $entity->removeTranslation('fr');
+
+    $entity->setNewRevision();
+    $entity->save();
+
+    // This block simulates exactly the flow of a node form submission of a new
+    // translation and a new revision.
+    $form_entity_builder_entity = EntityTestMulRevChanged::load($entity->id());
+    // ContentTranslationController::prepareTranslation().
+    $form_entity_builder_entity = $form_entity_builder_entity->addTranslation('fr', $form_entity_builder_entity->toArray());
+    // EntityForm::buildEntity() during form submit.
+    $form_entity_builder_clone = clone $form_entity_builder_entity;
+    // NodeForm::submitForm().
+    $form_entity_builder_clone->setNewRevision();
+    // EntityForm::save().
+    $form_entity_builder_clone->save();
+
+    $this->assertFalse(
+      $this->getChangedFlag($entity),
+      'Changed flag of original language is reset by adding a new translation and a new revision.'
+    );
+
+    $this->assertFalse(
+      $this->getChangedFlag($german),
+      'Changed flag of German translation is reset by adding a new translation and a new revision.'
+    );
+
+    $this->assertTrue(
+      $this->getChangedFlag($french),
+      'Changed flag of French translation is set when adding the translation and a new revision.'
+    );
+
+
+    $german->setOwner($user1);
+    $german->revision_translation_affected->value = 0;
+    $entity->setNewRevision();
+    $entity->save();
+
+    $this->assertFalse(
+      $this->getChangedFlag($german),
+      'German translation changed and a new revison is created but the changed flag is reset manually.'
+    );
+
+    $german->revision_translation_affected->value = 1;
+    $entity->setNewRevision();
+    $entity->save();
+
+    $this->assertTrue(
+      $this->getChangedFlag($german),
+      'German translation is not changed and a new revision is created but the changed flag is set manually.'
+    );
+
+  }
+
+  protected function getChangedFlag($entity) {
+    $query = $this->mulRevChangedStorage->getQuery();
+    $ids = $query->condition('revision_translation_affected', 1, '=', $entity->language()->getId())->execute();
+    $id = reset($ids);
+    return (int) ($id == $entity->id());
   }
 
 }
diff --git a/core/modules/system/tests/modules/entity_test/entity_test.module b/core/modules/system/tests/modules/entity_test/entity_test.module
index dd44c1f..f3409d0 100644
--- a/core/modules/system/tests/modules/entity_test/entity_test.module
+++ b/core/modules/system/tests/modules/entity_test/entity_test.module
@@ -185,7 +185,7 @@ function entity_test_entity_bundle_info() {
   $entity_types = \Drupal::entityManager()->getDefinitions();
   foreach ($entity_types as $entity_type_id => $entity_type) {
     if ($entity_type->getProvider() == 'entity_test') {
-      $bundles[$entity_type_id] = \Drupal::state()->get($entity_type_id . '.bundles') ?: array($entity_type_id => array('label' => 'Entity Test Bundle'));
+      $bundles[$entity_type_id] = \Drupal::state()->get($entity_type_id . '.bundles') ?: array($entity_type_id => array('label' => 'Entity Test Bundle', 'translatable' => strpos($entity_type_id, '_mul')));
     }
   }
   return $bundles;
diff --git a/core/modules/system/tests/modules/entity_test/src/Entity/EntityTestMulRevChanged.php b/core/modules/system/tests/modules/entity_test/src/Entity/EntityTestMulRevChanged.php
index c2f572f..55768fe 100644
--- a/core/modules/system/tests/modules/entity_test/src/Entity/EntityTestMulRevChanged.php
+++ b/core/modules/system/tests/modules/entity_test/src/Entity/EntityTestMulRevChanged.php
@@ -61,6 +61,13 @@ public static function baseFieldDefinitions(EntityTypeInterface $entity_type) {
       ->setReadOnly(TRUE)
       ->setSetting('unsigned', TRUE);
 
+    $fields['revision_translation_affected'] = BaseFieldDefinition::create('changed_flag')
+      ->setLabel(t('Revision translation affected'))
+      ->setDescription(t('Indicates if the last edit of a translation belongs to current revison.'))
+      ->setReadOnly(TRUE)
+      ->setRevisionable(TRUE)
+      ->setTranslatable(TRUE);
+
     $fields['langcode']->setRevisionable(TRUE);
     $fields['name']->setRevisionable(TRUE);
     $fields['user_id']->setRevisionable(TRUE);