first commit

core/modules/tracker/help_topics/tracker.tracking_changed_content.html.twig

@@ -0,0 +1,17 @@
+---
+label: 'Viewing lists of recently-updated content'
+related:
+  - core.tracking_content
+  - history.tracking_user_content
+---
+{% set recent_link_text %}
+{% trans %}Recent content{% endtrans %}
+{% endset %}
+{% set recent_link = render_var(help_route_link(recent_link_text, 'tracker.page')) %}
+<h2>{% trans %}What displays of recently-updated content are available?{% endtrans %}</h2>
+<p>{% trans %}Assuming that you have the core Activity Tracker module installed, these pages that show recently-updated content are available:{% endtrans %}</p>
+<ul>
+  <li>{% trans %}{{ recent_link }}: Shows the content that has been most recently added, updated, or commented on.{% endtrans %}</li>
+  <li>{% trans %}The <em>My recent content</em> tab on the <em>Recent content</em> page (for logged-in users) limits the list to content created or commented on by the user viewing the page.{% endtrans %}</li>
+  <li>{% trans %}The <em>Activity</em> tab on a user profile shows the same list for the user whose profile is being viewed.{% endtrans %}</li>
+</ul>

core/modules/tracker/js/tracker-history.js

@@ -0,0 +1,149 @@
+/**
+ * Attaches behaviors for the Tracker module's History module integration.
+ *
+ * May only be loaded for authenticated users, with the History module enabled.
+ */
+(function ($, Drupal, window) {
+  function processNodeNewIndicators(placeholders) {
+    const newNodeString = Drupal.t('new');
+    const updatedNodeString = Drupal.t('updated');
+
+    placeholders.forEach((placeholder) => {
+      const timestamp = parseInt(
+        placeholder.getAttribute('data-history-node-timestamp'),
+        10,
+      );
+      const nodeID = placeholder.getAttribute('data-history-node-id');
+      const lastViewTimestamp = Drupal.history.getLastRead(nodeID);
+
+      if (timestamp > lastViewTimestamp) {
+        const message =
+          lastViewTimestamp === 0 ? newNodeString : updatedNodeString;
+        $(placeholder).append(`<span class="marker">${message}</span>`);
+      }
+    });
+  }
+
+  function processNewRepliesIndicators(placeholders) {
+    // Figure out which placeholders need the "x new" replies links.
+    const placeholdersToUpdate = {};
+    placeholders.forEach((placeholder) => {
+      const timestamp = parseInt(
+        placeholder.getAttribute('data-history-node-last-comment-timestamp'),
+        10,
+      );
+      const nodeID = placeholder.previousSibling.previousSibling.getAttribute(
+        'data-history-node-id',
+      );
+      const lastViewTimestamp = Drupal.history.getLastRead(nodeID);
+
+      // Queue this placeholder's "X new" replies link to be downloaded from the
+      // server.
+      if (timestamp > lastViewTimestamp) {
+        placeholdersToUpdate[nodeID] = placeholder;
+      }
+    });
+
+    // Perform an AJAX request to retrieve node view timestamps.
+    const nodeIDs = Object.keys(placeholdersToUpdate);
+    if (nodeIDs.length === 0) {
+      return;
+    }
+    $.ajax({
+      url: Drupal.url('comments/render_new_comments_node_links'),
+      type: 'POST',
+      data: { 'node_ids[]': nodeIDs },
+      dataType: 'json',
+      success(results) {
+        Object.keys(results || {}).forEach((nodeID) => {
+          if (placeholdersToUpdate.hasOwnProperty(nodeID)) {
+            const url = results[nodeID].first_new_comment_link;
+            const text = Drupal.formatPlural(
+              results[nodeID].new_comment_count,
+              '1 new',
+              '@count new',
+            );
+            $(placeholdersToUpdate[nodeID]).append(
+              `<br /><a href="${url}">${text}</a>`,
+            );
+          }
+        });
+      },
+    });
+  }
+
+  /**
+   * Render "new" and "updated" node indicators, as well as "X new" replies links.
+   */
+  Drupal.behaviors.trackerHistory = {
+    attach(context) {
+      // Find all "new" comment indicator placeholders newer than 30 days ago that
+      // have not already been read after their last comment timestamp.
+      const nodeIDs = [];
+      const nodeNewPlaceholders = once(
+        'history',
+        '[data-history-node-timestamp]',
+        context,
+      ).filter((placeholder) => {
+        const nodeTimestamp = parseInt(
+          placeholder.getAttribute('data-history-node-timestamp'),
+          10,
+        );
+        const nodeID = placeholder.getAttribute('data-history-node-id');
+        if (Drupal.history.needsServerCheck(nodeID, nodeTimestamp)) {
+          nodeIDs.push(nodeID);
+          return true;
+        }
+
+        return false;
+      });
+
+      // Find all "new" comment indicator placeholders newer than 30 days ago that
+      // have not already been read after their last comment timestamp.
+      const newRepliesPlaceholders = once(
+        'history',
+        '[data-history-node-last-comment-timestamp]',
+        context,
+      ).filter((placeholder) => {
+        const lastCommentTimestamp = parseInt(
+          placeholder.getAttribute('data-history-node-last-comment-timestamp'),
+          10,
+        );
+        const nodeTimestamp = parseInt(
+          placeholder.previousSibling.previousSibling.getAttribute(
+            'data-history-node-timestamp',
+          ),
+          10,
+        );
+        // Discard placeholders that have zero comments.
+        if (lastCommentTimestamp === nodeTimestamp) {
+          return false;
+        }
+        const nodeID = placeholder.previousSibling.previousSibling.getAttribute(
+          'data-history-node-id',
+        );
+        if (Drupal.history.needsServerCheck(nodeID, lastCommentTimestamp)) {
+          if (nodeIDs.indexOf(nodeID) === -1) {
+            nodeIDs.push(nodeID);
+          }
+          return true;
+        }
+
+        return false;
+      });
+
+      if (
+        nodeNewPlaceholders.length === 0 &&
+        newRepliesPlaceholders.length === 0
+      ) {
+        return;
+      }
+
+      // Fetch the node read timestamps from the server.
+      Drupal.history.fetchTimestamps(nodeIDs, () => {
+        processNodeNewIndicators(nodeNewPlaceholders);
+        processNewRepliesIndicators(newRepliesPlaceholders);
+      });
+    },
+  };
+})(jQuery, Drupal, window);

core/modules/tracker/migrations/d7_tracker_node.yml

@@ -0,0 +1,16 @@
+id: d7_tracker_node
+label: Tracker node
+migration_tags:
+  - Drupal 7
+  - Content
+source:
+  plugin: d7_tracker_node
+process:
+  nid: nid
+  published: published
+  changed: changed
+destination:
+  plugin: entity:node
+migration_dependencies:
+  required:
+    - d7_user

core/modules/tracker/migrations/d7_tracker_settings.yml

@@ -0,0 +1,15 @@
+id: d7_tracker_settings
+label: Tracker settings
+migration_tags:
+  - Drupal 7
+  - Configuration
+source:
+  plugin: variable
+  variables:
+    - tracker_batch_size
+  source_module: tracker
+process:
+  cron_index_limit: tracker_batch_size
+destination:
+  plugin: config
+  config_name: tracker.settings

core/modules/tracker/migrations/d7_tracker_user.yml

@@ -0,0 +1,17 @@
+id: d7_tracker_user
+label: Tracker user
+migration_tags:
+  - Drupal 7
+  - Content
+source:
+  plugin: d7_tracker_user
+process:
+  nid: nid
+  uid: uid
+  published: published
+  changed: changed
+destination:
+  plugin: entity:user
+migration_dependencies:
+  required:
+    - d7_user

core/modules/tracker/migrations/state/tracker.migrate_drupal.yml

@@ -0,0 +1,3 @@
+finished:
+  7:
+    tracker: tracker

core/modules/tracker/src/Controller/TrackerController.php

