bool enabled_by_default = true;
      return enabled_by_default;
    }

    return absl::string_view(log_xla_activity) == "1";
  }
};

bool Register() {
  RegisterXlaActivityListener(std::make_unique<XlaActivityLoggingListener>());
  return false;
}

bool unused = Register();
}  // namespace

  XlaOptimizationRemark remark;
  remark.set_warning(optimization_warning);
  remark.set_debug_information(std::move(debug_information));
  return BroadcastOptimizationRemark(std::move(remark));
}
void RegisterXlaActivityListener(
    std::unique_ptr<XlaActivityListener> listener) {
  XlaActivityListenerList* listener_list = GetXlaActivityListenerList();
  absl::WriterMutexLock writer_lock(&listener_list->mutex);

  virtual void Flush();

  virtual ~XlaActivityListener();
};

// Registers an `XlaActivityListener`, which will be invoked on all subsequent
// `BroadcastXlaActivity` calls.
void RegisterXlaActivityListener(std::unique_ptr<XlaActivityListener> listener);
}  // namespace tensorflow

class DeviceCompilerSerializeTest : public ::testing::Test {
 protected:
  DeviceCompilerSerializeTest() {
    auto listener = std::make_unique<JitCompilationListener>();
    listener_ = listener.get();
    RegisterXlaActivityListener(std::move(listener));
  }

  JitCompilationListener* listener() const { return listener_; }

  // Returns a test graph that will split into two XLA clusters (due to a node
  // with _XlaCompile = false).

};

class XlaActivityListenerTest : public ::testing::Test {
 protected:
  XlaActivityListenerTest() {
    auto listener = std::make_unique<TestListener>();
    listener_ = listener.get();
    RegisterXlaActivityListener(std::move(listener));
  }

  TestListener* listener() const { return listener_; }

 private:
  TestListener* listener_;
};

GraphDef CreateGraphDef() {

  core::ScopedUnref profiler_ref(profiler);

  auto listener = std::make_unique<JitCompilationListener>();
  auto listener_ptr = listener.get();
  RegisterXlaActivityListener(std::move(listener));

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

  std::vector<XlaJitCompilationActivity> expected_activities;
  for (int i = 0; i < 5; ++i) {

    xla_device_compiler_ref_ =
        std::make_unique<core::ScopedUnref>(xla_device_compiler_);

    auto listener = std::make_unique<JitCompilationListener>();
    listener_ = listener.get();
    RegisterXlaActivityListener(std::move(listener));
  }

  XlaCompiler::Options GetDefaultXlaOptions() {
    XlaCompiler::Options options;
    options.device_type = DeviceType(DEVICE_GPU_XLA_JIT);