Issue #2957425 by tedbow, johndevman, mpotter, tim.plunkett, hawkeye.twolf,...

Issue #2957425 by tedbow, johndevman, mpotter, tim.plunkett, hawkeye.twolf, alexpott, Berdir, samuel.mortenson, xjm, kevincrafts, jibran, amateescu, larowlan, twfahey, EclipseGc, sjerdo, japerry, mtodor, phenaproxima, johnzzon, mglaman: Allow the inline creation of non-reusable Custom Blocks in the layout builder

(cherry picked from commit 4ed41f4e)

core/modules/layout_builder/config/schema/layout_builder.schema.yml

@@ -47,3 +47,20 @@ layout_builder.component:
     additional:
       type: ignore
       label: 'Additional data'
+
+inline_block:
+  type: block_settings
+  label: 'Inline block'
+  mapping:
+    view_mode:
+      type: string
+      lable: 'View mode'
+    block_revision_id:
+      type: integer
+      label: 'Block revision ID'
+    block_serialized:
+      type: string
+      label: 'Serialized block'
+
+block.settings.inline_block:*:
+  type: inline_block

core/modules/layout_builder/layout_builder.install

@@ -6,6 +6,8 @@
  */
 
 use Drupal\Core\Cache\Cache;
+use Drupal\Core\Database\Database;
+use Drupal\Core\Entity\EntityTypeInterface;
 use Drupal\layout_builder\Entity\LayoutBuilderEntityViewDisplay;
 use Drupal\layout_builder\Section;
 
@@ -62,3 +64,75 @@ function layout_builder_update_8601(&$sandbox) {
 
   $sandbox['#finished'] = empty($sandbox['ids']) ? 1 : ($sandbox['count'] - count($sandbox['ids'])) / $sandbox['count'];
 }
+
+/**
+ * Implements hook_schema().
+ */
+function layout_builder_schema() {
+  $schema['inline_block_usage'] = [
+    'description' => 'Track where a block_content entity is used.',
+    'fields' => [
+      'block_content_id' => [
+        'description' => 'The block_content entity ID.',
+        'type' => 'int',
+        'unsigned' => TRUE,
+        'not null' => TRUE,
+      ],
+      'layout_entity_type' => [
+        'description' => 'The entity type of the parent entity.',
+        'type' => 'varchar_ascii',
+        'length' => EntityTypeInterface::ID_MAX_LENGTH,
+        'not null' => FALSE,
+        'default' => '',
+      ],
+      'layout_entity_id' => [
+        'description' => 'The ID of the parent entity.',
+        'type' => 'varchar_ascii',
+        'length' => 128,
+        'not null' => FALSE,
+        'default' => 0,
+      ],
+    ],
+    'primary key' => ['block_content_id'],
+    'indexes' => [
+      'type_id' => ['layout_entity_type', 'layout_entity_id'],
+    ],
+  ];
+  return $schema;
+}
+
+/**
+ * Create the 'inline_block_usage' table.
+ */
+function layout_builder_update_8602() {
+  $inline_block_usage = [
+    'description' => 'Track where a block_content entity is used.',
+    'fields' => [
+      'block_content_id' => [
+        'description' => 'The block_content entity ID.',
+        'type' => 'int',
+        'unsigned' => TRUE,
+        'not null' => TRUE,
+      ],
+      'layout_entity_type' => [
+        'description' => 'The entity type of the parent entity.',
+        'type' => 'varchar_ascii',
+        'length' => EntityTypeInterface::ID_MAX_LENGTH,
+        'not null' => FALSE,
+        'default' => '',
+      ],
+      'layout_entity_id' => [
+        'description' => 'The ID of the parent entity.',
+        'type' => 'varchar_ascii',
+        'length' => 128,
+        'not null' => FALSE,
+        'default' => 0,
+      ],
+    ],
+    'primary key' => ['block_content_id'],
+    'indexes' => [
+      'type_id' => ['layout_entity_type', 'layout_entity_id'],
+    ],
+  ];
+  Database::getConnection()->schema()->createTable('inline_block_usage', $inline_block_usage);
+}

core/modules/layout_builder/layout_builder.module

@@ -5,6 +5,7 @@
  * Provides hook implementations for Layout Builder.
  */
 
+use Drupal\Core\Entity\EntityInterface;
 use Drupal\Core\Form\FormStateInterface;
 use Drupal\Core\Routing\RouteMatchInterface;
 use Drupal\Core\Url;