@@ -0,0 +1,258 @@
+<?php
+
+namespace Drupal\tracker\Controller;
+
+use Drupal\comment\CommentStatisticsInterface;
+use Drupal\Core\Access\AccessResult;
+use Drupal\Core\Cache\CacheableMetadata;
+use Drupal\Core\Controller\ControllerBase;
+use Drupal\Core\Database\Connection;
+use Drupal\Core\Database\Query\PagerSelectExtender;
+use Drupal\Core\Datetime\DateFormatterInterface;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\Core\Session\AccountInterface;
+use Drupal\user\UserInterface;
+use Symfony\Component\DependencyInjection\Attribute\Autowire;
+
+/**
+ * Controller for tracker pages.
+ */
+class TrackerController extends ControllerBase {
+
+  /**
+   * The database connection.
+   *
+   * @var \Drupal\Core\Database\Connection
+   */
+  protected $database;
+
+  /**
+   * The database replica connection.
+   *
+   * @var \Drupal\Core\Database\Connection
+   */
+  protected $databaseReplica;
+
+  /**
+   * The comment statistics.
+   *
+   * @var \Drupal\comment\CommentStatisticsInterface
+   */
+  protected $commentStatistics;
+
+  /**
+   * The date formatter.
+   *
+   * @var \Drupal\Core\Datetime\DateFormatterInterface
+   */
+  protected $dateFormatter;
+
+  /**
+   * The node storage.
+   *
+   * @var \Drupal\Core\Entity\EntityStorageInterface
+   */
+  protected $nodeStorage;
+
+  /**
+   * Constructs a TrackerController object.
+   *
+   * @param \Drupal\Core\Database\Connection $database
+   *   The database connection.
+   * @param \Drupal\Core\Database\Connection $databaseReplica
+   *   The database replica connection.
+   * @param \Drupal\comment\CommentStatisticsInterface $commentStatistics
+   *   The comment statistics.
+   * @param \Drupal\Core\Datetime\DateFormatterInterface $dateFormatter
+   *   The date formatter.
+   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entityTypeManager
+   *   The entity type manager.
+   */
+  public function __construct(
+    Connection $database,
+    #[Autowire(service: 'database.replica')]
+    Connection $databaseReplica,
+    CommentStatisticsInterface $commentStatistics,
+    DateFormatterInterface $dateFormatter,
+    EntityTypeManagerInterface $entityTypeManager,
+  ) {
+    $this->database = $database;
+    $this->databaseReplica = $databaseReplica;
+    $this->commentStatistics = $commentStatistics;
+    $this->dateFormatter = $dateFormatter;
+    $this->entityTypeManager = $entityTypeManager;
+    $this->nodeStorage = $entityTypeManager->getStorage('node');
+  }
+
+  /**
+   * Title callback for the tracker.user_tab route.
+   *
+   * @param \Drupal\user\UserInterface $user
+   *   The user.
+   *
+   * @return string
+   *   The title.
+   */
+  public function getTitle(UserInterface $user) {
+    return $user->getDisplayName();
+  }
+
+  /**
+   * Checks access for the users recent content tracker page.
+   *
+   * @param \Drupal\user\UserInterface $user
+   *   The user being viewed.
+   * @param \Drupal\Core\Session\AccountInterface $account
+   *   The account viewing the page.
+   *
+   * @return \Drupal\Core\Access\AccessResult
+   *   The access result.
+   */
+  public function checkAccess(UserInterface $user, AccountInterface $account) {
+    return AccessResult::allowedIf($account->isAuthenticated() && $user->id() == $account->id())
+      ->cachePerUser();
+  }
+
+  /**
+   * Builds content for the tracker controllers.
+   *
+   * @param \Drupal\user\UserInterface|null $user
+   *   (optional) The user account.
+   *
+   * @return array
+   *   The render array.
+   */
+  public function buildContent(?UserInterface $user = NULL) {
+    if ($user) {
+      $query = $this->database->select('tracker_user', 't')
+        ->extend(PagerSelectExtender::class)
+        ->addMetaData('base_table', 'tracker_user')
+        ->condition('t.uid', $user->id());
+    }
+    else {
+      $query = $this->databaseReplica->select('tracker_node', 't')
+        ->extend(PagerSelectExtender::class)
+        ->addMetaData('base_table', 'tracker_node');
+    }
+
+    // This array acts as a placeholder for the data selected later
+    // while keeping the correct order.
+    $tracker_data = $query
+      ->addTag('node_access')
+      ->fields('t', ['nid', 'changed'])
+      ->condition('t.published', 1)
+      ->orderBy('t.changed', 'DESC')
+      ->limit(25)
+      ->execute()
+      ->fetchAllAssoc('nid');
+
+    $cacheable_metadata = new CacheableMetadata();
+    $rows = [];
+    if (!empty($tracker_data)) {
+      // Load nodes into an array with the same order as $tracker_data.
+      /** @var \Drupal\node\NodeInterface[] $nodes */
+      $nodes = $this->nodeStorage->loadMultiple(array_keys($tracker_data));
+
+      // Enrich the node data.
+      $result = $this->commentStatistics->read($nodes, 'node', FALSE);
+      foreach ($result as $statistics) {
+        // The node ID may not be unique; there can be multiple comment fields.
+        // Make comment_count the total of all comments.
+        $nid = $statistics->entity_id;
+        if (empty($nodes[$nid]->comment_count)
+          || !is_numeric($tracker_data[$nid]->comment_count)) {
+          $tracker_data[$nid]->comment_count = $statistics->comment_count;
+        }
+        else {
+          $tracker_data[$nid]->comment_count += $statistics->comment_count;
+        }
+        // Make the last comment timestamp reflect the latest comment.
+        if (!isset($tracker_data[$nid]->last_comment_timestamp)) {
+          $tracker_data[$nid]->last_comment_timestamp = $statistics->last_comment_timestamp;
+        }
+        else {
+          $tracker_data[$nid]->last_comment_timestamp = max($tracker_data[$nid]->last_comment_timestamp, $statistics->last_comment_timestamp);
+        }
+      }
+
+      // Display the data.
+      foreach ($nodes as $node) {
+        // Set the last activity time from tracker data. This also takes into
+        // account comment activity, so getChangedTime() is not used.
+        $last_activity = $tracker_data[$node->id()]->changed;
+
+        $owner = $node->getOwner();
+        $row = [
+          'type' => node_get_type_label($node),
+          'title' => [
+            'data' => [
+              '#type' => 'link',
+              '#url' => $node->toUrl(),
+              '#title' => $node->getTitle(),
+            ],
+            'data-history-node-id' => $node->id(),
+            'data-history-node-timestamp' => $node->getChangedTime(),
+          ],
+          'author' => [
+            'data' => [
+              '#theme' => 'username',
+              '#account' => $owner,
+            ],
+          ],
+          'comments' => [
+            'class' => ['comments'],
+            'data' => $tracker_data[$node->id()]->comment_count ?? 0,
+            'data-history-node-last-comment-timestamp' => $tracker_data[$node->id()]->last_comment_timestamp ?? 0,
+          ],
+          'last updated' => [
+            'data' => t('@time ago', [
+              '@time' => $this->dateFormatter->formatTimeDiffSince($last_activity),
+            ]),
+          ],
+        ];
+
+        $rows[] = $row;
+
+        // Add node and node owner to cache tags.
+        $cacheable_metadata->addCacheTags($node->getCacheTags());
+        if ($owner) {
+          $cacheable_metadata->addCacheTags($owner->getCacheTags());
+        }
+      }
+    }
+
+    // Add the list cache tag for nodes.
+    $cacheable_metadata->addCacheTags($this->nodeStorage->getEntityType()->getListCacheTags());
+
+    $page['tracker'] = [
+      '#rows' => $rows,
+      '#header' => [
+        $this->t('Type'),
+        $this->t('Title'),
+        $this->t('Author'),
+        $this->t('Comments'),
+        $this->t('Last updated'),
+      ],
+      '#type' => 'table',
+      '#empty' => $this->t('No content available.'),
+    ];
+    $page['pager'] = [
+      '#type' => 'pager',
+      '#weight' => 10,
+    ];
+    $page['#sorted'] = TRUE;
+    $cacheable_metadata->addCacheContexts(['user.node_grants:view']);
+
+    // Display the reading history if that module is enabled.
+    if ($this->moduleHandler()->moduleExists('history')) {
+      // Reading history is tracked for authenticated users only.
+      if ($this->currentUser()->isAuthenticated()) {
+        $page['#attached']['library'][] = 'tracker/history';
+      }
+      $cacheable_metadata->addCacheContexts(['user.roles:authenticated']);
+    }
+    $cacheable_metadata->applyTo($page);
+    return $page;
+  }
+
+}

core/modules/tracker/src/Plugin/Menu/UserTrackerTab.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace Drupal\tracker\Plugin\Menu;
+
+use Drupal\Core\Menu\LocalTaskDefault;
+use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
+use Drupal\Core\Routing\RouteMatchInterface;
+use Drupal\Core\Session\AccountInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Provides route parameters needed to link to the current user tracker tab.
+ */
+class UserTrackerTab extends LocalTaskDefault implements ContainerFactoryPluginInterface {
+
+  /**
+   * Current user object.
+   *
+   * @var \Drupal\Core\Session\AccountInterface
+   */
+  protected $currentUser;
+
+  /**
+   * Construct the UserTrackerTab object.
+   *
+   * @param array $configuration
+   *   A configuration array containing information about the plugin instance.
+   * @param string $plugin_id
+   *   The plugin_id for the plugin instance.
+   * @param array $plugin_definition
+   *   The plugin implementation definition.
+   * @param \Drupal\Core\Session\AccountInterface $current_user
+   *   The current user.
+   */
+  public function __construct(array $configuration, $plugin_id, array $plugin_definition, AccountInterface $current_user) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition);
+    $this->currentUser = $current_user;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->get('current_user')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getRouteParameters(RouteMatchInterface $route_match) {
+    return ['user' => $this->currentUser->id()];
+  }
+
+}

core/modules/tracker/src/Plugin/migrate/source/d7/TrackerNode.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace Drupal\tracker\Plugin\migrate\source\d7;
+
+use Drupal\migrate_drupal\Plugin\migrate\source\DrupalSqlBase;
+
+/**
+ * Drupal 7 tracker node source from database.
+ *
+ * For available configuration keys, refer to the parent classes.
+ *
+ * @see \Drupal\migrate\Plugin\migrate\source\SqlBase
+ * @see \Drupal\migrate\Plugin\migrate\source\SourcePluginBase
+ *
+ * @MigrateSource(
+ *   id = "d7_tracker_node",
+ *   source_module = "tracker"
+ * )
+ */
+class TrackerNode extends DrupalSqlBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    return $this->select('tracker_node', 'tn')->fields('tn');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function fields() {
+    return [
+      'nid' => $this->t('The {node}.nid this record tracks.'),
+      'published' => $this->t('Boolean indicating whether the node is published.'),
+      'changed' => $this->t('The Unix timestamp when the node was most recently saved or commented on.'),
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    $ids['nid']['type'] = 'integer';
+    return $ids;
+  }
+
+}

core/modules/tracker/src/Plugin/migrate/source/d7/TrackerUser.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace Drupal\tracker\Plugin\migrate\source\d7;
+
+use Drupal\migrate_drupal\Plugin\migrate\source\DrupalSqlBase;
+
+/**
+ * Drupal 7 tracker user source from database.
+ *
+ * For available configuration keys, refer to the parent classes.
+ *
+ * @see \Drupal\migrate\Plugin\migrate\source\SqlBase
+ * @see \Drupal\migrate\Plugin\migrate\source\SourcePluginBase
+ *
+ * @MigrateSource(
+ *   id = "d7_tracker_user",
+ *   source_module = "tracker"
+ * )
+ */
+class TrackerUser extends DrupalSqlBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    return $this->select('tracker_user', 'tu')->fields('tu');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function fields() {
+    return [
+      'nid' => $this->t('The {user}.nid this record tracks.'),
+      'uid' => $this->t('The {users}.uid of the node author or commenter.'),
+      'published' => $this->t('Boolean indicating whether the node is published.'),
+      'changed' => $this->t('The Unix timestamp when the user was most recently saved or commented on.'),
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    $ids['nid']['type'] = 'integer';
+    $ids['uid']['type'] = 'integer';
+    return $ids;
+  }
+
+}

core/modules/tracker/src/Plugin/views/argument/UserUid.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Drupal\tracker\Plugin\views\argument;
+
+use Drupal\comment\Plugin\views\argument\UserUid as CommentUserUid;
+use Drupal\views\Attribute\ViewsArgument;
+
+/**
+ * UID argument to check for nodes that user posted or commented on.
+ *
+ * @ingroup views_argument_handlers
+ */
+#[ViewsArgument(
+  id: 'tracker_user_uid',
+)]
+class UserUid extends CommentUserUid {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query($group_by = FALSE) {
+    // Because this handler thinks it's an argument for a field on the {node}
+    // table, we need to make sure {tracker_user} is JOINed and use its alias
+    // for the WHERE clause.
+    $tracker_user_alias = $this->query->ensureTable('tracker_user');
+    $this->query->addWhere(0, "$tracker_user_alias.uid", $this->argument);
+  }
+
+}

core/modules/tracker/src/Plugin/views/filter/UserUid.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Drupal\tracker\Plugin\views\filter;
+
+use Drupal\user\Plugin\views\filter\Name;
+use Drupal\views\Attribute\ViewsFilter;
+
+/**
+ * UID filter to check for nodes that a user posted or commented on.
+ *
+ * @ingroup views_filter_handlers
+ */
+#[ViewsFilter("tracker_user_uid")]
+class UserUid extends Name {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    // Because this handler thinks it's an argument for a field on the {node}
+    // table, we need to make sure {tracker_user} is JOINed and use its alias
+    // for the WHERE clause.
+    $tracker_user_alias = $this->query->ensureTable('tracker_user');
+    // Cast scalars to array so we can consistently use an IN condition.
+    $this->query->addWhere(0, "$tracker_user_alias.uid", (array) $this->value, 'IN');
+  }
+
+}

core/modules/tracker/tests/modules/tracker_test_views/test_views/views.view.test_tracker_user_uid.yml

