diff --git a/core/lib/Drupal/Core/Entity/ContentEntityDatabaseStorage.php b/core/lib/Drupal/Core/Entity/ContentEntityDatabaseStorage.php
index b21958b..9c5d98a 100644
--- a/core/lib/Drupal/Core/Entity/ContentEntityDatabaseStorage.php
+++ b/core/lib/Drupal/Core/Entity/ContentEntityDatabaseStorage.php
@@ -18,9 +18,8 @@
 use Drupal\Core\Field\FieldStorageDefinitionInterface;
 use Drupal\Core\Language\Language;
 use Drupal\field\FieldConfigUpdateForbiddenException;
-use Drupal\field\FieldConfigInterface;
-use Drupal\field\FieldInstanceConfigInterface;
 use Drupal\field\Entity\FieldConfig;
+use Drupal\field\FieldInstanceConfigInterface;
 use Symfony\Component\DependencyInjection\ContainerInterface;
 
 /**
@@ -954,7 +953,7 @@ protected function doLoadFieldItems($entities, $age) {
     foreach ($bundles as $bundle => $v) {
       foreach ($this->entityManager->getFieldDefinitions($this->entityTypeId, $bundle) as $field_name => $instance) {
         if ($instance instanceof FieldInstanceConfigInterface) {
-          $fields[$field_name] = $instance->getField();
+          $fields[$field_name] = $instance;
         }
       }
     }
@@ -1023,9 +1022,8 @@ protected function doSaveFieldItems(EntityInterface $entity, $update) {
       if (!($instance instanceof FieldInstanceConfigInterface)) {
         continue;
       }
-      $field = $instance->getField();
-      $table_name = static::_fieldTableName($field);
-      $revision_name = static::_fieldRevisionTableName($field);
+      $table_name = static::_fieldTableName($instance);
+      $revision_name = static::_fieldRevisionTableName($instance);
 
       // Delete and insert, rather than update, in case a value was added.
       if ($update) {
@@ -1045,13 +1043,13 @@ protected function doSaveFieldItems(EntityInterface $entity, $update) {
       // Prepare the multi-insert query.
       $do_insert = FALSE;
       $columns = array('entity_id', 'revision_id', 'bundle', 'delta', 'langcode');
-      foreach ($field->getColumns() as $column => $attributes) {
-        $columns[] = static::_fieldColumnName($field, $column);
+      foreach ($instance->getColumns() as $column => $attributes) {
+        $columns[] = static::_fieldColumnName($instance, $column);
       }
       $query = $this->database->insert($table_name)->fields($columns);
       $revision_query = $this->database->insert($revision_name)->fields($columns);
 
-      $langcodes = $field->isTranslatable() ? $translation_langcodes : array($default_langcode);
+      $langcodes = $instance->isTranslatable() ? $translation_langcodes : array($default_langcode);
       foreach ($langcodes as $langcode) {
         $delta_count = 0;
         $items = $entity->getTranslation($langcode)->get($field_name);
@@ -1066,15 +1064,15 @@ protected function doSaveFieldItems(EntityInterface $entity, $update) {
             'delta' => $delta,
             'langcode' => $langcode,
           );
-          foreach ($field->getColumns() as $column => $attributes) {
-            $column_name = static::_fieldColumnName($field, $column);
+          foreach ($instance->getColumns() as $column => $attributes) {
+            $column_name = static::_fieldColumnName($instance, $column);
             // Serialize the value if specified in the column schema.
             $record[$column_name] = !empty($attributes['serialize']) ? serialize($item->$column) : $item->$column;
           }
           $query->values($record);
           $revision_query->values($record);
 
-          if ($field->getCardinality() != FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED && ++$delta_count == $field->getCardinality()) {
+          if ($instance->getCardinality() != FieldStorageDefinitionInterface::CARDINALITY_UNLIMITED && ++$delta_count == $instance->getCardinality()) {
             break;
           }
         }
@@ -1100,9 +1098,8 @@ protected function doDeleteFieldItems(EntityInterface $entity) {
       if (!($instance instanceof FieldInstanceConfigInterface)) {
         continue;
       }
-      $field = $instance->getField();
-      $table_name = static::_fieldTableName($field);
-      $revision_name = static::_fieldRevisionTableName($field);
+      $table_name = static::_fieldTableName($instance);
+      $revision_name = static::_fieldRevisionTableName($instance);
       $this->database->delete($table_name)
         ->condition('entity_id', $entity->id())
         ->execute();
@@ -1122,7 +1119,7 @@ protected function doDeleteFieldItemsRevision(EntityInterface $entity) {
         if (!($instance instanceof FieldInstanceConfigInterface)) {
           continue;
         }
-        $revision_name = static::_fieldRevisionTableName($instance->getField());
+        $revision_name = static::_fieldRevisionTableName($instance);
         $this->database->delete($revision_name)
           ->condition('entity_id', $entity->id())
           ->condition('revision_id', $vid)
@@ -1134,8 +1131,8 @@ protected function doDeleteFieldItemsRevision(EntityInterface $entity) {
   /**
    * {@inheritdoc}
    */