@@ -12,10 +13,12 @@
 use Drupal\layout_builder\Entity\LayoutBuilderEntityViewDisplay;
 use Drupal\layout_builder\Entity\LayoutBuilderEntityViewDisplayStorage;
 use Drupal\layout_builder\Form\LayoutBuilderEntityViewDisplayForm;
-use Drupal\Core\Entity\EntityInterface;
 use Drupal\Core\Entity\Display\EntityViewDisplayInterface;
 use Drupal\layout_builder\Entity\LayoutEntityDisplayInterface;
 use Drupal\layout_builder\Plugin\Block\ExtraFieldBlock;
+use Drupal\layout_builder\InlineBlockEntityOperations;
+use Drupal\Core\Session\AccountInterface;
+use Drupal\Core\Access\AccessResult;
 
 /**
  * Implements hook_help().
@@ -134,3 +137,68 @@ function layout_builder_module_implements_alter(&$implementations, $hook) {
     $implementations['layout_builder'] = $group;
   }
 }
+
+/**
+ * Implements hook_entity_presave().
+ */
+function layout_builder_entity_presave(EntityInterface $entity) {
+  if (\Drupal::moduleHandler()->moduleExists('block_content')) {
+    /** @var \Drupal\layout_builder\InlineBlockEntityOperations $entity_operations */
+    $entity_operations = \Drupal::classResolver(InlineBlockEntityOperations::class);
+    $entity_operations->handlePreSave($entity);
+  }
+}
+
+/**
+ * Implements hook_entity_delete().
+ */
+function layout_builder_entity_delete(EntityInterface $entity) {
+  if (\Drupal::moduleHandler()->moduleExists('block_content')) {
+    /** @var \Drupal\layout_builder\InlineBlockEntityOperations $entity_operations */
+    $entity_operations = \Drupal::classResolver(InlineBlockEntityOperations::class);
+    $entity_operations->handleEntityDelete($entity);
+  }
+}
+
+/**
+ * Implements hook_cron().
+ */
+function layout_builder_cron() {
+  if (\Drupal::moduleHandler()->moduleExists('block_content')) {
+    /** @var \Drupal\layout_builder\InlineBlockEntityOperations $entity_operations */
+    $entity_operations = \Drupal::classResolver(InlineBlockEntityOperations::class);
+    $entity_operations->removeUnused();
+  }
+}
+
+/**
+ * Implements hook_plugin_filter_TYPE_alter().
+ */
+function layout_builder_plugin_filter_block_alter(array &$definitions, array $extra, $consumer) {
+  // @todo Determine the 'inline_block' blocks should be allowed outside
+  //   of layout_builder https://www.drupal.org/node/2979142.
+  if ($consumer !== 'layout_builder') {
+    foreach ($definitions as $id => $definition) {
+      if ($definition['id'] === 'inline_block') {
+        unset($definitions[$id]);
+      }
+    }
+  }
+}
+
+/**
+ * Implements hook_ENTITY_TYPE_access().
+ */
+function layout_builder_block_content_access(EntityInterface $entity, $operation, AccountInterface $account) {
+  /** @var \Drupal\block_content\BlockContentInterface $entity */
+  if ($operation === 'view' || $entity->isReusable() || empty(\Drupal::service('inline_block.usage')->getUsage($entity->id()))) {
+    // If the operation is 'view' or this is reusable block or if this is
+    // non-reusable that isn't used by this module then don't alter the access.
+    return AccessResult::neutral();
+  }
+
+  if ($account->hasPermission('configure any layout')) {
+    return AccessResult::allowed();
+  }
+  return AccessResult::forbidden();
+}

core/modules/layout_builder/layout_builder.services.yml

@@ -43,3 +43,6 @@ services:
   logger.channel.layout_builder:
     parent: logger.channel_base
     arguments: ['layout_builder']
+  inline_block.usage:
+    class: Drupal\layout_builder\InlineBlockUsage
+    arguments: ['@database']

core/modules/layout_builder/src/Access/LayoutPreviewAccessAllowed.php

+<?php
+
+namespace Drupal\layout_builder\Access;
+
+use Drupal\Core\Access\AccessibleInterface;
+use Drupal\Core\Access\AccessResult;
+use Drupal\Core\Session\AccountInterface;
+
+/**
+ * Accessible class to allow access for inline blocks in the Layout Builder.
+ *
+ * @internal
+ */
+class LayoutPreviewAccessAllowed implements AccessibleInterface {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function access($operation, AccountInterface $account = NULL, $return_as_object = FALSE) {
+    if ($operation === 'view') {
+      return $return_as_object ? AccessResult::allowed() : TRUE;
+    }
+    // The layout builder preview should only need 'view' access.
+    return $return_as_object ? AccessResult::forbidden() : FALSE;
+  }
+
+}