@@ -0,0 +1,180 @@
+langcode: en
+status: true
+dependencies:
+  module:
+    - node
+    - tracker
+    - user
+id: test_tracker_user_uid
+label: 'tracker test'
+module: views
+description: ''
+tag: ''
+base_table: node_field_data
+base_field: nid
+display:
+  default:
+    display_plugin: default
+    id: default
+    display_title: Default
+    position: null
+    display_options:
+      access:
+        type: perm
+      cache:
+        type: tag
+      query:
+        type: views_query
+      exposed_form:
+        type: basic
+      pager:
+        type: full
+      style:
+        type: table
+        options:
+          grouping: {  }
+          row_class: ''
+          default_row_class: true
+          override: true
+          sticky: false
+          summary: ''
+          columns:
+            title: title
+          info:
+            title:
+              sortable: true
+              default_sort_order: asc
+              align: ''
+              separator: ''
+              empty_column: false
+              responsive: ''
+          default: '-1'
+          empty_table: false
+      row:
+        type: fields
+      fields:
+        title:
+          id: title
+          table: node_field_data
+          field: title
+          relationship: none
+          group_type: group
+          admin_label: ''
+          label: Title
+          exclude: false
+          alter:
+            alter_text: false
+            text: ''
+            make_link: false
+            path: ''
+            absolute: false
+            external: false
+            replace_spaces: false
+            path_case: none
+            trim_whitespace: false
+            alt: ''
+            rel: ''
+            link_class: ''
+            prefix: ''
+            suffix: ''
+            target: ''
+            nl2br: false
+            max_length: 0
+            word_boundary: false
+            ellipsis: false
+            more_link: false
+            more_link_text: ''
+            more_link_path: ''
+            strip_tags: false
+            trim: false
+            preserve_tags: ''
+            html: false
+          element_type: ''
+          element_class: ''
+          element_label_type: ''
+          element_label_class: ''
+          element_label_colon: true
+          element_wrapper_type: ''
+          element_wrapper_class: ''
+          element_default_classes: true
+          empty: ''
+          hide_empty: false
+          empty_zero: false
+          hide_alter_empty: true
+          plugin_id: field
+          entity_type: node
+          entity_field: title
+      filters:
+        uid_touch_tracker:
+          id: uid_touch_tracker
+          table: node_field_data
+          field: uid_touch_tracker
+          relationship: none
+          group_type: group
+          admin_label: ''
+          operator: in
+          value:
+            - '0'
+          group: 1
+          exposed: false
+          expose:
+            operator_id: ''
+            label: 'User posted or commented'
+            description: ''
+            use_operator: false
+            operator: uid_touch_tracker_op
+            identifier: uid_touch_tracker
+            required: false
+            remember: false
+            multiple: false
+            remember_roles:
+              authenticated: authenticated
+            reduce: false
+          is_grouped: false
+          group_info:
+            label: ''
+            description: ''
+            identifier: ''
+            optional: true
+            widget: select
+            multiple: false
+            remember: false
+            default_group: All
+            default_group_multiple: {  }
+            group_items: {  }
+          plugin_id: tracker_user_uid
+          entity_type: node
+      arguments:
+        uid_touch_tracker:
+          id: uid_touch_tracker
+          table: node_field_data
+          field: uid_touch_tracker
+          relationship: none
+          group_type: group
+          admin_label: ''
+          default_action: ignore
+          exception:
+            value: all
+            title_enable: false
+            title: All
+          title_enable: false
+          title: ''
+          default_argument_type: fixed
+          default_argument_options:
+            argument: ''
+          summary_options:
+            base_path: ''
+            count: true
+            items_per_page: 25
+            override: false
+          summary:
+            sort_order: asc
+            number_of_records: 0
+            format: default_summary
+          specify_validation: false
+          validate:
+            type: none
+            fail: 'not found'
+          validate_options: {  }
+          plugin_id: tracker_user_uid
+          entity_type: node

core/modules/tracker/tests/modules/tracker_test_views/tracker_test_views.info.yml

@@ -0,0 +1,13 @@
+name: 'Tracker test views'
+type: module
+description: 'Provides default views for views tracker tests.'
+package: Testing
+# version: VERSION
+dependencies:
+  - drupal:tracker
+  - drupal:views
+
+# Information added by Drupal.org packaging script on 2024-07-04
+version: '10.3.1'
+project: 'drupal'
+datestamp: 1720094222

core/modules/tracker/tests/src/Functional/GenericTest.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\tracker\Functional;
+
+use Drupal\Tests\system\Functional\Module\GenericModuleTestBase;
+
+/**
+ * Generic module test for tracker.
+ *
+ * @group tracker
+ * @group legacy
+ */
+class GenericTest extends GenericModuleTestBase {}

core/modules/tracker/tests/src/Functional/Migrate/ReviewPageTest.php