-  public function onFieldCreate(FieldConfigInterface $field) {
-    $schema = $this->_fieldSqlSchema($field);
+  public function onFieldCreate(FieldStorageDefinitionInterface $storage_definition) {
+    $schema = $this->_fieldSqlSchema($storage_definition);
     foreach ($schema as $name => $table) {
       $this->database->schema()->createTable($name, $table);
     }
@@ -1144,10 +1141,10 @@ public function onFieldCreate(FieldConfigInterface $field) {
   /**
    * {@inheritdoc}
    */
-  public function onFieldUpdate(FieldConfigInterface $field) {
-    $original = $field->original;
+  public function onFieldUpdate(FieldStorageDefinitionInterface $storage_definition) {
+    $original = $storage_definition->original;
 
-    if (!$field->hasData()) {
+    if (!$storage_definition->hasData()) {
       // There is no data. Re-create the tables completely.
 
       if ($this->database->supportsTransactionalDDL()) {
@@ -1161,7 +1158,7 @@ public function onFieldUpdate(FieldConfigInterface $field) {
         foreach ($original_schema as $name => $table) {
           $this->database->schema()->dropTable($name, $table);
         }
-        $schema = $this->_fieldSqlSchema($field);
+        $schema = $this->_fieldSqlSchema($storage_definition);
         foreach ($schema as $name => $table) {
           $this->database->schema()->createTable($name, $table);
         }
@@ -1183,7 +1180,7 @@ public function onFieldUpdate(FieldConfigInterface $field) {
       }
     }
     else {
-      if ($field->getColumns() != $original->getColumns()) {
+      if ($storage_definition->getColumns() != $original->getColumns()) {
         throw new FieldConfigUpdateForbiddenException("The SQL storage cannot change the schema for an existing field with data.");
       }
       // There is data, so there are no column changes. Drop all the prior
@@ -1192,33 +1189,33 @@ public function onFieldUpdate(FieldConfigInterface $field) {
       $table = static::_fieldTableName($original);
       $revision_table = static::_fieldRevisionTableName($original);
 
-      $schema = $field->getSchema();
+      $schema = $storage_definition->getSchema();
       $original_schema = $original->getSchema();
 
       foreach ($original_schema['indexes'] as $name => $columns) {
         if (!isset($schema['indexes'][$name]) || $columns != $schema['indexes'][$name]) {
-          $real_name = static::_fieldIndexName($field, $name);
+          $real_name = static::_fieldIndexName($storage_definition, $name);
           $this->database->schema()->dropIndex($table, $real_name);
           $this->database->schema()->dropIndex($revision_table, $real_name);
         }
       }
-      $table = static::_fieldTableName($field);
-      $revision_table = static::_fieldRevisionTableName($field);
+      $table = static::_fieldTableName($storage_definition);
+      $revision_table = static::_fieldRevisionTableName($storage_definition);
       foreach ($schema['indexes'] as $name => $columns) {
         if (!isset($original_schema['indexes'][$name]) || $columns != $original_schema['indexes'][$name]) {
-          $real_name = static::_fieldIndexName($field, $name);
+          $real_name = static::_fieldIndexName($storage_definition, $name);
           $real_columns = array();
           foreach ($columns as $column_name) {
             // Indexes can be specified as either a column name or an array with
             // column name and length. Allow for either case.
             if (is_array($column_name)) {
               $real_columns[] = array(
-                static::_fieldColumnName($field, $column_name[0]),
+                static::_fieldColumnName($storage_definition, $column_name[0]),
                 $column_name[1],
               );
             }
             else {
-              $real_columns[] = static::_fieldColumnName($field, $column_name);
+              $real_columns[] = static::_fieldColumnName($storage_definition, $column_name);
             }
           }
           $this->database->schema()->addIndex($table, $real_name, $real_columns);
@@ -1231,17 +1228,17 @@ public function onFieldUpdate(FieldConfigInterface $field) {
   /**
    * {@inheritdoc}
    */
-  public function onFieldDelete(FieldConfigInterface $field) {
+  public function onFieldDelete(FieldStorageDefinitionInterface $storage_definition) {
     // Mark all data associated with the field for deletion.
-    $table = static::_fieldTableName($field);
-    $revision_table = static::_fieldRevisionTableName($field);
+    $table = static::_fieldTableName($storage_definition);
+    $revision_table = static::_fieldRevisionTableName($storage_definition);
     $this->database->update($table)
       ->fields(array('deleted' => 1))
       ->execute();
 
     // Move the table to a unique name while the table contents are being
     // deleted.
-    $deleted_field = clone $field;
+    $deleted_field = clone $storage_definition;
     $deleted_field->deleted = TRUE;
     $new_table = static::_fieldTableName($deleted_field);
     $revision_new_table = static::_fieldRevisionTableName($deleted_field);
@@ -1252,17 +1249,16 @@ public function onFieldDelete(FieldConfigInterface $field) {
   /**
    * {@inheritdoc}
    */
-  public function onInstanceDelete(FieldInstanceConfigInterface $instance) {
-    $field = $instance->getField();
-    $table_name = static::_fieldTableName($field);
-    $revision_name = static::_fieldRevisionTableName($field);
+  public function onInstanceDelete(FieldDefinitionInterface $field_definition) {
+    $table_name = static::_fieldTableName($field_definition);
+    $revision_name = static::_fieldRevisionTableName($field_definition);
     $this->database->update($table_name)
       ->fields(array('deleted' => 1))
-      ->condition('bundle', $instance->bundle)
+      ->condition('bundle', $field_definition->bundle)
       ->execute();
     $this->database->update($revision_name)
       ->fields(array('deleted' => 1))
-      ->condition('bundle', $instance->bundle)
+      ->condition('bundle', $field_definition->bundle)
       ->execute();
   }
 
@@ -1275,9 +1271,8 @@ public function onBundleRename($bundle, $bundle_new) {
     // using the old bundle name.
     $instances = entity_load_multiple_by_properties('field_instance_config', array('entity_type' => $this->entityTypeId, 'bundle' => $bundle, 'include_deleted' => TRUE));
     foreach ($instances as $instance) {
-      $field = $instance->getField();
-      $table_name = static::_fieldTableName($field);
-      $revision_name = static::_fieldRevisionTableName($field);
+      $table_name = static::_fieldTableName($instance);
+      $revision_name = static::_fieldRevisionTableName($instance);
       $this->database->update($table_name)
         ->fields(array('bundle' => $bundle_new))
         ->condition('bundle', $bundle)
@@ -1292,14 +1287,13 @@ public function onBundleRename($bundle, $bundle_new) {
   /**
    * {@inheritdoc}
    */
-  protected function readFieldItemsToPurge(EntityInterface $entity, FieldInstanceConfigInterface $instance) {
-    $field = $instance->getField();
-    $table_name = static::_fieldTableName($field);
+  protected function readFieldItemsToPurge(EntityInterface $entity, FieldDefinitionInterface $field_definition) {
+    $table_name = static::_fieldTableName($field_definition);
     $query = $this->database->select($table_name, 't', array('fetch' => \PDO::FETCH_ASSOC))
       ->condition('entity_id', $entity->id())
       ->orderBy('delta');
-    foreach ($field->getColumns() as $column_name => $data) {
-      $query->addField('t', static::_fieldColumnName($field, $column_name), $column_name);
+    foreach ($field_definition->getColumns() as $column_name => $data) {
+      $query->addField('t', static::_fieldColumnName($field_definition, $column_name), $column_name);
     }
     return $query->execute()->fetchAll();
   }
@@ -1307,10 +1301,9 @@ protected function readFieldItemsToPurge(EntityInterface $entity, FieldInstanceC
   /**
    * {@inheritdoc}
    */
-  public function purgeFieldItems(EntityInterface $entity, FieldInstanceConfigInterface $instance) {
-    $field = $instance->getField();
-    $table_name = static::_fieldTableName($field);
-    $revision_name = static::_fieldRevisionTableName($field);
+  public function purgeFieldItems(EntityInterface $entity, FieldDefinitionInterface $field_definition) {
+    $table_name = static::_fieldTableName($field_definition);
+    $revision_name = static::_fieldRevisionTableName($field_definition);
     $this->database->delete($table_name)
       ->condition('entity_id', $entity->id())
       ->execute();
@@ -1322,9 +1315,9 @@ public function purgeFieldItems(EntityInterface $entity, FieldInstanceConfigInte
   /**
    * {@inheritdoc}
    */
-  public function onFieldPurge(FieldConfigInterface $field) {
-    $table_name = static::_fieldTableName($field);
-    $revision_name = static::_fieldRevisionTableName($field);
+  public function onFieldPurge(FieldStorageDefinitionInterface $storage_definition) {
+    $table_name = static::_fieldTableName($storage_definition);
+    $revision_name = static::_fieldRevisionTableName($storage_definition);
     $this->database->schema()->dropTable($table_name);
     $this->database->schema()->dropTable($revision_name);
   }
@@ -1336,8 +1329,8 @@ public function onFieldPurge(FieldConfigInterface $field) {
    * strongly discouraged. This function is not considered part of the public
    * API and modules relying on it might break even in minor releases.
    *
-   * @param \Drupal\field\FieldConfigInterface $field
-   *   The field object
+   * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition
+   *   The field storage definition.
    * @param array $schema
    *   The field schema array. Mandatory for upgrades, omit otherwise.
    *
@@ -1347,17 +1340,17 @@ public function onFieldPurge(FieldConfigInterface $field) {
    *
    * @see hook_schema()
    */
-  public static function _fieldSqlSchema(FieldConfigInterface $field, array $schema = NULL) {
-    if ($field->deleted) {
-      $description_current = "Data storage for deleted field {$field->uuid()} ({$field->entity_type}, {$field->getName()}).";
-      $description_revision = "Revision archive storage for deleted field {$field->uuid()} ({$field->entity_type}, {$field->getName()}).";
+  public static function _fieldSqlSchema(FieldStorageDefinitionInterface $storage_definition, array $schema = NULL) {
+    if ($storage_definition->deleted) {
+      $description_current = "Data storage for deleted field {$storage_definition->getUniqueStorageIdentifier()} ({$storage_definition->getTargetEntityTypeId()}, {$storage_definition->getName()}).";
+      $description_revision = "Revision archive storage for deleted field {$storage_definition->getUniqueStorageIdentifier()} ({$storage_definition->getTargetEntityTypeId()}, {$storage_definition->getName()}).";
     }
     else {
-      $description_current = "Data storage for {$field->entity_type} field {$field->getName()}.";
-      $description_revision = "Revision archive storage for {$field->entity_type} field {$field->getName()}.";
+      $description_current = "Data storage for {$storage_definition->getTargetEntityTypeId()} field {$storage_definition->getName()}.";
+      $description_revision = "Revision archive storage for {$storage_definition->getTargetEntityTypeId()} field {$storage_definition->getName()}.";
     }
 
-    $entity_type_id = $field->entity_type;
+    $entity_type_id = $storage_definition->getTargetEntityTypeId();
     $entity_manager = \Drupal::entityManager();
     $entity_type = $entity_manager->getDefinition($entity_type_id);
     $definitions = $entity_manager->getBaseFieldDefinitions($entity_type_id);
@@ -1445,39 +1438,39 @@ public static function _fieldSqlSchema(FieldConfigInterface $field, array $schem
     );
 
     if (!$schema) {
-      $schema = $field->getSchema();
+      $schema = $storage_definition->getSchema();
     }
 
     // Add field columns.
     foreach ($schema['columns'] as $column_name => $attributes) {
-      $real_name = static::_fieldColumnName($field, $column_name);
+      $real_name = static::_fieldColumnName($storage_definition, $column_name);
       $current['fields'][$real_name] = $attributes;
     }
 
     // Add indexes.
     foreach ($schema['indexes'] as $index_name => $columns) {
-      $real_name = static::_fieldIndexName($field, $index_name);
+      $real_name = static::_fieldIndexName($storage_definition, $index_name);
       foreach ($columns as $column_name) {
         // Indexes can be specified as either a column name or an array with
         // column name and length. Allow for either case.
         if (is_array($column_name)) {
           $current['indexes'][$real_name][] = array(
-            static::_fieldColumnName($field, $column_name[0]),
+            static::_fieldColumnName($storage_definition, $column_name[0]),
             $column_name[1],
           );
         }
         else {
-          $current['indexes'][$real_name][] = static::_fieldColumnName($field, $column_name);
+          $current['indexes'][$real_name][] = static::_fieldColumnName($storage_definition, $column_name);
         }
       }
     }
 
     // Add foreign keys.
     foreach ($schema['foreign keys'] as $specifier => $specification) {
-      $real_name = static::_fieldIndexName($field, $specifier);
+      $real_name = static::_fieldIndexName($storage_definition, $specifier);
       $current['foreign keys'][$real_name]['table'] = $specification['table'];
       foreach ($specification['columns'] as $column_name => $referenced) {
-        $sql_storage_column = static::_fieldColumnName($field, $column_name);
+        $sql_storage_column = static::_fieldColumnName($storage_definition, $column_name);
         $current['foreign keys'][$real_name]['columns'][$sql_storage_column] = $referenced;
       }
     }
@@ -1490,8 +1483,8 @@ public static function _fieldSqlSchema(FieldConfigInterface $field, array $schem
     $revision['fields']['revision_id']['description'] = 'The entity revision id this data is attached to';
 
     return array(
-      static::_fieldTableName($field) => $current,
-      static::_fieldRevisionTableName($field) => $revision,
+      static::_fieldTableName($storage_definition) => $current,
+      static::_fieldRevisionTableName($storage_definition) => $revision,
     );
   }
 
@@ -1505,23 +1498,28 @@ public static function _fieldSqlSchema(FieldConfigInterface $field, array $schem
    * support. Always call entity_load() before using the data found in the
    * table.
    *
-   * @param \Drupal\field\FieldConfigInterface $field
-   *   The field object.
+   * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition
+   *   The field storage definition.
    *
    * @return string
    *   A string containing the generated name for the database table.
-   *
    */
-  static public function _fieldTableName(FieldConfigInterface $field) {
-    if ($field->deleted) {
+  static public function _fieldTableName(FieldStorageDefinitionInterface $storage_definition) {
+    // Be sure to get the field config object so we check the right deleted
+    // property. @todo: Fix properly.
+    if ($storage_definition instanceof FieldInstanceConfigInterface) {
+      $storage_definition = $storage_definition->getField();
+    }
+    if ($storage_definition->deleted) {
       // When a field is a deleted, the table is renamed to
       // {field_deleted_data_FIELD_UUID}. To make sure we don't end up with
-      // table names longer than 64 characters, we hash the uuid and return the
-      // first 10 characters so we end up with a short unique ID.
-      return "field_deleted_data_" . substr(hash('sha256', $field->uuid()), 0, 10);
+      // table names longer than 64 characters, we hash the unique storage
+      // identifier and return the first 10 characters so we end up with a short
+      // unique ID.
+      return "field_deleted_data_" . substr(hash('sha256', $storage_definition->getUniqueStorageIdentifier()), 0, 10);
     }
     else {
-      return static::_generateFieldTableName($field, FALSE);
+      return static::_generateFieldTableName($storage_definition, FALSE);
     }
   }
 
@@ -1535,22 +1533,28 @@ static public function _fieldTableName(FieldConfigInterface $field) {
    * support. Always call entity_load() before using the data found in the
    * table.
    *
-   * @param \Drupal\field\FieldConfigInterface $field
-   *   The field object.
+   * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition
+   *   The field storage definition.
    *
    * @return string
    *   A string containing the generated name for the database table.
    */
-  static public function _fieldRevisionTableName(FieldConfigInterface $field) {
-    if ($field->deleted) {
+  static public function _fieldRevisionTableName(FieldStorageDefinitionInterface $storage_definition) {
+    // Be sure to get the field config object so we check the right deleted
+    // property. @todo: Fix properly.
+    if ($storage_definition instanceof FieldInstanceConfigInterface) {
+      $storage_definition = $storage_definition->getField();
+    }
+    if ($storage_definition->deleted) {
       // When a field is a deleted, the table is renamed to
       // {field_deleted_revision_FIELD_UUID}. To make sure we don't end up with
-      // table names longer than 64 characters, we hash the uuid and return the
-      // first 10 characters so we end up with a short unique ID.
-      return "field_deleted_revision_" . substr(hash('sha256', $field->uuid()), 0, 10);
+      // table names longer than 64 characters, we hash the unique storage
+      // identifier and return the first 10 characters so we end up with a short
+      // unique ID.
+      return "field_deleted_revision_" . substr(hash('sha256', $storage_definition->getUniqueStorageIdentifier()), 0, 10);
     }
     else {
-      return static::_generateFieldTableName($field, TRUE);
+      return static::_generateFieldTableName($storage_definition, TRUE);
     }
   }
 
@@ -1560,17 +1564,17 @@ static public function _fieldRevisionTableName(FieldConfigInterface $field) {
    * The method accounts for a maximum table name length of 64 characters, and
    * takes care of disambiguation.
    *
-   * @param \Drupal\field\FieldConfigInterface $field
-   *   The field object.
+   * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition
+   *   The field storage definition.
    * @param bool $revision
    *   TRUE for revision table, FALSE otherwise.
    *
    * @return string
    *   The final table name.
    */
-  static protected function _generateFieldTableName(FieldConfigInterface $field, $revision) {
+  static protected function _generateFieldTableName(FieldStorageDefinitionInterface $storage_definition, $revision) {
     $separator = $revision ? '_revision__' : '__';
-    $table_name = $field->entity_type . $separator .  $field->name;
+    $table_name = $storage_definition->getTargetEntityTypeId() . $separator .  $storage_definition->getName();
     // Limit the string to 48 characters, keeping a 16 characters margin for db
     // prefixes.
     if (strlen($table_name) > 48) {
@@ -1578,8 +1582,8 @@ static protected function _generateFieldTableName(FieldConfigInterface $field, $
       // field UUID.
       $separator = $revision ? '_r__' : '__';
       // Truncate to the same length for the current and revision tables.
-      $entity_type = substr($field->entity_type, 0, 34);
-      $field_hash = substr(hash('sha256', $field->uuid), 0, 10);
+      $entity_type = substr($storage_definition->getTargetEntityTypeId(), 0, 34);
+      $field_hash = substr(hash('sha256', $storage_definition->getUniqueStorageIdentifier()), 0, 10);
       $table_name = $entity_type . $separator . $field_hash;
     }
     return $table_name;
@@ -1592,8 +1596,8 @@ static protected function _generateFieldTableName(FieldConfigInterface $field, $
    * strongly discouraged. This function is not considered part of the public
    * API and modules relying on it might break even in minor releases.
    *
-   * @param \Drupal\field\FieldConfigInterface $field
-   *   The field structure
+   * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition
+   *   The field storage definition.
    * @param string $index
    *   The name of the index.
    *
@@ -1601,8 +1605,8 @@ static protected function _generateFieldTableName(FieldConfigInterface $field, $
    *   A string containing a generated index name for a field data table that is
    *   unique among all other fields.
    */
-  static public function _fieldIndexName(FieldConfigInterface $field, $index) {
-    return $field->getName() . '_' . $index;
+  static public function _fieldIndexName(FieldStorageDefinitionInterface $storage_definition, $index) {
+    return $storage_definition->getName() . '_' . $index;
   }
 
   /**
@@ -1615,8 +1619,8 @@ static public function _fieldIndexName(FieldConfigInterface $field, $index) {
    * support. Always call entity_load() before using the data found in the
    * table.
    *
-   * @param \Drupal\field\FieldConfigInterface $field
-   *   The field object.
+   * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition
+   *   The field storage definition.
    * @param string $column
    *   The name of the column.
    *
@@ -1624,8 +1628,8 @@ static public function _fieldIndexName(FieldConfigInterface $field, $index) {
    *   A string containing a generated column name for a field data table that is
    *   unique among all other fields.
    */
-  static public function _fieldColumnName(FieldConfigInterface $field, $column) {
-    return in_array($column, FieldConfig::getReservedColumns()) ? $column : $field->getName() . '_' . $column;
+  static public function _fieldColumnName(FieldStorageDefinitionInterface $storage_definition, $column) {
+    return in_array($column, FieldConfig::getReservedColumns()) ? $column : $storage_definition->getName() . '_' . $column;
   }
 
 }
diff --git a/core/lib/Drupal/Core/Entity/ContentEntityNullStorage.php b/core/lib/Drupal/Core/Entity/ContentEntityNullStorage.php
index 98dbd2f..00d3cab 100644
--- a/core/lib/Drupal/Core/Entity/ContentEntityNullStorage.php
+++ b/core/lib/Drupal/Core/Entity/ContentEntityNullStorage.php
@@ -8,7 +8,7 @@
 namespace Drupal\Core\Entity;
 
 use Drupal\Core\Entity\Query\QueryException;
-use Drupal\field\FieldInstanceConfigInterface;
+use Drupal\Core\Field\FieldDefinitionInterface;
 
 /**
  * Defines a null entity storage.
@@ -109,13 +109,13 @@ protected function doDeleteFieldItemsRevision(EntityInterface $entity) {
   /**
    * {@inheritdoc}
    */
-  protected function readFieldItemsToPurge(EntityInterface $entity, FieldInstanceConfigInterface $instance) {
+  protected function readFieldItemsToPurge(EntityInterface $entity, FieldDefinitionInterface $field_definition) {
   }
 
   /**
    * {@inheritdoc}
    */
-  protected function purgeFieldItems(EntityInterface $entity, FieldInstanceConfigInterface $instance) {
+  protected function purgeFieldItems(EntityInterface $entity, FieldDefinitionInterface $field_definition) {
   }
 
   /**
diff --git a/core/lib/Drupal/Core/Entity/ContentEntityStorageBase.php b/core/lib/Drupal/Core/Entity/ContentEntityStorageBase.php
index 29c1de9..cf1cd92 100644
--- a/core/lib/Drupal/Core/Entity/ContentEntityStorageBase.php
+++ b/core/lib/Drupal/Core/Entity/ContentEntityStorageBase.php
@@ -8,8 +8,9 @@
 namespace Drupal\Core\Entity;
 
 use Drupal\Component\Utility\String;
+use Drupal\Core\Field\FieldDefinitionInterface;
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
 use Drupal\Core\Cache\Cache;
-use Drupal\field\FieldConfigInterface;
 use Drupal\field\FieldInstanceConfigInterface;
 use Symfony\Component\DependencyInjection\ContainerInterface;
 
@@ -267,32 +268,32 @@ protected function deleteFieldItemsRevision(EntityInterface $entity) {
   /**
    * {@inheritdoc}
    */
-  public function onFieldCreate(FieldConfigInterface $field) { }
+  public function onFieldCreate(FieldStorageDefinitionInterface $storage_definition) { }
 
   /**
    * {@inheritdoc}
    */
-  public function onFieldUpdate(FieldConfigInterface $field) { }
+  public function onFieldUpdate(FieldStorageDefinitionInterface $storage_definition) { }
 
   /**
    * {@inheritdoc}
    */
-  public function onFieldDelete(FieldConfigInterface $field) { }
+  public function onFieldDelete(FieldStorageDefinitionInterface $storage_definition) { }
 
   /**
    * {@inheritdoc}
    */
-  public function onInstanceCreate(FieldInstanceConfigInterface $instance) { }
+  public function onInstanceCreate(FieldDefinitionInterface $field_definition) { }
 
   /**
    * {@inheritdoc}
    */
-  public function onInstanceUpdate(FieldInstanceConfigInterface $instance) { }
+  public function onInstanceUpdate(FieldDefinitionInterface $field_definition) { }
 
   /**
    * {@inheritdoc}
    */
-  public function onInstanceDelete(FieldInstanceConfigInterface $instance) { }
+  public function onInstanceDelete(FieldDefinitionInterface $field_definition) { }
 
   /**
    * {@inheritdoc}
@@ -312,12 +313,12 @@ public function onBundleDelete($bundle) { }
   /**
    * {@inheritdoc}
    */
-  public function onFieldItemsPurge(EntityInterface $entity, FieldInstanceConfigInterface $instance) {
-    if ($values = $this->readFieldItemsToPurge($entity, $instance)) {
-      $items = \Drupal::typedDataManager()->create($instance, $values, $instance->getName(), $entity);
+  public function onFieldItemsPurge(EntityInterface $entity, FieldDefinitionInterface $field_definition) {
+    if ($values = $this->readFieldItemsToPurge($entity, $field_definition)) {
+      $items = \Drupal::typedDataManager()->create($field_definition, $values, $field_definition->getName(), $entity);
       $items->delete();
     }
-    $this->purgeFieldItems($entity, $instance);
+    $this->purgeFieldItems($entity, $field_definition);
   }
 
   /**
@@ -328,29 +329,29 @@ public function onFieldItemsPurge(EntityInterface $entity, FieldInstanceConfigIn
    *
    * @param \Drupal\Core\Entity\EntityInterface $entity
    *   The entity.
-   * @param \Drupal\field\FieldInstanceConfigInterface $instance
+   * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
    *   The field instance.
    *
    * @return array
    *   The field values, in their canonical array format (numerically indexed
    *   array of items, each item being a property/value array).
    */
-  abstract protected function readFieldItemsToPurge(EntityInterface $entity, FieldInstanceConfigInterface $instance);
+  abstract protected function readFieldItemsToPurge(EntityInterface $entity, FieldDefinitionInterface $field_definition);
 
   /**
    * Removes field data from storage during purge.
    *
    * @param EntityInterface $entity
    *   The entity whose values are being purged.
-   * @param FieldInstanceConfigInterface $instance
+   * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
    *   The field whose values are bing purged.
    */
-  abstract protected function purgeFieldItems(EntityInterface $entity, FieldInstanceConfigInterface $instance);
+  abstract protected function purgeFieldItems(EntityInterface $entity, FieldDefinitionInterface $field_definition);
 
   /**
    * {@inheritdoc}
    */
-  public function onFieldPurge(FieldConfigInterface $field) { }
+  public function onFieldPurge(FieldStorageDefinitionInterface $storage_definition) { }
 
   /**
    * Checks translation statuses and invoke the related hooks if needed.
diff --git a/core/lib/Drupal/Core/Entity/EntityForm.php b/core/lib/Drupal/Core/Entity/EntityForm.php
index dcb9aae..e601f3e 100644
--- a/core/lib/Drupal/Core/Entity/EntityForm.php
+++ b/core/lib/Drupal/Core/Entity/EntityForm.php
@@ -73,10 +73,9 @@ public function getBaseFormID() {
    */
   public function getFormId() {
     $entity_type = $this->entity->getEntityTypeId();
-    $bundle = $this->entity->bundle();
     $form_id = $entity_type;
-    if ($bundle != $entity_type) {
-      $form_id = $bundle . '_' . $form_id;
+    if ($this->entity->getEntityType()->hasKey('bundle')) {
+      $form_id = $this->entity->bundle() . '_' . $form_id;
     }
     if ($this->operation != 'default') {
       $form_id = $form_id . '_' . $this->operation;
diff --git a/core/lib/Drupal/Core/Entity/FieldableEntityStorageInterface.php b/core/lib/Drupal/Core/Entity/FieldableEntityStorageInterface.php
index 2998c21..fa83ad2 100644
--- a/core/lib/Drupal/Core/Entity/FieldableEntityStorageInterface.php
+++ b/core/lib/Drupal/Core/Entity/FieldableEntityStorageInterface.php
@@ -7,68 +7,68 @@
 
 namespace Drupal\Core\Entity;
 
-use Drupal\field\FieldConfigInterface;
-use Drupal\field\FieldInstanceConfigInterface;
+use Drupal\Core\Field\FieldDefinitionInterface;
+use Drupal\Core\Field\FieldStorageDefinitionInterface;
 
 interface FieldableEntityStorageInterface extends EntityStorageInterface {
 
   /**
-   * Allows reaction to the creation of a configurable field.
+   * Allows reaction to the creation of a field.
    *
-   * @param \Drupal\field\FieldConfigInterface $field
+   * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition
    *   The field being created.
    */
-  public function onFieldCreate(FieldConfigInterface $field);
+  public function onFieldCreate(FieldStorageDefinitionInterface $storage_definition);
 
   /**
-   * Allows reaction to the update of a configurable field.
+   * Allows reaction to the update of a field.
    *
-   * @param \Drupal\field\FieldConfigInterface $field
+   * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition
    *   The field being updated.
    */
-  public function onFieldUpdate(FieldConfigInterface $field);
+  public function onFieldUpdate(FieldStorageDefinitionInterface $storage_definition);
 
   /**
-   * Allows reaction to the deletion of a configurable field.
+   * Allows reaction to the deletion of a field.
    *
    * Stored values should not be wiped at once, but marked as 'deleted' so that
    * they can go through a proper purge process later on.
    *
-   * @param \Drupal\field\FieldConfigInterface $field
+   * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition
    *   The field being deleted.
    *
    * @see fieldPurgeData()
    */
-  public function onFieldDelete(FieldConfigInterface $field);
+  public function onFieldDelete(FieldStorageDefinitionInterface $storage_definition);
 
   /**
-   * Allows reaction to the creation of a configurable field instance.
+   * Allows reaction to the creation of a field.
    *
-   * @param \Drupal\field\FieldInstanceConfigInterface $instance
-   *   The instance being created.
+   * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
+   *   The field being created.
    */
-  public function onInstanceCreate(FieldInstanceConfigInterface $instance);
+  public function onInstanceCreate(FieldDefinitionInterface $field_definition);
 
   /**
-   * Allows reaction to the update of a configurable field instance.
+   * Allows reaction to the update of a field.
    *
-   * @param \Drupal\field\FieldInstanceConfigInterface $instance
-   *   The instance being updated.
+   * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
+   *   The field being updated.
    */
-  public function onInstanceUpdate(FieldInstanceConfigInterface $instance);
+  public function onInstanceUpdate(FieldDefinitionInterface $field_definition);
 
   /**
-   * Allows reaction to the deletion of a configurable field instance.
+   * Allows reaction to the deletion of a field.
    *
    * Stored values should not be wiped at once, but marked as 'deleted' so that
    * they can go through a proper purge process later on.
    *
-   * @param \Drupal\field\FieldInstanceConfigInterface $instance
-   *   The instance being deleted.
+   * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
+   *   The field being deleted.
    *
    * @see fieldPurgeData()
    */
-  public function onInstanceDelete(FieldInstanceConfigInterface $instance);
+  public function onInstanceDelete(FieldDefinitionInterface $field_definition);
 
   /**
    * Allows reaction to a bundle being created.
@@ -81,8 +81,7 @@ public function onBundleCreate($bundle);
   /**
    * Allows reaction to a bundle being renamed.
    *
-   * This method runs before field instance definitions are updated with the new
-   * bundle name.
+   * This method runs before fields are updated with the new bundle name.
    *
    * @param string $bundle
    *   The name of the bundle being renamed.
@@ -94,7 +93,7 @@ public function onBundleRename($bundle, $bundle_new);
   /**
    * Allows reaction to a bundle being deleted.
    *
-   * This method runs before field and instance definitions are deleted.
+   * This method runs before fields are deleted.
    *
    * @param string $bundle
    *   The name of the bundle being deleted.
@@ -109,17 +108,17 @@ public function onBundleDelete($bundle);
    *
    * @param \Drupal\Core\Entity\EntityInterface $entity
    *   The entity whose field data is being purged.
-   * @param \Drupal\field\FieldInstanceConfigInterface $instance
-   *   The deleted field instance whose data is being purged.
+   * @param \Drupal\Core\Field\FieldDefinitionInterface $field_definition
+   *   The deleted field whose data is being purged.
    */
-  public function onFieldItemsPurge(EntityInterface $entity, FieldInstanceConfigInterface $instance);
+  public function onFieldItemsPurge(EntityInterface $entity, FieldDefinitionInterface $field_definition);
 
   /**
-   * Performs final cleanup after all data on all instances has been purged.
+   * Performs final cleanup after all data of a field has been purged.
    *
-   * @param \Drupal\field\FieldConfigInterface $instance
+   * @param \Drupal\Core\Field\FieldStorageDefinitionInterface $storage_definition
    *   The field being purged.
    */
-  public function onFieldPurge(FieldConfigInterface $field);
+  public function onFieldPurge(FieldStorageDefinitionInterface $storage_definition);
 
 }
diff --git a/core/lib/Drupal/Core/Field/FieldDefinition.php b/core/lib/Drupal/Core/Field/FieldDefinition.php
index cfeccf8..5ddd9e7 100644
--- a/core/lib/Drupal/Core/Field/FieldDefinition.php
+++ b/core/lib/Drupal/Core/Field/FieldDefinition.php
@@ -543,4 +543,11 @@ public function setCustomStorage($custom_storage) {
     return $this;
   }
 
+  /**
+   * {@inheritdoc}
+   */
+  public function getUniqueStorageIdentifier() {
+    return $this->getTargetEntityTypeId() . '-' . $this->getName();
+  }
+
 }
diff --git a/core/lib/Drupal/Core/Field/FieldStorageDefinitionInterface.php b/core/lib/Drupal/Core/Field/FieldStorageDefinitionInterface.php
index aa1d90e..eccb7b8 100644
--- a/core/lib/Drupal/Core/Field/FieldStorageDefinitionInterface.php
+++ b/core/lib/Drupal/Core/Field/FieldStorageDefinitionInterface.php
@@ -285,4 +285,11 @@ public function getProvider();
    */
   public function hasCustomStorage();
 
+  /**
+   * Returns the field UUID (Universally Unique Identifier).
+   *
+   * @return string
+   */
+  public function getUniqueStorageIdentifier();
+
 }
diff --git a/core/modules/field/src/Entity/FieldConfig.php b/core/modules/field/src/Entity/FieldConfig.php
index 3f5b787..82fe1d6 100644
--- a/core/modules/field/src/Entity/FieldConfig.php
+++ b/core/modules/field/src/Entity/FieldConfig.php
@@ -790,6 +790,13 @@ public function getMainPropertyName() {
   }
 
   /**
+   * {@inheritdoc}
+   */
+  public function getUniqueStorageIdentifier() {
+    return $this->uuid();
+  }
+
+  /**
    * Helper to retrieve the field item class.
    */
   protected function getFieldItemClass() {
diff --git a/core/modules/field/src/Entity/FieldInstanceConfig.php b/core/modules/field/src/Entity/FieldInstanceConfig.php
index f655a18..2b4ff56 100644
--- a/core/modules/field/src/Entity/FieldInstanceConfig.php
+++ b/core/modules/field/src/Entity/FieldInstanceConfig.php
@@ -821,4 +821,11 @@ public static function loadByName($entity_type_id, $bundle, $field_name) {
     return \Drupal::entityManager()->getStorage('field_instance_config')->load($entity_type_id . '.' . $bundle . '.' . $field_name);
   }
 
+  /**
+   * {@inheritdoc}
+   */
+  public function getUniqueStorageIdentifier() {
+    return $this->field->uuid();
+  }
+
 }
diff --git a/core/tests/Drupal/Tests/Core/Entity/ContentEntityDatabaseStorageTest.php b/core/tests/Drupal/Tests/Core/Entity/ContentEntityDatabaseStorageTest.php
index cc77d6d..b865a55 100644
--- a/core/tests/Drupal/Tests/Core/Entity/ContentEntityDatabaseStorageTest.php
+++ b/core/tests/Drupal/Tests/Core/Entity/ContentEntityDatabaseStorageTest.php
@@ -956,14 +956,16 @@ public function testFieldSqlSchemaForEntityWithStringIdentifier() {
       ->will($this->returnValue($this->fieldDefinitions));
 
     // Define a field definition for a test_field field.
-    $field = $this->getMock('\Drupal\field\FieldConfigInterface');
+    $field = $this->getMock('\Drupal\Core\Field\FieldStorageDefinitionInterface');
     $field->deleted = FALSE;
-    $field->entity_type = 'test_entity';
-    $field->name = 'test_field';
 
     $field->expects($this->any())
       ->method('getName')
-      ->will($this->returnValue('test'));
+      ->will($this->returnValue('test_field'));
+
+    $field->expects($this->any())
+      ->method('getTargetEntityTypeId')
+      ->will($this->returnValue('test_entity'));
 
     $field_schema = array(
       'columns' => array(