return absl::OkStatus();
    }

    return absl::OkStatus();
  }

  Status Listen(
      const XlaJitCompilationActivity& jit_compilation_activity) override {
    if (!IsEnabled()) {
      VLOG(3) << "Logging XlaJitCompilationActivity disabled";
      return absl::OkStatus();
    }

    return absl::OkStatus();
  }

      }
    }
    return absl::OkStatus();
  }

  std::vector<XlaJitCompilationActivity> GetListenerHistory() {
    return activity_history_;
  }

  void ClearListenerHistory() { activity_history_.clear(); }

 private:
  std::vector<XlaJitCompilationActivity> activity_history_;
};

// Fixture for testing XLA compilation cache serialization.

// Each instance of XlaJitCompilationActivity corresponds to a single
// compilation of a single XLA cluster.  E.g. if a graph has two clusters, A and
// B, and A is compiled 5 times and B is compiled 2 times then we will generate
// 7 instances of XlaJitCompilationActivity.
//
// Next ID: 6
message XlaJitCompilationActivity {
  string cluster_name = 1;

  const XlaAutoClusteringActivity& auto_clustering_activity() const {
    return auto_clustering_activity_;
  }
  const XlaJitCompilationActivity& jit_compilation_activity() const {
    return jit_compilation_activity_;
  }

 private:
  XlaAutoClusteringActivity auto_clustering_activity_;
  XlaJitCompilationActivity jit_compilation_activity_;
};

class XlaActivityListenerTest : public ::testing::Test {
 protected:

Status BroadcastXlaActivity(XlaAutoClusteringActivity auto_clustering_activity);

// Broadcast `jit_compilation_activity` to all the registered listeners.
Status BroadcastXlaActivity(XlaJitCompilationActivity jit_compilation_activity);

// Broadcast `jit_compilation_activity` to all the registered listeners.
Status BroadcastOptimizationRemark(XlaOptimizationRemark optimization_remark);

// LINT.IfChange

  return ForEachListener([&](XlaActivityListener* listener) {
    return listener->Listen(auto_clustering_activity);
  });
}

Status BroadcastXlaActivity(
    XlaJitCompilationActivity jit_compilation_activity) {
  return ForEachListener([&](XlaActivityListener* listener) {
    return listener->Listen(jit_compilation_activity);
  });
}

  NameAttrList function;
  function.set_name("TestFunc");

  std::vector<XlaJitCompilationActivity> expected_activities;
  for (int i = 0; i < 5; ++i) {
    EXPECT_TRUE(profiler->RegisterCompilation(function, 4, false).ok());

    TF_ASSERT_OK_AND_ASSIGN(auto stats, profiler->GetCompileStats(function));
    XlaJitCompilationActivity expected_activity;
    expected_activity.set_cluster_name(function.name());

  void RegisterExecution(const NameAttrList& function);

  // Registers a cluster compilation. Increments the compilation count and
  // accumulates the compile time for the given cluster. Also broadcasts an
  // XlaJitCompilationActivity.
  virtual Status RegisterCompilation(const NameAttrList& function,
                                     int64_t compile_time_us,
                                     bool used_persistent_cache);

          << " / "
          << tensorflow::strings::HumanReadableElapsedTime(
                 it->second.cumulative_compile_time_us / 1.0e6)
          << ")";

  XlaJitCompilationActivity jit_compilation_activity;
  jit_compilation_activity.set_cluster_name(function_name);
  jit_compilation_activity.set_compile_count(it->second.compile_count);

  EXPECT_TRUE(compilation_result != nullptr);
  EXPECT_TRUE(xla_executable != nullptr);

  // Check if device_compiler was able to load the executable from the
  // persistent cache.
  std::vector<XlaJitCompilationActivity> activity_history =
      listener_->GetListenerHistory();
  EXPECT_EQ(activity_history.size(), 1);
  EXPECT_EQ(activity_history[0].cluster_name(), fn.name());
  EXPECT_EQ(activity_history[0].compile_count(), 1);