@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\tracker\Functional\Migrate;
+
+use Drupal\Tests\migrate_drupal_ui\Functional\NoMultilingualReviewPageTestBase;
+
+/**
+ * Tests Review page.
+ *
+ * @group tracker
+ * @group legacy
+ */
+class ReviewPageTest extends NoMultilingualReviewPageTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = ['tracker'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+    $this->loadFixture($this->getModulePath('tracker') . '/tests/fixtures/drupal7.php');
+  }
+
+  /**
+   * Tests the review page.
+   */
+  public function testMigrateUpgradeReviewPage(): void {
+    $this->prepare();
+    // Start the upgrade process.
+    $this->submitCredentialForm();
+
+    $session = $this->assertSession();
+    $this->submitForm([], 'I acknowledge I may lose data. Continue anyway.');
+    $session->statusCodeEquals(200);
+
+    // Confirm that Tracker will be upgraded.
+    $session->elementExists('xpath', "//td[contains(@class, 'checked') and text() = 'Tracker']");
+    $session->elementNotExists('xpath', "//td[contains(@class, 'error') and text() = 'Tracker']");
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getSourceBasePath() {
+    return __DIR__;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getAvailablePaths() {
+    return [];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getIncompletePaths() {
+    return [];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getMissingPaths() {
+    return [];
+  }
+
+}

core/modules/tracker/tests/src/Functional/TrackerNodeAccessTest.php

@@ -0,0 +1,120 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\tracker\Functional;
+
+use Drupal\comment\Plugin\Field\FieldType\CommentItemInterface;
+use Drupal\comment\Tests\CommentTestTrait;
+use Drupal\node\Entity\NodeType;
+use Drupal\Tests\BrowserTestBase;
+
+/**
+ * Tests for private node access on /tracker.
+ *
+ * @group tracker
+ * @group legacy
+ */
+class TrackerNodeAccessTest extends BrowserTestBase {
+
+  use CommentTestTrait;
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  protected static $modules = [
+    'node',
+    'comment',
+    'tracker',
+    'node_access_test',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $defaultTheme = 'stark';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+    node_access_rebuild();
+    $this->drupalCreateContentType(['type' => 'page']);
+    node_access_test_add_field(NodeType::load('page'));
+    $this->addDefaultCommentField('node', 'page', 'comment', CommentItemInterface::OPEN);
+    \Drupal::state()->set('node_access_test.private', TRUE);
+  }
+
+  /**
+   * Ensure that tracker_cron is not access sensitive.
+   */
+  public function testTrackerNodeAccessIndexing(): void {
+    // The node is private and not authored by the anonymous user, so any entity
+    // queries run for the anonymous user will miss it.
+    $author = $this->drupalCreateUser();
+    $private_node = $this->drupalCreateNode([
+      'title' => 'Private node test',
+      'private' => TRUE,
+      'uid' => $author->id(),
+    ]);
+
+    // Remove index entries, and index as tracker_install() does.
+    \Drupal::database()->delete('tracker_node')->execute();
+    \Drupal::state()->set('tracker.index_nid', $private_node->id());
+    tracker_cron();
+
+    // Test that the private node has been indexed and so can be viewed by a
+    // user with node test view permission.
+    $user = $this->drupalCreateUser(['node test view']);
+    $this->drupalLogin($user);
+    $this->drupalGet('activity');
+    $this->assertSession()->pageTextContains($private_node->getTitle());
+  }
+
+  /**
+   * Ensure private node on /tracker is only visible to users with permission.
+   */
+  public function testTrackerNodeAccess(): void {
+    // Create user with node test view permission.
+    $access_user = $this->drupalCreateUser([
+      'node test view',
+      'access user profiles',
+    ]);
+
+    // Create user without node test view permission.
+    $no_access_user = $this->drupalCreateUser(['access user profiles']);
+
+    $this->drupalLogin($access_user);
+
+    // Create some nodes.
+    $private_node = $this->drupalCreateNode([
+      'title' => 'Private node test',
+      'private' => TRUE,
+    ]);
+    $public_node = $this->drupalCreateNode([
+      'title' => 'Public node test',
+      'private' => FALSE,
+    ]);
+
+    // User with access should see both nodes created.
+    $this->drupalGet('activity');
+    $this->assertSession()->pageTextContains($private_node->getTitle());
+    $this->assertSession()->pageTextContains($public_node->getTitle());
+    $this->drupalGet('user/' . $access_user->id() . '/activity');
+    $this->assertSession()->pageTextContains($private_node->getTitle());
+    $this->assertSession()->pageTextContains($public_node->getTitle());
+
+    // User without access should not see private node.
+    $this->drupalLogin($no_access_user);
+    $this->drupalGet('activity');
+    $this->assertSession()->pageTextNotContains($private_node->getTitle());
+    $this->assertSession()->pageTextContains($public_node->getTitle());
+    $this->drupalGet('user/' . $access_user->id() . '/activity');
+    $this->assertSession()->pageTextNotContains($private_node->getTitle());
+    $this->assertSession()->pageTextContains($public_node->getTitle());
+  }
+
+}

core/modules/tracker/tests/src/Functional/TrackerRecentContentLinkTest.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\tracker\Functional;
+
+use Drupal\Tests\BrowserTestBase;
+
+/**
+ * Tests recent content link.
+ *
+ * @group tracker
+ * @group legacy
+ */
+class TrackerRecentContentLinkTest extends BrowserTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = ['block', 'tracker'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $defaultTheme = 'stark';
+
+  /**
+   * Tests the recent content link in menu block.
+   */
+  public function testRecentContentLink(): void {
+    $this->drupalGet('<front>');
+    $this->assertSession()->linkNotExists('Recent content');
+    $this->drupalPlaceBlock('system_menu_block:tools');
+
+    // Create a regular user.
+    $user = $this->drupalCreateUser();
+
+    // Log in and get the homepage.
+    $this->drupalLogin($user);
+    $this->drupalGet('<front>');
+    $this->assertSession()->elementsCount('xpath', '//ul/li/a[contains(@href, "/activity") and text()="Recent content"]', 1);
+  }
+
+}

core/modules/tracker/tests/src/Functional/TrackerTest.php

@@ -0,0 +1,484 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\tracker\Functional;
+
+use Drupal\comment\CommentInterface;
+use Drupal\comment\Tests\CommentTestTrait;
+use Drupal\Core\Cache\Cache;
+use Drupal\Core\Database\Database;
+use Drupal\Core\EventSubscriber\MainContentViewSubscriber;
+use Drupal\Core\Session\AccountInterface;
+use Drupal\field\Entity\FieldStorageConfig;
+use Drupal\node\Entity\Node;
+use Drupal\Tests\BrowserTestBase;
+use Drupal\Tests\system\Functional\Cache\AssertPageCacheContextsAndTagsTrait;
+
+/**
+ * Create and delete nodes and check for their display in the tracker listings.
+ *
+ * @group tracker
+ * @group legacy
+ */
+class TrackerTest extends BrowserTestBase {
+
+  use CommentTestTrait;
+  use AssertPageCacheContextsAndTagsTrait;
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  protected static $modules = [
+    'block',
+    'comment',
+    'tracker',
+    'history',
+    'node_test',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $defaultTheme = 'stark';
+
+  /**
+   * The main user for testing.
+   *
+   * @var \Drupal\user\UserInterface
+   */
+  protected $user;
+
+  /**
+   * A second user that will 'create' comments and nodes.
+   *
+   * @var \Drupal\user\UserInterface
+   */
+  protected $otherUser;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+
+    $this->drupalCreateContentType(['type' => 'page', 'name' => 'Basic page']);
+
+    $permissions = ['access comments', 'create page content', 'post comments', 'skip comment approval'];
+    $this->user = $this->drupalCreateUser($permissions);
+    $this->otherUser = $this->drupalCreateUser($permissions);
+    $this->addDefaultCommentField('node', 'page');
+    user_role_grant_permissions(AccountInterface::ANONYMOUS_ROLE, [
+      'access content',
+      'access user profiles',
+    ]);
+    $this->drupalPlaceBlock('local_tasks_block', ['id' => 'page_tabs_block']);
+    $this->drupalPlaceBlock('local_actions_block', ['id' => 'page_actions_block']);
+  }
+
+  /**
+   * Tests for the presence of nodes on the global tracker listing.
+   */
+  public function testTrackerAll(): void {
+    $this->drupalLogin($this->user);
+
+    $unpublished = $this->drupalCreateNode([
+      'title' => $this->randomMachineName(8),
+      'status' => 0,
+    ]);
+    $published = $this->drupalCreateNode([
+      'title' => $this->randomMachineName(8),
+      'status' => 1,
+    ]);
+
+    $this->drupalGet('activity');
+    $this->assertSession()->pageTextNotContains($unpublished->label());
+    $this->assertSession()->pageTextContains($published->label());
+    $this->assertSession()->linkExists('My recent content', 0, 'User tab shows up on the global tracker page.');
+
+    // Assert cache contexts, specifically the pager and node access contexts.
+    $this->assertCacheContexts(['languages:language_interface', 'route', 'theme', 'url.query_args:' . MainContentViewSubscriber::WRAPPER_FORMAT, 'url.query_args.pagers:0', 'user.node_grants:view', 'user']);
+    // Assert cache tags for the action/tabs blocks, visible node, and node list
+    // cache tag.
+    $expected_tags = Cache::mergeTags($published->getCacheTags(), $published->getOwner()->getCacheTags());
+    $block_tags = [
+      'block_view',
+      'local_task',
+      'config:block.block.page_actions_block',
+      'config:block.block.page_tabs_block',
+      'config:block_list',
+    ];
+    $expected_tags = Cache::mergeTags($expected_tags, $block_tags);
+    $additional_tags = [
+      'node_list',
+      'rendered',
+    ];
+    $expected_tags = Cache::mergeTags($expected_tags, $additional_tags);
+    $this->assertCacheTags($expected_tags);
+
+    // Delete a node and ensure it no longer appears on the tracker.
+    $published->delete();
+    $this->drupalGet('activity');
+    $this->assertSession()->pageTextNotContains($published->label());
+
+    // Test proper display of time on activity page when comments are disabled.
+    // Disable comments.
+    FieldStorageConfig::loadByName('node', 'comment')->delete();
+    $node = $this->drupalCreateNode([
+      // This title is required to trigger the custom changed time set in the
+      // node_test module. This is needed in order to ensure a sufficiently
+      // large 'time ago' interval that isn't numbered in seconds.
+      'title' => 'testing_node_presave',
+      'status' => 1,
+    ]);
+
+    $this->drupalGet('activity');
+    $this->assertSession()->pageTextContains($node->label());
+    $this->assertSession()->pageTextContains(\Drupal::service('date.formatter')->formatTimeDiffSince($node->getChangedTime()));
+  }
+
+  /**
+   * Tests for the presence of nodes on a user's tracker listing.
+   */
+  public function testTrackerUser(): void {
+    $this->drupalLogin($this->user);
+
+    $unpublished = $this->drupalCreateNode([
+      'title' => $this->randomMachineName(8),
+      'uid' => $this->user->id(),
+      'status' => 0,
+    ]);
+    $my_published = $this->drupalCreateNode([
+      'title' => $this->randomMachineName(8),
+      'uid' => $this->user->id(),
+      'status' => 1,
+    ]);
+    $other_published_no_comment = $this->drupalCreateNode([
+      'title' => $this->randomMachineName(8),
+      'uid' => $this->otherUser->id(),
+      'status' => 1,
+    ]);
+    $other_published_my_comment = $this->drupalCreateNode([
+      'title' => $this->randomMachineName(8),
+      'uid' => $this->otherUser->id(),
+      'status' => 1,
+    ]);
+    $comment = [
+      'subject[0][value]' => $this->randomMachineName(),
+      'comment_body[0][value]' => $this->randomMachineName(20),
+    ];
+    $this->drupalGet('comment/reply/node/' . $other_published_my_comment->id() . '/comment');
+    $this->submitForm($comment, 'Save');
+
+    $this->drupalGet('user/' . $this->user->id() . '/activity');
+    $this->assertSession()->pageTextNotContains($unpublished->label());
+    $this->assertSession()->pageTextContains($my_published->label());
+    $this->assertSession()->pageTextNotContains($other_published_no_comment->label());
+    $this->assertSession()->pageTextContains($other_published_my_comment->label());
+
+    // Assert cache contexts.
+    $this->assertCacheContexts(['languages:language_interface', 'route', 'theme', 'url.query_args:' . MainContentViewSubscriber::WRAPPER_FORMAT, 'url.query_args.pagers:0', 'user', 'user.node_grants:view']);
+    // Assert cache tags for the visible nodes (including owners) and node list
+    // cache tag.
+    $expected_tags = Cache::mergeTags($my_published->getCacheTags(), $my_published->getOwner()->getCacheTags());
+    $expected_tags = Cache::mergeTags($expected_tags, $other_published_my_comment->getCacheTags());
+    $expected_tags = Cache::mergeTags($expected_tags, $other_published_my_comment->getOwner()->getCacheTags());
+    $block_tags = [
+      'block_view',
+      'local_task',
+      'config:block.block.page_actions_block',
+      'config:block.block.page_tabs_block',
+      'config:block_list',
+    ];
+    $expected_tags = Cache::mergeTags($expected_tags, $block_tags);
+    $additional_tags = [
+      'node_list',
+      'rendered',
+    ];
+    $expected_tags = Cache::mergeTags($expected_tags, $additional_tags);
+
+    $this->assertCacheTags($expected_tags);
+    $this->assertCacheContexts(['languages:language_interface', 'route', 'theme', 'url.query_args:' . MainContentViewSubscriber::WRAPPER_FORMAT, 'url.query_args.pagers:0', 'user', 'user.node_grants:view']);
+
+    $this->assertSession()->linkExists($my_published->label());
+    $this->assertSession()->linkNotExists($unpublished->label());
+    // Verify that title and tab title have been set correctly.
+    $this->assertSession()->pageTextContains('Activity');
+    $this->assertSession()->titleEquals($this->user->getAccountName() . ' | Drupal');
+
+    // Verify that unpublished comments are removed from the tracker.
+    $admin_user = $this->drupalCreateUser([
+      'post comments',
+      'administer comments',
+      'access user profiles',
+    ]);
+    $this->drupalLogin($admin_user);
+    $this->drupalGet('comment/1/edit');
+    $this->submitForm(['status' => CommentInterface::NOT_PUBLISHED], 'Save');
+    $this->drupalGet('user/' . $this->user->id() . '/activity');
+    $this->assertSession()->pageTextNotContains($other_published_my_comment->label());
+
+    // Test escaping of title on user's tracker tab.
+    \Drupal::service('module_installer')->install(['user_hooks_test']);
+    Cache::invalidateTags(['rendered']);
+    \Drupal::state()->set('user_hooks_test_user_format_name_alter', TRUE);
+    $this->drupalGet('user/' . $this->user->id() . '/activity');
+    $this->assertSession()->assertEscaped('<em>' . $this->user->id() . '</em>');
+
+    \Drupal::state()->set('user_hooks_test_user_format_name_alter_safe', TRUE);
+    Cache::invalidateTags(['rendered']);
+    $this->drupalGet('user/' . $this->user->id() . '/activity');
+    $this->assertSession()->assertNoEscaped('<em>' . $this->user->id() . '</em>');
+    $this->assertSession()->responseContains('<em>' . $this->user->id() . '</em>');
+  }
+
+  /**
+   * Tests the metadata for the "new"/"updated" indicators.
+   */
+  public function testTrackerHistoryMetadata(): void {
+    $this->drupalLogin($this->user);
+
+    // Create a page node.
+    $edit = [
+      'title' => $this->randomMachineName(8),
+    ];
+    $node = $this->drupalCreateNode($edit);
+
+    // Verify that the history metadata is present.
+    $this->drupalGet('activity');
+    $this->assertHistoryMetadata($node->id(), $node->getChangedTime(), $node->getChangedTime());
+    $this->drupalGet('activity/' . $this->user->id());
+    $this->assertHistoryMetadata($node->id(), $node->getChangedTime(), $node->getChangedTime());
+    $this->drupalGet('user/' . $this->user->id() . '/activity');
+    $this->assertHistoryMetadata($node->id(), $node->getChangedTime(), $node->getChangedTime());
+
+    // Add a comment to the page, make sure it is created after the node by
+    // sleeping for one second, to ensure the last comment timestamp is
+    // different from before.
+    $comment = [
+      'subject[0][value]' => $this->randomMachineName(),
+      'comment_body[0][value]' => $this->randomMachineName(20),
+    ];
+    sleep(1);
+    $this->drupalGet('comment/reply/node/' . $node->id() . '/comment');
+    $this->submitForm($comment, 'Save');
+    // Reload the node so that comment.module's hook_node_load()
+    // implementation can set $node->last_comment_timestamp for the freshly
+    // posted comment.
+    $node = Node::load($node->id());
+
+    // Verify that the history metadata is updated.
+    $this->drupalGet('activity');
+    $this->assertHistoryMetadata($node->id(), $node->getChangedTime(), (int) $node->get('comment')->last_comment_timestamp);
+    $this->drupalGet('activity/' . $this->user->id());
+    $this->assertHistoryMetadata($node->id(), $node->getChangedTime(), (int) $node->get('comment')->last_comment_timestamp);
+    $this->drupalGet('user/' . $this->user->id() . '/activity');
+    $this->assertHistoryMetadata($node->id(), $node->getChangedTime(), (int) $node->get('comment')->last_comment_timestamp);
+
+    // Log out, now verify that the metadata is still there, but the library is
+    // not.
+    $this->drupalLogout();
+    $this->drupalGet('activity');
+    $this->assertHistoryMetadata($node->id(), $node->getChangedTime(), (int) $node->get('comment')->last_comment_timestamp, FALSE);
+    $this->drupalGet('user/' . $this->user->id() . '/activity');
+    $this->assertHistoryMetadata($node->id(), $node->getChangedTime(), (int) $node->get('comment')->last_comment_timestamp, FALSE);
+  }
+
+  /**
+   * Tests for ordering on a users tracker listing when comments are posted.
+   */
+  public function testTrackerOrderingNewComments(): void {
+    $this->drupalLogin($this->user);
+
+    $node_one = $this->drupalCreateNode([
+      'title' => $this->randomMachineName(8),
+    ]);
+
+    $node_two = $this->drupalCreateNode([
+      'title' => $this->randomMachineName(8),
+    ]);
+
+    // Now get otherUser to track these pieces of content.
+    $this->drupalLogin($this->otherUser);
+
+    // Add a comment to the first page.
+    $comment = [
+      'subject[0][value]' => $this->randomMachineName(),
+      'comment_body[0][value]' => $this->randomMachineName(20),
+    ];
+    $this->drupalGet('comment/reply/node/' . $node_one->id() . '/comment');
+    $this->submitForm($comment, 'Save');
+
+    // If the comment is posted in the same second as the last one then Drupal
+    // can't tell the difference, so we wait one second here.
+    sleep(1);
+
+    // Add a comment to the second page.
+    $comment = [
+      'subject[0][value]' => $this->randomMachineName(),
+      'comment_body[0][value]' => $this->randomMachineName(20),
+    ];
+    $this->drupalGet('comment/reply/node/' . $node_two->id() . '/comment');
+    $this->submitForm($comment, 'Save');
+
+    // We should at this point have in our tracker for otherUser:
+    // 1. node_two
+    // 2. node_one
+    // Because that's the reverse order of the posted comments.
+
+    // Now we're going to post a comment to node_one which should jump it to the
+    // top of the list.
+
+    $this->drupalLogin($this->user);
+    // If the comment is posted in the same second as the last one then Drupal
+    // can't tell the difference, so we wait one second here.
+    sleep(1);
+
+    // Add a comment to the second page.
+    $comment = [
+      'subject[0][value]' => $this->randomMachineName(),
+      'comment_body[0][value]' => $this->randomMachineName(20),
+    ];
+    $this->drupalGet('comment/reply/node/' . $node_one->id() . '/comment');
+    $this->submitForm($comment, 'Save');
+
+    // Switch back to the otherUser and assert that the order has swapped.
+    $this->drupalLogin($this->otherUser);
+    $this->drupalGet('user/' . $this->otherUser->id() . '/activity');
+    // This is a cheeky way of asserting that the nodes are in the right order
+    // on the tracker page.
+    // It's almost certainly too brittle.
+    $pattern = '/' . preg_quote($node_one->getTitle()) . '.+' . preg_quote($node_two->getTitle()) . '/s';
+    // Verify that the most recent comment on node appears at the top of
+    // tracker.
+    $this->assertSession()->responseMatches($pattern);
+  }
+
+  /**
+   * Tests that existing nodes are indexed by cron.
+   */
+  public function testTrackerCronIndexing(): void {
+    $this->drupalLogin($this->user);
+
+    // Create 3 nodes.
+    $edits = [];
+    $nodes = [];
+    for ($i = 1; $i <= 3; $i++) {
+      $edits[$i] = [
+        'title' => $this->randomMachineName(),
+      ];
+      $nodes[$i] = $this->drupalCreateNode($edits[$i]);
+    }
+
+    // Add a comment to the last node as other user.
+    $this->drupalLogin($this->otherUser);
+    $comment = [
+      'subject[0][value]' => $this->randomMachineName(),
+      'comment_body[0][value]' => $this->randomMachineName(20),
+    ];
+    $this->drupalGet('comment/reply/node/' . $nodes[3]->id() . '/comment');
+    $this->submitForm($comment, 'Save');
+
+    // Create an unpublished node.
+    $unpublished = $this->drupalCreateNode([
+      'title' => $this->randomMachineName(8),
+      'status' => 0,
+    ]);
+
+    $this->drupalGet('activity');
+    $this->assertSession()->responseNotContains($unpublished->label());
+
+    // Start indexing backwards from node 4.
+    \Drupal::state()->set('tracker.index_nid', 4);
+
+    // Clear the current tracker tables and rebuild them.
+    $connection = Database::getConnection();
+    $connection->delete('tracker_node')
+      ->execute();
+    $connection->delete('tracker_user')
+      ->execute();
+    tracker_cron();
+
+    $this->drupalLogin($this->user);
+
+    // Fetch the user's tracker.
+    $this->drupalGet('activity/' . $this->user->id());
+
+    // Assert that all node titles are displayed.
+    foreach ($nodes as $i => $node) {
+      $this->assertSession()->pageTextContains($node->label());
+    }
+
+    // Fetch the site-wide tracker.
+    $this->drupalGet('activity');
+
+    // Assert that all node titles are displayed.
+    foreach ($nodes as $i => $node) {
+      $this->assertSession()->pageTextContains($node->label());
+    }
+  }
+
+  /**
+   * Tests that publish/unpublish works at admin/content/node.
+   */
+  public function testTrackerAdminUnpublish(): void {
+    \Drupal::service('module_installer')->install(['views']);
+    $admin_user = $this->drupalCreateUser([
+      'access content overview',
+      'administer nodes',
+      'bypass node access',
+    ]);
+    $this->drupalLogin($admin_user);
+
+    $node = $this->drupalCreateNode([
+      'title' => $this->randomMachineName(),
+    ]);
+
+    // Assert that the node is displayed.
+    $this->drupalGet('activity');
+    $this->assertSession()->pageTextContains($node->label());
+
+    // Unpublish the node and ensure that it's no longer displayed.
+    $edit = [
+      'action' => 'node_unpublish_action',
+      'node_bulk_form[0]' => $node->id(),
+    ];
+    $this->drupalGet('admin/content');
+    $this->submitForm($edit, 'Apply to selected items');
+
+    $this->drupalGet('activity');
+    $this->assertSession()->pageTextContains('No content available.');
+  }
+
+  /**
+   * Passes if the appropriate history metadata exists.
+   *
+   * Verify the data-history-node-id, data-history-node-timestamp and
+   * data-history-node-last-comment-timestamp attributes, which are used by the
+   * drupal.tracker-history library to add the appropriate "new" and "updated"
+   * indicators, as well as the "x new" replies link to the tracker.
+   * We do this in JavaScript to prevent breaking the render cache.
+   *
+   * @param string|int $node_id
+   *   A node ID, that must exist as a data-history-node-id attribute
+   * @param int $node_timestamp
+   *   A node timestamp, that must exist as a data-history-node-timestamp
+   *   attribute.
+   * @param int $node_last_comment_timestamp
+   *   A node's last comment timestamp, that must exist as a
+   *   data-history-node-last-comment-timestamp attribute.
+   * @param bool $library_is_present
+   *   Whether the drupal.tracker-history library should be present or not.
+   *
+   * @internal
+   */
+  public function assertHistoryMetadata(string|int $node_id, int $node_timestamp, int $node_last_comment_timestamp, bool $library_is_present = TRUE): void {
+    $settings = $this->getDrupalSettings();
+    $this->assertSame($library_is_present, isset($settings['ajaxPageState']) && in_array('tracker/history', explode(',', $settings['ajaxPageState']['libraries'])), 'drupal.tracker-history library is present.');
+    $this->assertSession()->elementsCount('xpath', '//table/tbody/tr/td[@data-history-node-id="' . $node_id . '" and @data-history-node-timestamp="' . $node_timestamp . '"]', 1);
+    $this->assertSession()->elementsCount('xpath', '//table/tbody/tr/td[@data-history-node-last-comment-timestamp="' . $node_last_comment_timestamp . '"]', 1);
+  }
+
+}

core/modules/tracker/tests/src/Kernel/Migrate/d7/MigrateDrupalTestBase.php

@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\tracker\Kernel\Migrate\d7;
+
+use Drupal\migrate_drupal\NodeMigrateType;
+use Drupal\Tests\migrate_drupal\Kernel\MigrateDrupalTestBase as CoreMigrateDrupalTestBase;
+use Drupal\Tests\migrate_drupal\Traits\NodeMigrateTypeTestTrait;
+
+/**
+ * Base class for Tracker Drupal 7 migration tests.
+ */
+abstract class MigrateDrupalTestBase extends CoreMigrateDrupalTestBase {
+
+  use NodeMigrateTypeTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+    // Add a node classic migrate table to the destination site so that tests
+    // run by default with the classic node migrations.
+    $this->makeNodeMigrateMapTable(NodeMigrateType::NODE_MIGRATE_TYPE_CLASSIC, '7');
+    $this->loadFixture($this->getFixtureFilePath());
+  }
+
+  /**
+   * Gets the path to the fixture file.
+   */
+  protected function getFixtureFilePath() {
+    return __DIR__ . '/../../../../fixtures/drupal7.php';
+  }
+
+  /**
+   * Executes all user migrations.
+   *
+   * @param bool $include_pictures
+   *   (optional) If TRUE, migrates user pictures. Defaults to TRUE.
+   */
+  protected function migrateUsers($include_pictures = TRUE) {
+    $migrations = ['d7_user_role', 'd7_user'];
+
+    if ($include_pictures) {
+      // Prepare to migrate user pictures as well.
+      $this->installEntitySchema('file');
+      $migrations = array_merge([
+        'user_picture_field',
+        'user_picture_field_instance',
+      ], $migrations);
+    }
+
+    $this->executeMigrations($migrations);
+  }
+
+  /**
+   * Migrates node types.
+   */
+  protected function migrateContentTypes() {
+    $this->installConfig(['node']);
+    $this->installEntitySchema('node');
+    $this->executeMigration('d7_node_type');
+  }
+
+}

core/modules/tracker/tests/src/Kernel/Migrate/d7/MigrateTrackerNodeTest.php

@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\tracker\Kernel\Migrate\d7;
+
+use Drupal\Core\Database\Database;
+
+/**
+ * Tests migration of tracker_node.
+ *
+ * @group tracker
+ * @group legacy
+ */
+class MigrateTrackerNodeTest extends MigrateDrupalTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = [
+    'menu_ui',
+    'node',
+    'text',
+    'tracker',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+
+    $this->installEntitySchema('node');
+    $this->installConfig(static::$modules);
+    $this->installSchema('node', ['node_access']);
+    $this->installSchema('tracker', ['tracker_node', 'tracker_user']);
+
+    $this->migrateContentTypes();
+    $this->migrateUsers(FALSE);
+    $this->executeMigrations([
+      'd7_node',
+      'd7_tracker_node',
+    ]);
+  }
+
+  /**
+   * Tests migration of tracker node table.
+   */
+  public function testMigrateTrackerNode(): void {
+    $connection = Database::getConnection('default', 'migrate');
+    $num_rows = $connection
+      ->select('tracker_node', 'tn')
+      ->fields('tn', ['nid', 'published', 'changed'])
+      ->countQuery()
+      ->execute()
+      ->fetchField();
+    $this->assertSame('1', $num_rows);
+
+    $tracker_nodes = $connection
+      ->select('tracker_node', 'tn')
+      ->fields('tn', ['nid', 'published', 'changed'])
+      ->execute();
+    $row = $tracker_nodes->fetchAssoc();
+    $this->assertSame('1', $row['nid']);
+    $this->assertSame('1', $row['published']);
+    $this->assertSame('1421727536', $row['changed']);
+  }
+
+}

core/modules/tracker/tests/src/Kernel/Migrate/d7/MigrateTrackerSettingsTest.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\tracker\Kernel\Migrate\d7;
+
+/**
+ * Tests migration of Tracker settings to configuration.
+ *
+ * @group tracker
+ * @group legacy
+ */
+class MigrateTrackerSettingsTest extends MigrateDrupalTestBase {
+
+  protected static $modules = ['tracker'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+    $this->installConfig(['tracker']);
+    $this->executeMigration('d7_tracker_settings');
+  }
+
+  /**
+   * Tests migration of tracker's variables to configuration.
+   */
+  public function testMigration(): void {
+    $this->assertSame(999, \Drupal::config('tracker.settings')->get('cron_index_limit'));
+  }
+
+}

core/modules/tracker/tests/src/Kernel/Migrate/d7/MigrateTrackerUserTest.php

@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\tracker\Kernel\Migrate\d7;
+
+use Drupal\Core\Database\Database;
+
+/**
+ * Tests migration of tracker_user.
+ *
+ * @group tracker
+ * @group legacy
+ */
+class MigrateTrackerUserTest extends MigrateDrupalTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = [
+    'menu_ui',
+    'node',
+    'text',
+    'tracker',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+
+    $this->installEntitySchema('node');
+    $this->installConfig(static::$modules);
+    $this->installSchema('node', ['node_access']);
+    $this->installSchema('tracker', ['tracker_node', 'tracker_user']);
+
+    $this->migrateContentTypes();
+    $this->migrateUsers(FALSE);
+    $this->executeMigrations([
+      'd7_node',
+      'd7_tracker_node',
+    ]);
+  }
+
+  /**
+   * Tests migration of tracker user table.
+   */
+  public function testMigrateTrackerUser(): void {
+    $connection = Database::getConnection('default', 'migrate');
+    $num_rows = $connection
+      ->select('tracker_user', 'tn')
+      ->fields('tu', ['nid', 'uid', 'published', 'changed'])
+      ->countQuery()
+      ->execute()
+      ->fetchField();
+    $this->assertSame('1', $num_rows);
+
+    $tracker_nodes = $connection
+      ->select('tracker_user', 'tu')
+      ->fields('tu', ['nid', 'uid', 'published', 'changed'])
+      ->execute();
+    $row = $tracker_nodes->fetchAssoc();
+    $this->assertSame('1', $row['nid']);
+    $this->assertSame('2', $row['uid']);
+    $this->assertSame('1', $row['published']);
+    $this->assertSame('1421727536', $row['changed']);
+  }
+
+}