core/modules/layout_builder/src/EventSubscriber/BlockComponentRenderArray.php

@@ -2,9 +2,11 @@
 
 namespace Drupal\layout_builder\EventSubscriber;
 
+use Drupal\block_content\Access\RefinableDependentAccessInterface;
 use Drupal\Core\Access\AccessResult;
 use Drupal\Core\Block\BlockPluginInterface;
 use Drupal\Core\Session\AccountInterface;
+use Drupal\layout_builder\Access\LayoutPreviewAccessAllowed;
 use Drupal\layout_builder\Event\SectionComponentBuildRenderArrayEvent;
 use Drupal\layout_builder\LayoutBuilderEvents;
 use Symfony\Component\EventDispatcher\EventSubscriberInterface;
@@ -56,6 +58,24 @@ public function onBuildRender(SectionComponentBuildRenderArrayEvent $event) {
       return;
     }
 
+    // Set block access dependency even if we are not checking access on
+    // this level. The block itself may render another
+    // RefinableDependentAccessInterface object and need to pass on this value.
+    if ($block instanceof RefinableDependentAccessInterface) {
+      $contexts = $event->getContexts();
+      if (isset($contexts['layout_builder.entity'])) {
+        if ($entity = $contexts['layout_builder.entity']->getContextValue()) {
+          if ($event->inPreview()) {
+            // If previewing in Layout Builder allow access.
+            $block->setAccessDependency(new LayoutPreviewAccessAllowed());
+          }
+          else {
+            $block->setAccessDependency($entity);
+          }
+        }
+      }
+    }
+
     // Only check access if the component is not being previewed.
     if ($event->inPreview()) {
       $access = AccessResult::allowed()->setCacheMaxAge(0);

core/modules/layout_builder/src/EventSubscriber/SetInlineBlockDependency.php

+<?php
+
+namespace Drupal\layout_builder\EventSubscriber;
+
+use Drupal\block_content\BlockContentEvents;
+use Drupal\block_content\BlockContentInterface;
+use Drupal\block_content\Event\BlockContentGetDependencyEvent;
+use Drupal\Core\Database\Connection;
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\layout_builder\InlineBlockUsage;
+use Drupal\layout_builder\LayoutEntityHelperTrait;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+
+/**
+ * An event subscriber that returns an access dependency for inline blocks.
+ *
+ * When used within the layout builder the access dependency for inline blocks
+ * will be explicitly set but if access is evaluated outside of the layout
+ * builder then the dependency may not have been set.
+ *
+ * A known example of when the access dependency will not have been set is when
+ * determining 'view' or 'download' access to a file entity that is attached
+ * to a content block via a field that is using the private file system. The
+ * file access handler will evaluate access on the content block without setting
+ * the dependency.
+ *
+ * @internal
+ *
+ * @see \Drupal\file\FileAccessControlHandler::checkAccess()
+ * @see \Drupal\block_content\BlockContentAccessControlHandler::checkAccess()
+ */
+class SetInlineBlockDependency implements EventSubscriberInterface {
+
+  use LayoutEntityHelperTrait;
+
+  /**
+   * The entity type manager.
+   *
+   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
+   */
+  protected $entityTypeManager;
+
+  /**
+   * The database connection.
+   *
+   * @var \Drupal\Core\Database\Connection
+   */
+  protected $database;
+
+  /**
+   * The inline block usage service.
+   *
+   * @var \Drupal\layout_builder\InlineBlockUsage
+   */
+  protected $usage;
+
+  /**
+   * Constructs SetInlineBlockDependency object.
+   *
+   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
+   *   The entity type manager.
+   * @param \Drupal\Core\Database\Connection $database
+   *   The database connection.
+   * @param \Drupal\layout_builder\InlineBlockUsage $usage
+   *   The inline block usage service.
+   */
+  public function __construct(EntityTypeManagerInterface $entity_type_manager, Connection $database, InlineBlockUsage $usage) {
+    $this->entityTypeManager = $entity_type_manager;
+    $this->database = $database;
+    $this->usage = $usage;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function getSubscribedEvents() {
+    return [
+      BlockContentEvents::BLOCK_CONTENT_GET_DEPENDENCY => 'onGetDependency',
+    ];
+  }
+
+  /**
+   * Handles the BlockContentEvents::INLINE_BLOCK_GET_DEPENDENCY event.
+   *
+   * @param \Drupal\block_content\Event\BlockContentGetDependencyEvent $event
+   *   The event.
+   */
+  public function onGetDependency(BlockContentGetDependencyEvent $event) {
+    if ($dependency = $this->getInlineBlockDependency($event->getBlockContentEntity())) {
+      $event->setAccessDependency($dependency);
+    }
+  }
+
+  /**
+   * Get the access dependency of an inline block.
+   *
+   * If the block is used in an entity that entity will be returned as the
+   * dependency.
+   *
+   * For revisionable entities the entity will only be returned if it is used in
+   * the latest revision of the entity. For inline blocks that are not used in
+   * the latest revision but are used in a previous revision the entity will not
+   * be returned because calling
+   * \Drupal\Core\Access\AccessibleInterface::access() will only check access on
+   * the latest revision. Therefore if the previous revision of the entity was
+   * returned as the dependency access would be granted to inline block
+   * regardless of whether the user has access to the revision in which the
+   * inline block was used.
+   *
+   * @param \Drupal\block_content\BlockContentInterface $block_content
+   *   The block content entity.
+   *
+   * @return \Drupal\Core\Entity\EntityInterface|null
+   *   Returns the layout dependency.
+   *
+   * @see \Drupal\block_content\BlockContentAccessControlHandler::checkAccess()
+   * @see \Drupal\layout_builder\EventSubscriber\BlockComponentRenderArray::onBuildRender()
+   */
+  protected function getInlineBlockDependency(BlockContentInterface $block_content) {
+    $layout_entity_info = $this->usage->getUsage($block_content->id());
+    if (empty($layout_entity_info)) {
+      // If the block does not have usage information then we cannot set a
+      // dependency. It may be used by another module besides layout builder.
+      return NULL;
+    }
+    /** @var \Drupal\layout_builder\InlineBlockUsage $usage */
+    $layout_entity_storage = $this->entityTypeManager->getStorage($layout_entity_info->layout_entity_type);
+    $layout_entity = $layout_entity_storage->load($layout_entity_info->layout_entity_id);
+    if ($this->isLayoutCompatibleEntity($layout_entity)) {
+      if ($this->isBlockRevisionUsedInEntity($layout_entity, $block_content)) {
+        return $layout_entity;
+      }
+
+    }
+    return NULL;
+  }
+
+  /**
+   * Determines if a block content revision is used in an entity.
+   *
+   * @param \Drupal\Core\Entity\EntityInterface $layout_entity
+   *   The layout entity.
+   * @param \Drupal\block_content\BlockContentInterface $block_content
+   *   The block content revision.
+   *
+   * @return bool
+   *   TRUE if the block content revision is used as an inline block in the
+   *   layout entity.
+   */
+  protected function isBlockRevisionUsedInEntity(EntityInterface $layout_entity, BlockContentInterface $block_content) {
+    $sections_blocks_revision_ids = $this->getInlineBlockRevisionIdsInSections($this->getEntitySections($layout_entity));
+    return in_array($block_content->getRevisionId(), $sections_blocks_revision_ids);
+  }
+
+}

core/modules/layout_builder/src/Form/RevertOverridesForm.php

@@ -103,6 +103,10 @@ public function buildForm(array $form, FormStateInterface $form_state, SectionSt
    * {@inheritdoc}
    */
   public function submitForm(array &$form, FormStateInterface $form_state) {
+    // Ensure the section storage is loaded from the database.
+    // @todo Remove after https://www.drupal.org/node/2970801.
+    $this->sectionStorage = \Drupal::service('plugin.manager.layout_builder.section_storage')->loadFromStorageId($this->sectionStorage->getStorageType(), $this->sectionStorage->getStorageId());
+
     // Remove all sections.
     while ($this->sectionStorage->count()) {
       $this->sectionStorage->removeSection(0);

core/modules/layout_builder/src/InlineBlockEntityOperations.php

+<?php
+
+namespace Drupal\layout_builder;
+
+use Drupal\Core\Database\Connection;
+use Drupal\Core\DependencyInjection\ContainerInjectionInterface;
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\Core\Entity\RevisionableInterface;
+use Drupal\layout_builder\Plugin\Block\InlineBlock;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Defines a class for reacting to entity events related to Inline Blocks.
+ *
+ * @internal
+ */
+class InlineBlockEntityOperations implements ContainerInjectionInterface {
+
+  use LayoutEntityHelperTrait;
+
+  /**
+   * Inline block usage tracking service.
+   *
+   * @var \Drupal\layout_builder\InlineBlockUsage
+   */
+  protected $usage;
+
+  /**
+   * The block content storage.
+   *
+   * @var \Drupal\Core\Entity\EntityStorageInterface
+   */
+  protected $blockContentStorage;
+
+  /**
+   * The entity type manager.
+   *
+   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
+   */
+  protected $entityTypeManager;
+
+  /**
+   * Constructs a new EntityOperations object.
+   *
+   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entityTypeManager
+   *   The entity type manager service.
+   * @param \Drupal\layout_builder\InlineBlockUsage $usage
+   *   Inline block usage tracking service.
+   * @param \Drupal\Core\Database\Connection $database
+   *   The database connection.
+   */
+  public function __construct(EntityTypeManagerInterface $entityTypeManager, InlineBlockUsage $usage, Connection $database) {
+    $this->entityTypeManager = $entityTypeManager;
+    $this->blockContentStorage = $entityTypeManager->getStorage('block_content');
+    $this->usage = $usage;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container) {
+    return new static(
+      $container->get('entity_type.manager'),
+      $container->get('inline_block.usage'),
+      $container->get('database')
+    );
+  }
+
+  /**
+   * Remove all unused inline blocks on save.
+   *
+   * Entities that were used in prevision revisions will be removed if not
+   * saving a new revision.
+   *
+   * @param \Drupal\Core\Entity\EntityInterface $entity
+   *   The parent entity.
+   */
+  protected function removeUnusedForEntityOnSave(EntityInterface $entity) {
+    // If the entity is new or '$entity->original' is not set then there will
+    // not be any unused inline blocks to remove.
+    // If this is a revisionable entity then do not remove inline blocks. They
+    // could be referenced in previous revisions even if this is not a new
+    // revision.
+    if ($entity->isNew() || !isset($entity->original) || $entity instanceof RevisionableInterface) {
+      return;
+    }
+    $sections = $this->getEntitySections($entity);
+    // If this is a layout override and there are no sections then it is a new
+    // override.
+    if ($this->isEntityUsingFieldOverride($entity) && empty($sections)) {
+      return;
+    }
+
+    // Delete and remove the usage for inline blocks that were removed.
+    if ($removed_block_ids = $this->getRemovedBlockIds($entity)) {
+      $this->deleteBlocksAndUsage($removed_block_ids);
+    }
+  }
+
+  /**
+   * Gets the IDs of the inline blocks that were removed.
+   *
+   * @param \Drupal\Core\Entity\EntityInterface $entity
+   *   The layout entity.
+   *
+   * @return int[]
+   *   The block content IDs that were removed.
+   */
+  protected function getRemovedBlockIds(EntityInterface $entity) {
+    $original_sections = $this->getEntitySections($entity->original);
+    $current_sections = $this->getEntitySections($entity);
+    // Avoid un-needed conversion from revision IDs to block content IDs by
+    // first determining if there are any revisions in the original that are not
+    // also in the current sections.
+    $current_block_content_revision_ids = $this->getInlineBlockRevisionIdsInSections($current_sections);
+    $original_block_content_revision_ids = $this->getInlineBlockRevisionIdsInSections($original_sections);
+    if ($unused_original_revision_ids = array_diff($original_block_content_revision_ids, $current_block_content_revision_ids)) {
+      // If there are any revisions in the original that aren't in the current
+      // there may some blocks that need to be removed.
+      $current_block_content_ids = $this->getBlockIdsForRevisionIds($current_block_content_revision_ids);
+      $unused_original_block_content_ids = $this->getBlockIdsForRevisionIds($unused_original_revision_ids);
+      return array_diff($unused_original_block_content_ids, $current_block_content_ids);
+    }
+    return [];
+  }
+
+  /**
+   * Handles entity tracking on deleting a parent entity.
+   *
+   * @param \Drupal\Core\Entity\EntityInterface $entity
+   *   The parent entity.
+   */
+  public function handleEntityDelete(EntityInterface $entity) {
+    if ($this->isLayoutCompatibleEntity($entity)) {
+      $this->usage->removeByLayoutEntity($entity);
+    }
+  }
+
+  /**
+   * Handles saving a parent entity.
+   *
+   * @param \Drupal\Core\Entity\EntityInterface $entity
+   *   The parent entity.
+   */
+  public function handlePreSave(EntityInterface $entity) {
+    if (!$this->isLayoutCompatibleEntity($entity)) {
+      return;
+    }
+    $duplicate_blocks = FALSE;
+
+    if ($sections = $this->getEntitySections($entity)) {
+      if ($this->isEntityUsingFieldOverride($entity)) {
+        if (!$entity->isNew() && isset($entity->original)) {
+          if (empty($this->getEntitySections($entity->original))) {
+            // If there were no sections in the original entity then this is a
+            // new override from a default and the blocks need to be duplicated.
+            $duplicate_blocks = TRUE;
+          }
+        }
+      }
+      $new_revision = FALSE;
+      if ($entity instanceof RevisionableInterface) {
+        // If the parent entity will have a new revision create a new revision
+        // of the block.
+        // @todo Currently revisions are never created for the parent entity.
+        //   This will be fixed in https://www.drupal.org/node/2937199.
+        //   To work around this always make a revision when the parent entity
+        //   is an instance of RevisionableInterface. After the issue is fixed
+        //   only create a new revision if '$entity->isNewRevision()'.
+        $new_revision = TRUE;
+      }
+
+      foreach ($this->getInlineBlockComponents($sections) as $component) {
+        $this->saveInlineBlockComponent($entity, $component, $new_revision, $duplicate_blocks);
+      }
+    }
+    $this->removeUnusedForEntityOnSave($entity);
+  }
+
+  /**
+   * Gets a block ID for an inline block plugin.
+   *
+   * @param \Drupal\layout_builder\Plugin\Block\InlineBlock $block_plugin
+   *   The inline block plugin.
+   *
+   * @return int
+   *   The block content ID or null none available.
+   */
+  protected function getPluginBlockId(InlineBlock $block_plugin) {
+    $configuration = $block_plugin->getConfiguration();
+    if (!empty($configuration['block_revision_id'])) {
+      $revision_ids = $this->getBlockIdsForRevisionIds([$configuration['block_revision_id']]);
+      return array_pop($revision_ids);
+    }
+    return NULL;
+  }
+
+  /**
+   * Delete the inline blocks and the usage records.
+   *
+   * @param int[] $block_content_ids
+   *   The block content entity IDs.
+   */
+  protected function deleteBlocksAndUsage(array $block_content_ids) {
+    foreach ($block_content_ids as $block_content_id) {
+      if ($block = $this->blockContentStorage->load($block_content_id)) {
+        $block->delete();
+      }
+    }
+    $this->usage->deleteUsage($block_content_ids);
+  }
+
+  /**
+   * Removes unused inline blocks.
+   *
+   * @param int $limit
+   *   The maximum number of inline blocks to remove.
+   */
+  public function removeUnused($limit = 100) {
+    $this->deleteBlocksAndUsage($this->usage->getUnused($limit));
+  }
+
+  /**
+   * Gets blocks IDs for an array of revision IDs.
+   *
+   * @param int[] $revision_ids
+   *   The revision IDs.
+   *
+   * @return int[]
+   *   The block IDs.
+   */
+  protected function getBlockIdsForRevisionIds(array $revision_ids) {
+    if ($revision_ids) {
+      $query = $this->blockContentStorage->getQuery();
+      $query->condition('revision_id', $revision_ids, 'IN');
+      $block_ids = $query->execute();
+      return $block_ids;
+    }
+    return [];
+  }
+
+  /**
+   * Saves an inline block component.
+   *
+   * @param \Drupal\Core\Entity\EntityInterface $entity
+   *   The entity with the layout.
+   * @param \Drupal\layout_builder\SectionComponent $component
+   *   The section component with an inline block.
+   * @param bool $new_revision
+   *   Whether a new revision of the block should be created.
+   * @param bool $duplicate_blocks
+   *   Whether the blocks should be duplicated.
+   */
+  protected function saveInlineBlockComponent(EntityInterface $entity, SectionComponent $component, $new_revision, $duplicate_blocks) {
+    /** @var \Drupal\layout_builder\Plugin\Block\InlineBlock $plugin */
+    $plugin = $component->getPlugin();
+    $pre_save_configuration = $plugin->getConfiguration();
+    $plugin->saveBlockContent($new_revision, $duplicate_blocks);
+    $post_save_configuration = $plugin->getConfiguration();
+    if ($duplicate_blocks || (empty($pre_save_configuration['block_revision_id']) && !empty($post_save_configuration['block_revision_id']))) {
+      $this->usage->addUsage($this->getPluginBlockId($plugin), $entity);