core/modules/tracker/tests/src/Kernel/Plugin/migrate/source/d7/TrackerNodeTest.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\tracker\Kernel\Plugin\migrate\source\d7;
+
+use Drupal\Tests\migrate\Kernel\MigrateSqlSourceTestBase;
+
+/**
+ * Tests D7 tracker node source plugin.
+ *
+ * @covers Drupal\tracker\Plugin\migrate\source\d7\TrackerNode
+ *
+ * @group tracker
+ * @group legacy
+ */
+class TrackerNodeTest extends MigrateSqlSourceTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = ['tracker', 'migrate_drupal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function providerSource() {
+    $tests = [];
+
+    // The source data.
+    $tests[0]['database']['tracker_node'] = [
+      [
+        'nid' => '2',
+        'published' => '1',
+        'changed' => '1421727536',
+      ],
+    ];
+
+    // The expected results are identical to the source data.
+    $tests[0]['expected_results'] = $tests[0]['database']['tracker_node'];
+
+    return $tests;
+  }
+
+}

core/modules/tracker/tests/src/Kernel/Plugin/migrate/source/d7/TrackerUserTest.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\tracker\Kernel\Plugin\migrate\source\d7;
+
+use Drupal\Tests\migrate\Kernel\MigrateSqlSourceTestBase;
+
+/**
+ * Tests D7 tracker user source plugin.
+ *
+ * @covers Drupal\tracker\Plugin\migrate\source\d7\TrackerUser
+ *
+ * @group tracker
+ * @group legacy
+ */
+class TrackerUserTest extends MigrateSqlSourceTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = ['tracker', 'migrate_drupal'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function providerSource() {
+    $tests = [];
+
+    // The source data.
+    $tests[0]['database']['tracker_user'] = [
+      [
+        'nid' => '1',
+        'uid' => '2',
+        'published' => '1',
+        'changed' => '1421727536',
+      ],
+    ];
+
+    // The expected results are identical to the source data.
+    $tests[0]['expected_results'] = $tests[0]['database']['tracker_user'];
+
+    return $tests;
+  }
+
+}

core/modules/tracker/tests/src/Kernel/Views/TrackerUserUidTest.php

@@ -0,0 +1,101 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\tracker\Kernel\Views;
+
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\Tests\node\Traits\NodeCreationTrait;
+use Drupal\Tests\user\Traits\UserCreationTrait;
+use Drupal\views\Tests\ViewResultAssertionTrait;
+use Drupal\views\Tests\ViewTestData;
+use Drupal\views\Views;
+
+/**
+ * Tests the tracker user uid handlers.
+ *
+ * @group tracker
+ * @group legacy
+ */
+class TrackerUserUidTest extends KernelTestBase {
+
+  use NodeCreationTrait;
+  use UserCreationTrait;
+  use ViewResultAssertionTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = [
+    'filter',
+    'node',
+    'system',
+    'tracker',
+    'tracker_test_views',
+    'user',
+    'views',
+  ];
+
+  /**
+   * Views used by this test.
+   *
+   * @var array
+   */
+  public static $testViews = ['test_tracker_user_uid'];
+
+  /**
+   * Tests the user uid filter and argument.
+   */
+  public function testUserUid(): void {
+    $this->installConfig(['filter']);
+    $this->installEntitySchema('user');
+    $this->installEntitySchema('node');
+    $this->installSchema('tracker', ['tracker_node', 'tracker_user']);
+
+    ViewTestData::createTestViews(static::class, ['tracker_test_views']);
+    $node = $this->createNode();
+
+    $map = [
+      'nid' => 'nid',
+      'title' => 'title',
+    ];
+
+    $expected = [
+      [
+        'nid' => $node->id(),
+        'title' => $node->label(),
+      ],
+    ];
+
+    $view = Views::getView('test_tracker_user_uid');
+    $view->preview();
+
+    // We should have no results as the filter is set for uid 0.
+    $this->assertIdenticalResultSet($view, [], $map);
+    $view->destroy();
+
+    // Change the filter value to our user.
+    $view->initHandlers();
+    $view->filter['uid_touch_tracker']->value = $node->getOwnerId();
+    $view->preview();
+
+    // We should have one result as the filter is set for the created user.
+    $this->assertIdenticalResultSet($view, $expected, $map);
+    $view->destroy();
+
+    // Remove the filter now, so only the argument will affect the query.
+    $view->removeHandler('default', 'filter', 'uid_touch_tracker');
+
+    // Test the incorrect argument UID.
+    $view->initHandlers();
+    $view->preview(NULL, [rand()]);
+    $this->assertIdenticalResultSet($view, [], $map);
+    $view->destroy();
+
+    // Test the correct argument UID.
+    $view->initHandlers();
+    $view->preview(NULL, [$node->getOwnerId()]);
+    $this->assertIdenticalResultSet($view, $expected, $map);
+  }
+
+}

core/modules/tracker/tracker.info.yml

@@ -0,0 +1,15 @@
+name: Activity Tracker
+type: module
+description: 'Displays recently added and updated content.'
+lifecycle: deprecated
+lifecycle_link: 'https://www.drupal.org/about/core/policies/core-change-policies/deprecated-and-obsolete-modules-and-themes#s-activity-tracker'
+dependencies:
+  - drupal:node
+  - drupal:comment
+package: Core
+# version: VERSION
+
+# Information added by Drupal.org packaging script on 2024-07-04
+version: '10.3.1'
+project: 'drupal'
+datestamp: 1720094222

core/modules/tracker/tracker.install

@@ -0,0 +1,150 @@
+<?php
+
+/**
+ * @file
+ * Install, update, and uninstall functions for tracker.module.
+ */
+
+/**
+ * Implements hook_uninstall().
+ */
+function tracker_uninstall() {
+  \Drupal::state()->delete('tracker.index_nid');
+}
+
+/**
+ * Implements hook_install().
+ */
+function tracker_install() {
+  $max_nid = \Drupal::database()->query('SELECT MAX([nid]) FROM {node}')->fetchField();
+  if ($max_nid != 0) {
+    \Drupal::state()->set('tracker.index_nid', $max_nid);
+    // To avoid timing out while attempting to do a complete indexing, we
+    // simply call our cron job to remove stale records and begin the process.
+    tracker_cron();
+  }
+}
+
+/**
+ * Implements hook_schema().
+ */
+function tracker_schema() {
+  $schema['tracker_node'] = [
+    'description' => 'Tracks when nodes were last changed or commented on.',
+    'fields' => [
+      'nid' => [
+        'description' => 'The {node}.nid this record tracks.',
+        'type' => 'int',
+        'unsigned' => TRUE,
+        'not null' => TRUE,
+        'default' => 0,
+      ],
+      'published' => [
+        'description' => 'Boolean indicating whether the node is published.',
+        'type' => 'int',
+        'not null' => FALSE,
+        'default' => 0,
+        'size' => 'tiny',
+      ],
+      'changed' => [
+        'description' => 'The Unix timestamp when the node was most recently saved or commented on.',
+        'type' => 'int',
+        'unsigned' => TRUE,
+        'not null' => TRUE,
+        'default' => 0,
+        'size' => 'big',
+      ],
+    ],
+    'indexes' => [
+      'tracker' => ['published', 'changed'],
+    ],
+    'primary key' => ['nid'],
+    'foreign keys' => [
+      'tracked_node' => [
+        'table' => 'node',
+        'columns' => ['nid' => 'nid'],
+      ],
+    ],
+  ];
+
+  $schema['tracker_user'] = [
+    'description' => 'Tracks when nodes were last changed or commented on, for each user that authored the node or one of its comments.',
+    'fields' => [
+      'nid' => [
+        'description' => 'The {node}.nid this record tracks.',
+        'type' => 'int',
+        'unsigned' => TRUE,
+        'not null' => TRUE,
+        'default' => 0,
+      ],
+      'uid' => [
+        'description' => 'The {users}.uid of the node author or commenter.',
+        'type' => 'int',
+        'unsigned' => TRUE,
+        'not null' => TRUE,
+        'default' => 0,
+      ],
+      'published' => [
+        'description' => 'Boolean indicating whether the node is published.',
+        'type' => 'int',
+        'not null' => FALSE,
+        'default' => 0,
+        'size' => 'tiny',
+      ],
+      'changed' => [
+        'description' => 'The Unix timestamp when the node was most recently saved or commented on.',
+        'type' => 'int',
+        'unsigned' => TRUE,
+        'not null' => TRUE,
+        'default' => 0,
+        'size' => 'big',
+      ],
+    ],
+    'indexes' => [
+      'tracker' => ['uid', 'published', 'changed'],
+    ],
+    'primary key' => ['nid', 'uid'],
+    'foreign keys' => [
+      'tracked_node' => [
+        'table' => 'node',
+        'columns' => ['nid' => 'nid'],
+      ],
+      'tracked_user' => [
+        'table' => 'users',
+        'columns' => ['uid' => 'uid'],
+      ],
+    ],
+  ];
+
+  return $schema;
+}
+
+/**
+ * Remove the year 2038 date limitation.
+ */
+function tracker_update_10100(&$sandbox = NULL) {
+  $connection = \Drupal::database();
+  if ($connection->schema()->tableExists('tracker_node') && $connection->databaseType() != 'sqlite') {
+    $new = [
+      'description' => 'The Unix timestamp when the node was most recently saved or commented on.',
+      'type' => 'int',
+      'unsigned' => TRUE,
+      'not null' => TRUE,
+      'default' => 0,
+      'size' => 'big',
+    ];
+    $connection->schema()->changeField('tracker_node', 'changed', 'changed', $new);
+  }
+  if ($connection->schema()->tableExists('tracker_user') && $connection->databaseType() != 'sqlite') {
+    $new = [
+      'description' => 'The Unix timestamp when the node was most recently saved or commented on.',
+      'type' => 'int',
+      'unsigned' => TRUE,
+      'not null' => TRUE,
+      'default' => 0,
+      'size' => 'big',
+    ];
+    $connection->schema()->changeField('tracker_user', 'changed', 'changed', $new);
+  }
+
+}

core/modules/tracker/tracker.libraries.yml

@@ -0,0 +1,8 @@
+history:
+  version: VERSION
+  js:
+    js/tracker-history.js: {}
+  dependencies:
+    - core/jquery
+    - core/drupal
+    - history/api

core/modules/tracker/tracker.links.menu.yml

@@ -0,0 +1,3 @@
+tracker.page:
+  title: 'Recent content'
+  route_name: tracker.page

core/modules/tracker/tracker.links.task.yml

@@ -0,0 +1,15 @@
+tracker.page_tab:
+  route_name: tracker.page
+  title: 'Recent content'
+  base_route: tracker.page
+
+tracker.users_recent_tab:
+  route_name: tracker.users_recent_content
+  title: 'My recent content'
+  base_route: tracker.page
+  class: '\Drupal\tracker\Plugin\Menu\UserTrackerTab'
+
+tracker.user_tab:
+  route_name: tracker.user_tab
+  base_route: entity.user.canonical
+  title: 'Activity'

core/modules/tracker/tracker.module

@@ -0,0 +1,355 @@
+<?php
+
+/**
+ * @file
+ * Tracks recent content posted by a user or users.
+ */
+
+use Drupal\Core\Url;
+use Drupal\Core\Entity\EntityInterface;
+use Drupal\comment\CommentInterface;
+use Drupal\Core\Routing\RouteMatchInterface;
+use Drupal\node\Entity\Node;
+use Drupal\node\NodeInterface;
+
+/**
+ * Implements hook_help().
+ */
+function tracker_help($route_name, RouteMatchInterface $route_match) {
+  switch ($route_name) {
+    case 'help.page.tracker':
+      $output = '<h2>' . t('About') . '</h2>';
+      $output .= '<p>' . t('The Activity Tracker module displays the most recently added and updated content on your site, and allows you to follow new content created by each user. This module has no configuration options. For more information, see the <a href=":tracker">online documentation for the Activity Tracker module</a>.', [':tracker' => 'https://www.drupal.org/documentation/modules/tracker']) . '</p>';
+      $output .= '<h2>' . t('Uses') . '</h2>';
+      $output .= '<dl>';
+      $output .= '<dt>' . t('Tracking new and updated site content') . '</dt>';
+      $output .= '<dd>' . t('The <a href=":recent">Recent content</a> page shows new and updated content in reverse chronological order, listing the content type, title, author\'s name, number of comments, and time of last update. Content is considered updated when changes occur in the text, or when new comments are added. The <em>My recent content</em> tab limits the list to the currently logged-in user.', [':recent' => Url::fromRoute('tracker.page')->toString()]) . '</dd>';
+      $output .= '<dt>' . t('Tracking user-specific content') . '</dt>';
+      $output .= '<dd>' . t("To follow a specific user's new and updated content, select the <em>Activity</em> tab from the user's profile page.") . '</dd>';
+      $output .= '</dl>';
+      return $output;
+  }
+}
+
+/**
+ * Implements hook_cron().
+ *
+ * Updates tracking information for any items still to be tracked. The state
+ * 'tracker.index_nid' is set to ((the last node ID that was indexed) - 1) and
+ * used to select the nodes to be processed. If there are no remaining nodes to
+ * process, 'tracker.index_nid' will be 0.
+ * This process does not run regularly on live sites, rather it updates tracking
+ * info once on an existing site just after the tracker module was installed.
+ */
+function tracker_cron() {
+  $state = \Drupal::state();
+  $max_nid = $state->get('tracker.index_nid') ?: 0;
+  if ($max_nid > 0) {
+    $last_nid = FALSE;
+    $count = 0;
+
+    $nids = \Drupal::entityQuery('node')
+      ->accessCheck(FALSE)
+      ->condition('nid', $max_nid, '<=')
+      ->sort('nid', 'DESC')
+      ->range(0, \Drupal::config('tracker.settings')->get('cron_index_limit'))
+      ->execute();
+
+    $nodes = Node::loadMultiple($nids);
+    $connection = \Drupal::database();
+    foreach ($nodes as $nid => $node) {
+
+      // Calculate the changed timestamp for this node.
+      $changed = _tracker_calculate_changed($node);
+
+      // Remove existing data for this node.
+      $connection->delete('tracker_node')
+        ->condition('nid', $nid)
+        ->execute();
+      $connection->delete('tracker_user')
+        ->condition('nid', $nid)
+        ->execute();
+
+      // Insert the node-level data.
+      $connection->insert('tracker_node')
+        ->fields([
+          'nid' => $nid,
+          'published' => (int) $node->isPublished(),
+          'changed' => $changed,
+        ])
+        ->execute();
+
+      // Insert the user-level data for the node's author.
+      $connection->insert('tracker_user')
+        ->fields([
+          'nid' => $nid,
+          'published' => (int) $node->isPublished(),
+          'changed' => $changed,
+          'uid' => $node->getOwnerId(),
+        ])
+        ->execute();
+
+      // Insert the user-level data for the commenters (except if a commenter
+      // is the node's author).
+
+      // Get unique user IDs via entityQueryAggregate because it's the easiest
+      // database agnostic way. We don't actually care about the comments here
+      // so don't add an aggregate field.
+      $result = \Drupal::entityQueryAggregate('comment')
+        ->accessCheck(FALSE)
+        ->condition('entity_type', 'node')
+        ->condition('entity_id', $node->id())
+        ->condition('uid', $node->getOwnerId(), '<>')
+        ->condition('status', CommentInterface::PUBLISHED)
+        ->groupBy('uid')
+        ->execute();
+      if ($result) {
+        $query = $connection->insert('tracker_user');
+        foreach ($result as $row) {
+          $query->fields([
+            'uid' => $row['uid'],
+            'nid' => $nid,
+            'published' => CommentInterface::PUBLISHED,
+            'changed' => $changed,
+          ]);
+        }
+        $query->execute();
+      }
+
+      // Note that we have indexed at least one node.
+      $last_nid = $nid;
+
+      $count++;
+    }
+
+    if ($last_nid !== FALSE) {
+      // Prepare a starting point for the next run.
+      $state->set('tracker.index_nid', $last_nid - 1);
+
+      \Drupal::logger('tracker')->notice('Indexed %count content items for tracking.', ['%count' => $count]);
+    }
+    else {
+      // If all nodes have been indexed, set to zero to skip future cron runs.
+      $state->set('tracker.index_nid', 0);
+    }
+  }
+}
+
+/**
+ * Implements hook_ENTITY_TYPE_insert() for node entities.
+ *
+ * Adds new tracking information for this node since it's new.
+ */
+function tracker_node_insert(NodeInterface $node, $arg = 0) {
+  _tracker_add($node->id(), $node->getOwnerId(), $node->getChangedTime());
+}
+
+/**
+ * Implements hook_ENTITY_TYPE_update() for node entities.
+ *
+ * Adds tracking information for this node since it's been updated.
+ */
+function tracker_node_update(NodeInterface $node, $arg = 0) {
+  _tracker_add($node->id(), $node->getOwnerId(), $node->getChangedTime());
+}
+
+/**
+ * Implements hook_ENTITY_TYPE_predelete() for node entities.
+ *
+ * Deletes tracking information for a node.
+ */
+function tracker_node_predelete(EntityInterface $node, $arg = 0) {
+  $connection = \Drupal::database();
+  $connection->delete('tracker_node')
+    ->condition('nid', $node->id())
+    ->execute();
+  $connection->delete('tracker_user')
+    ->condition('nid', $node->id())
+    ->execute();
+}
+
+/**
+ * Implements hook_ENTITY_TYPE_update() for comment entities.
+ */
+function tracker_comment_update(CommentInterface $comment) {
+  if ($comment->getCommentedEntityTypeId() == 'node') {
+    if ($comment->isPublished()) {
+      _tracker_add($comment->getCommentedEntityId(), $comment->getOwnerId(), $comment->getChangedTime());
+    }
+    else {
+      _tracker_remove($comment->getCommentedEntityId(), $comment->getOwnerId(), $comment->getChangedTime());
+    }
+  }
+}
+
+/**
+ * Implements hook_ENTITY_TYPE_insert() for comment entities.
+ */
+function tracker_comment_insert(CommentInterface $comment) {
+  if ($comment->getCommentedEntityTypeId() == 'node' && $comment->isPublished()) {
+    _tracker_add($comment->getCommentedEntityId(), $comment->getOwnerId(), $comment->getChangedTime());
+  }
+}
+
+/**
+ * Implements hook_ENTITY_TYPE_delete() for comment entities.
+ */
+function tracker_comment_delete(CommentInterface $comment) {
+  if ($comment->getCommentedEntityTypeId() == 'node') {
+    _tracker_remove($comment->getCommentedEntityId(), $comment->getOwnerId(), $comment->getChangedTime());
+  }
+}
+
+/**
+ * Updates indexing tables when a node is added, updated, or commented on.
+ *
+ * @param int $nid
+ *   A node ID.
+ * @param int $uid
+ *   The node or comment author.
+ * @param int $changed
+ *   The node updated timestamp or comment timestamp.
+ */
+function _tracker_add($nid, $uid, $changed) {
+  $connection = \Drupal::database();
+  // @todo This should be actually filtering on the desired language and just
+  //   fall back to the default language.
+  $node = $connection->query('SELECT [nid], [status], [uid], [changed] FROM {node_field_data} WHERE [nid] = :nid AND [default_langcode] = 1 ORDER BY [changed] DESC, [status] DESC', [':nid' => $nid])->fetchObject();
+
+  // Adding a comment can only increase the changed timestamp, so our
+  // calculation here is simple.
+  $changed = max($node->changed, $changed);
+
+  // Update the node-level data.
+  $connection->merge('tracker_node')
+    ->key('nid', $nid)
+    ->fields([
+      'changed' => $changed,
+      'published' => $node->status,
+    ])
+    ->execute();
+
+  // Create or update the user-level data, first for the user posting.
+  $connection->merge('tracker_user')
+    ->keys([
+      'nid' => $nid,
+      'uid' => $uid,
+    ])
+    ->fields([
+      'changed' => $changed,
+      'published' => $node->status,
+    ])
+    ->execute();
+  // Update the times for all the other users tracking the post.
+  $connection->update('tracker_user')
+    ->condition('nid', $nid)
+    ->fields([
+      'changed' => $changed,
+      'published' => $node->status,
+    ])
+    ->execute();
+}
+
+/**
+ * Picks the most recent timestamp between node changed and the last comment.
+ *
+ * @param \Drupal\node\NodeInterface $node
+ *   The node entity.
+ *
+ * @return int
+ *   The node changed timestamp, or most recent comment timestamp, whichever is
+ *   the greatest.
+ *
+ * @todo Check if we should introduce 'language context' here, because the
+ *   callers may need different timestamps depending on the users' language?
+ */
+function _tracker_calculate_changed($node) {
+  $changed = $node->getChangedTime();
+  $latest_comment = \Drupal::service('comment.statistics')->read([$node], 'node', FALSE);
+  if ($latest_comment && $latest_comment->last_comment_timestamp > $changed) {
+    $changed = $latest_comment->last_comment_timestamp;
+  }
+  return $changed;
+}
+
+/**
+ * Cleans up indexed data when nodes or comments are removed.
+ *
+ * @param int $nid
+ *   The node ID.
+ * @param int $uid
+ *   The author of the node or comment.
+ * @param int $changed
+ *   The last changed timestamp of the node.
+ */
+function _tracker_remove($nid, $uid = NULL, $changed = NULL) {
+  $node = Node::load($nid);
+  $connection = \Drupal::database();
+
+  // The user only keeps their subscription if the node exists.
+  if ($node) {
+    // And they are the author of the node.
+    $keep_subscription = ($node->getOwnerId() == $uid);
+
+    // Or if they have commented on the node.
+    if (!$keep_subscription) {
+      // Check if the user has commented at least once on the given nid.
+      $keep_subscription = \Drupal::entityQuery('comment')
+        ->accessCheck(FALSE)
+        ->condition('entity_type', 'node')
+        ->condition('entity_id', $nid)
+        ->condition('uid', $uid)
+        ->condition('status', CommentInterface::PUBLISHED)
+        ->range(0, 1)
+        ->count()
+        ->execute();
+    }
+
+    // If we haven't found a reason to keep the user's subscription, delete it.
+    if (!$keep_subscription) {
+      $connection->delete('tracker_user')
+        ->condition('nid', $nid)
+        ->condition('uid', $uid)
+        ->execute();
+    }
+
+    // Now we need to update the (possibly) changed timestamps for other users
+    // and the node itself.
+    // We only need to do this if the removed item has a timestamp that equals
+    // or exceeds the listed changed timestamp for the node.
+    $tracker_node = $connection->query('SELECT [nid], [changed] FROM {tracker_node} WHERE [nid] = :nid', [':nid' => $nid])->fetchObject();
+    if ($tracker_node && $changed >= $tracker_node->changed) {
+      // If we're here, the item being removed is *possibly* the item that
+      // established the node's changed timestamp.
+
+      // We just have to recalculate things from scratch.
+      $changed = _tracker_calculate_changed($node);
+
+      // And then we push the out the new changed timestamp to our denormalized
+      // tables.
+      $connection->update('tracker_node')
+        ->fields([
+          'changed' => $changed,
+          'published' => $node->isPublished(),
+        ])
+        ->condition('nid', $nid)
+        ->execute();
+      $connection->update('tracker_node')
+        ->fields([
+          'changed' => $changed,
+          'published' => $node->isPublished(),
+        ])
+        ->condition('nid', $nid)
+        ->execute();
+    }
+  }
+  else {
+    // If the node doesn't exist, remove everything.
+    $connection->delete('tracker_node')
+      ->condition('nid', $nid)
+      ->execute();
+    $connection->delete('tracker_user')
+      ->condition('nid', $nid)
+      ->execute();
+  }
+}

core/modules/tracker/tracker.routing.yml

@@ -0,0 +1,27 @@
+tracker.page:
+  path: '/activity'
+  defaults:
+    _controller: '\Drupal\tracker\Controller\TrackerController::buildContent'
+    _title: 'Recent content'
+  requirements:
+    _permission: 'access content'
+
+tracker.users_recent_content:
+  path: '/activity/{user}'
+  defaults:
+    _controller: '\Drupal\tracker\Controller\TrackerController::buildContent'
+    _title: 'My recent content'
+  requirements:
+    _permission: 'access content'
+    _custom_access: '\Drupal\tracker\Controller\TrackerController::checkAccess'
+    user: \d+
+
+tracker.user_tab:
+  path: '/user/{user}/activity'
+  defaults:
+    _controller: '\Drupal\tracker\Controller\TrackerController::buildContent'
+    _title_callback: '\Drupal\tracker\Controller\TrackerController::getTitle'
+  requirements:
+    _permission: 'access content'
+    _entity_access: 'user.view'
+    user: \d+

core/modules/tracker/tracker.views.inc

@@ -0,0 +1,179 @@
+<?php
+
+/**
+ * @file
+ * Provide views data for tracker.module.
+ */
+
+/**
+ * Implements hook_views_data().
+ */
+function tracker_views_data() {
+  $data = [];
+
+  $data['tracker_node']['table']['group'] = t('Tracker');
+  $data['tracker_node']['table']['join'] = [
+    'node_field_data' => [
+      'type' => 'INNER',
+      'left_field' => 'nid',
+      'field' => 'nid',
+    ],
+  ];
+  $data['tracker_node']['nid'] = [
+    'title' => t('Nid'),
+    'help' => t('The node ID of the node.'),
+    'field' => [
+      'id' => 'node',
+    ],
+    'argument' => [
+      'id' => 'node_nid',
+      'name field' => 'title',
+      'numeric' => TRUE,
+      'validate type' => 'nid',
+    ],
+    'filter' => [
+      'id' => 'numeric',
+    ],
+    'sort' => [
+      'id' => 'standard',
+    ],
+  ];
+  $data['tracker_node']['published'] = [
+    'title' => t('Published'),
+    'help' => t('Whether or not the node is published.'),
+    'field' => [
+      'id' => 'boolean',
+    ],
+    'filter' => [
+      'id' => 'boolean',
+      'label' => t('Published'),
+      'type' => 'yes-no',
+      'accept null' => TRUE,
+      'use_equal' => TRUE,
+    ],
+    'sort' => [
+      'id' => 'standard',
+    ],
+  ];
+  $data['tracker_node']['changed'] = [
+    'title' => t('Updated date'),
+    'help' => t('The date the node was last updated.'),
+    'field' => [
+      'id' => 'date',
+    ],
+    'sort' => [
+      'id' => 'date',
+    ],
+    'filter' => [
+      'id' => 'date',
+    ],
+  ];
+
+  $data['tracker_user']['table']['group'] = t('Tracker - User');
+  $data['tracker_user']['table']['join'] = [
+    'node_field_data' => [
+      'type' => 'INNER',
+      'left_field' => 'nid',
+      'field' => 'nid',
+    ],
+    'user_field_data' => [
+      'type' => 'INNER',
+      'left_field' => 'uid',
+      'field' => 'uid',
+    ],
+  ];
+  $data['tracker_user']['nid'] = [
+    'title' => t('Nid'),
+    'help' => t('The node ID of the node a user created or commented on. You must use an argument or filter on UID or you will get misleading results using this field.'),
+    'field' => [
+      'id' => 'node',
+    ],
+    'argument' => [
+      'id' => 'node_nid',
+      'name field' => 'title',
+      'numeric' => TRUE,
+      'validate type' => 'nid',
+    ],
+    'filter' => [
+      'id' => 'numeric',
+    ],
+    'sort' => [
+      'id' => 'standard',
+    ],
+  ];
+  $data['tracker_user']['uid'] = [
+    'title' => t('Uid'),
+    'help' => t('The user ID of a user who touched the node (either created or commented on it).'),
+    'field' => [
+      'id' => 'user_name',
+    ],
+    'argument' => [
+      'id' => 'user_uid',
+      'name field' => 'name',
+    ],
+    'filter' => [
+      'title' => t('Name'),
+      'id' => 'user_name',
+    ],
+    'sort' => [
+      'id' => 'standard',
+    ],
+  ];
+  $data['tracker_user']['published'] = [
+    'title' => t('Published'),
+    'help' => t('Whether or not the node is published. You must use an argument or filter on UID or you will get misleading results using this field.'),
+    'field' => [
+      'id' => 'boolean',
+    ],
+    'filter' => [
+      'id' => 'boolean',
+      'label' => t('Published'),
+      'type' => 'yes-no',
+      'accept null' => TRUE,
+      'use_equal' => TRUE,
+    ],
+    'sort' => [
+      'id' => 'standard',
+    ],
+  ];
+  $data['tracker_user']['changed'] = [
+    'title' => t('Updated date'),
+    'help' => t('The date the node was last updated or commented on. You must use an argument or filter on UID or you will get misleading results using this field.'),
+    'field' => [
+      'id' => 'date',
+    ],
+    'sort' => [
+      'id' => 'date',
+    ],
+    'filter' => [
+      'id' => 'date',
+    ],
+  ];
+
+  return $data;
+}
+
+/**
+ * Implements hook_views_data_alter().
+ */
+function tracker_views_data_alter(&$data) {
+  // Provide additional uid_touch handlers which are handled by tracker
+  $data['node_field_data']['uid_touch_tracker'] = [
+    'group' => t('Tracker - User'),
+    'title' => t('User posted or commented'),
+    'help' => t('Display nodes only if a user posted the node or commented on the node.'),
+    'argument' => [
+      'field' => 'uid',
+      'name table' => 'users_field_data',
+      'name field' => 'name',
+      'id' => 'tracker_user_uid',
+      'no group by' => TRUE,
+    ],
+    'filter' => [
+      'field' => 'uid',
+      'name table' => 'users_field_data',
+      'name field' => 'name',
+      'id' => 'tracker_user_uid',
+    ],
+  ];
+}