// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "chromeos/ash/components/dbus/debug_daemon/debug_daemon_client.h"

#include <fcntl.h>
#include <stddef.h>
#include <stdint.h>
#include <unistd.h>

#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "base/files/file_path.h"
#include "base/files/scoped_file.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/json/json_reader.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/memory/raw_ptr.h"
#include "base/observer_list.h"
#include "base/posix/eintr_wrapper.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "base/task/single_thread_task_runner.h"
#include "base/task/thread_pool.h"
#include "base/trace_event/trace_config.h"
#include "chromeos/ash/components/dbus/cryptohome/rpc.pb.h"
#include "chromeos/ash/components/dbus/debug_daemon/fake_debug_daemon_client.h"
#include "chromeos/ash/components/dbus/debug_daemon/metrics.h"
#include "chromeos/dbus/common/dbus_library_error.h"
#include "chromeos/dbus/common/pipe_reader.h"
#include "dbus/bus.h"
#include "dbus/message.h"
#include "dbus/object_path.h"
#include "dbus/object_proxy.h"
#include "third_party/cros_system_api/dbus/debugd/dbus-constants.h"

namespace ash {

namespace {

const char kCrOSTracingAgentName[] = "cros";
const char kCrOSTraceLabel[] = "systemTraceEvents";

// Because the cheets logs are very huge, we set the D-Bus timeout to 2 minutes.
const int kBigLogsDBusTimeoutMS = 120 * 1000;

// crash_sender could take a while to run if the network connection is slow, so
// wait up to 20 seconds for it.
const int kCrashSenderTimeoutMS = 20 * 1000;

// NOTE: This does not use the typical pattern of a single `g_instance` variable
// due to browser_tests that need to temporarily override the existing instance
// with a specialized subclass.
DebugDaemonClient* g_instance = nullptr;
DebugDaemonClient* g_instance_for_test = nullptr;

// A self-deleting object that wraps the pipe reader operations for reading the
// big feedback logs. It will delete itself once the pipe stream has been
// terminated. Once the data has been completely read from the pipe, it invokes
// the GetLogsCallback |callback| passing the deserialized logs data back to
// the requester.
class PipeReaderWrapper final {
 public:
  explicit PipeReaderWrapper(DebugDaemonClient::GetLogsCallback callback)
      : pipe_reader_(base::ThreadPool::CreateTaskRunner(
            {base::MayBlock(),
             base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN})),
        callback_(std::move(callback)) {}

  PipeReaderWrapper(const PipeReaderWrapper&) = delete;
  PipeReaderWrapper& operator=(const PipeReaderWrapper&) = delete;

  base::ScopedFD Initialize() {
    return pipe_reader_.StartIO(base::BindOnce(&PipeReaderWrapper::OnIOComplete,
                                               weak_ptr_factory_.GetWeakPtr()));
  }

  void OnIOComplete(std::optional<std::string> result) {
    if (!result.has_value()) {
      VLOG(1) << "Failed to read data.";
      RecordGetFeedbackLogsV2DbusResult(
          GetFeedbackLogsV2DbusResult::kErrorReadingData);
      RunCallbackAndDestroy(std::nullopt);
      return;
    }

    std::optional<base::Value::Dict> logs = base::JSONReader::ReadDict(*result);
    if (!logs.has_value()) {
      VLOG(1) << "Failed to deserialize the JSON logs.";
      RecordGetFeedbackLogsV2DbusResult(
          GetFeedbackLogsV2DbusResult::kErrorDeserializingJSonLogs);
      RunCallbackAndDestroy(std::nullopt);
      return;
    }
    std::map<std::string, std::string> data;
    for (const auto [dict_key, dict_value] : *logs) {
      data[dict_key] = dict_value.GetString();
    }
    RunCallbackAndDestroy(std::move(data));
  }

  void TerminateStream() {
    VLOG(1) << "Terminated";
    RunCallbackAndDestroy(std::nullopt);
  }

  base::WeakPtr<PipeReaderWrapper> AsWeakPtr() {
    return weak_ptr_factory_.GetWeakPtr();
  }

 private:
  void RunCallbackAndDestroy(
      std::optional<std::map<std::string, std::string>> result) {
    if (result.has_value()) {
      std::move(callback_).Run(true, std::move(result.value()));
    } else {
      std::move(callback_).Run(false, std::map<std::string, std::string>());
    }
    delete this;
  }

  chromeos::PipeReader pipe_reader_;
  DebugDaemonClient::GetLogsCallback callback_;
  base::WeakPtrFactory<PipeReaderWrapper> weak_ptr_factory_{this};
};

// The DebugDaemonClient implementation used in production.
class DebugDaemonClientImpl : public DebugDaemonClient {
 public:
  DebugDaemonClientImpl() : debugdaemon_proxy_(nullptr) {}

  DebugDaemonClientImpl(const DebugDaemonClientImpl&) = delete;
  DebugDaemonClientImpl& operator=(const DebugDaemonClientImpl&) = delete;

  ~DebugDaemonClientImpl() override = default;

  // DebugDaemonClient override.
  void DumpDebugLogs(bool is_compressed,
                     int file_descriptor,
                     chromeos::VoidDBusMethodCallback callback) override {
    // Issue the dbus request to get debug logs.
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kDumpDebugLogs);
    dbus::MessageWriter writer(&method_call);
    writer.AppendBool(is_compressed);
    writer.AppendFileDescriptor(file_descriptor);
    debugdaemon_proxy_->CallMethod(
        &method_call, kBigLogsDBusTimeoutMS,
        base::BindOnce(&DebugDaemonClientImpl::OnVoidMethod,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void SetDebugMode(const std::string& subsystem,
                    chromeos::VoidDBusMethodCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kSetDebugMode);
    dbus::MessageWriter writer(&method_call);
    writer.AppendString(subsystem);
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnVoidMethod,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void GetRoutes(bool numeric,
                 bool ipv6,
                 bool all_tables,
                 chromeos::DBusMethodCallback<std::vector<std::string>>
                     callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface, debugd::kGetRoutes);
    dbus::MessageWriter writer(&method_call);
    dbus::MessageWriter sub_writer(NULL);
    writer.OpenArray("{sv}", &sub_writer);
    dbus::MessageWriter elem_writer(NULL);
    sub_writer.OpenDictEntry(&elem_writer);
    elem_writer.AppendString("numeric");
    elem_writer.AppendVariantOfBool(numeric);
    sub_writer.CloseContainer(&elem_writer);
    sub_writer.OpenDictEntry(&elem_writer);
    elem_writer.AppendString("v6");
    elem_writer.AppendVariantOfBool(ipv6);
    sub_writer.CloseContainer(&elem_writer);
    sub_writer.OpenDictEntry(&elem_writer);
    elem_writer.AppendString("all");
    elem_writer.AppendVariantOfBool(all_tables);
    sub_writer.CloseContainer(&elem_writer);
    writer.CloseContainer(&sub_writer);
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnGetRoutes,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void GetNetworkStatus(
      chromeos::DBusMethodCallback<std::string> callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kGetNetworkStatus);
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnStringMethod,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void GetNetworkInterfaces(
      chromeos::DBusMethodCallback<std::string> callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kGetInterfaces);
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnStringMethod,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void GetPerfOutput(const std::vector<std::string>& quipper_args,
                     bool disable_cpu_idle,
                     int file_descriptor,
                     chromeos::DBusMethodCallback<uint64_t> callback) override {
    DCHECK(file_descriptor);
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kGetPerfOutputV2);
    dbus::MessageWriter writer(&method_call);
    writer.AppendArrayOfStrings(quipper_args);
    writer.AppendBool(disable_cpu_idle);
    writer.AppendFileDescriptor(file_descriptor);

    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnUint64Method,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void StopPerf(uint64_t session_id,
                chromeos::VoidDBusMethodCallback callback) override {
    DCHECK(session_id);
    dbus::MethodCall method_call(debugd::kDebugdInterface, debugd::kStopPerf);
    dbus::MessageWriter writer(&method_call);
    writer.AppendUint64(session_id);

    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnVoidMethod,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void GetFeedbackLogs(
      const cryptohome::AccountIdentifier& id,
      const std::vector<debugd::FeedbackLogType>& requested_logs,
      GetLogsCallback callback) override {
    // The PipeReaderWrapper is a self-deleting object; we don't have to worry
    // about ownership or lifetime. We need to create a new one for each Big
    // Logs requests in order to queue these requests. One request can take a
    // long time to be processed and a new request should never be ignored nor
    // cancels the on-going one.
    PipeReaderWrapper* pipe_reader = new PipeReaderWrapper(std::move(callback));
    base::ScopedFD pipe_write_end = pipe_reader->Initialize();

    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kGetFeedbackLogsV3);
    dbus::MessageWriter writer(&method_call);
    writer.AppendFileDescriptor(pipe_write_end.get());
    writer.AppendString(id.account_id());
    // Write |requested_logs|.
    dbus::MessageWriter sub_writer(nullptr);
    writer.OpenArray("i", &sub_writer);
    for (auto log_type : requested_logs) {
      sub_writer.AppendInt32(log_type);
    }
    writer.CloseContainer(&sub_writer);

    DVLOG(1) << "Requesting feedback logs";
    debugdaemon_proxy_->CallMethodWithErrorResponse(
        &method_call, kBigLogsDBusTimeoutMS,
        base::BindOnce(&DebugDaemonClientImpl::OnFeedbackLogsResponse,
                       weak_ptr_factory_.GetWeakPtr(),
                       pipe_reader->AsWeakPtr()));
  }

  void GetFeedbackBinaryLogs(
      const cryptohome::AccountIdentifier& id,
      const std::map<debugd::FeedbackBinaryLogType, base::ScopedFD>&
          log_type_fds,
      chromeos::VoidDBusMethodCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kGetFeedbackBinaryLogs);
    dbus::MessageWriter writer(&method_call);
    writer.AppendString(id.account_id());

    dbus::MessageWriter array_writer(nullptr);
    // Write map of log_type and fd.
    writer.OpenArray("{ih}", &array_writer);
    for (const auto& log_type : log_type_fds) {
      dbus::MessageWriter dict_entry_writer(nullptr);
      array_writer.OpenDictEntry(&dict_entry_writer);
      dict_entry_writer.AppendInt32(log_type.first);
      dict_entry_writer.AppendFileDescriptor(log_type.second.get());
      array_writer.CloseContainer(&dict_entry_writer);
    }
    writer.CloseContainer(&array_writer);

    DVLOG(1) << "Requesting feedback binary logs";
    debugdaemon_proxy_->CallMethodWithErrorResponse(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnFeedbackBinaryLogsResponse,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void BackupArcBugReport(const cryptohome::AccountIdentifier& id,
                          chromeos::VoidDBusMethodCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kBackupArcBugReport);
    dbus::MessageWriter writer(&method_call);
    writer.AppendString(id.account_id());

    DVLOG(1) << "Backing up ARC bug report";
    debugdaemon_proxy_->CallMethod(
        &method_call, kBigLogsDBusTimeoutMS,
        base::BindOnce(&DebugDaemonClientImpl::OnVoidMethod,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void GetAllLogs(GetLogsCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface, debugd::kGetAllLogs);
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnGetAllLogs,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void GetLog(const std::string& log_name,
              chromeos::DBusMethodCallback<std::string> callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface, debugd::kGetLog);
    dbus::MessageWriter(&method_call).AppendString(log_name);
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnStringMethod,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  // base::trace_event::TracingAgent implementation.
  std::string GetTracingAgentName() override { return kCrOSTracingAgentName; }

  std::string GetTraceEventLabel() override { return kCrOSTraceLabel; }

  void StartAgentTracing(const base::trace_event::TraceConfig& trace_config,
                         StartAgentTracingCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kSystraceStart);
    dbus::MessageWriter writer(&method_call);
    if (trace_config.systrace_events().empty()) {
      writer.AppendString("all");  // TODO(sleffler) parameterize category list
    } else {
      std::string events;
      for (const std::string& event : trace_config.systrace_events()) {
        if (!events.empty())
          events += " ";
        events += event;
      }
      writer.AppendString(events);
    }

    DVLOG(1) << "Requesting a systrace start";
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnStartMethod,
                       weak_ptr_factory_.GetWeakPtr()));

    base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
        FROM_HERE, base::BindOnce(std::move(callback), GetTracingAgentName(),
                                  true /* success */));
  }

  void StopAgentTracing(StopAgentTracingCallback callback) override {
    DCHECK(stop_agent_tracing_task_runner_);
    if (pipe_reader_ != NULL) {
      LOG(ERROR) << "Busy doing StopSystemTracing";
      return;
    }

    pipe_reader_ =
        std::make_unique<chromeos::PipeReader>(stop_agent_tracing_task_runner_);
    callback_ = std::move(callback);
    base::ScopedFD pipe_write_end = pipe_reader_->StartIO(base::BindOnce(
        &DebugDaemonClientImpl::OnIOComplete, weak_ptr_factory_.GetWeakPtr()));

    DCHECK(pipe_write_end.is_valid());
    // Issue the dbus request to stop system tracing
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kSystraceStop);
    dbus::MessageWriter writer(&method_call);
    writer.AppendFileDescriptor(pipe_write_end.get());

    DVLOG(1) << "Requesting a systrace stop";
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnStopAgentTracing,
                       weak_ptr_factory_.GetWeakPtr()));
  }

  void SetStopAgentTracingTaskRunner(
      scoped_refptr<base::TaskRunner> task_runner) override {
    stop_agent_tracing_task_runner_ = task_runner;
  }

  void TestICMP(const std::string& ip_address,
                TestICMPCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface, debugd::kTestICMP);
    dbus::MessageWriter writer(&method_call);
    writer.AppendString(ip_address);
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnTestICMP,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void TestICMPWithOptions(const std::string& ip_address,
                           const std::map<std::string, std::string>& options,
                           TestICMPCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kTestICMPWithOptions);
    dbus::MessageWriter writer(&method_call);
    dbus::MessageWriter sub_writer(NULL);
    dbus::MessageWriter elem_writer(NULL);

    // Write the host.
    writer.AppendString(ip_address);

    // Write the options.
    writer.OpenArray("{ss}", &sub_writer);
    std::map<std::string, std::string>::const_iterator it;
    for (it = options.begin(); it != options.end(); ++it) {
      sub_writer.OpenDictEntry(&elem_writer);
      elem_writer.AppendString(it->first);
      elem_writer.AppendString(it->second);
      sub_writer.CloseContainer(&elem_writer);
    }
    writer.CloseContainer(&sub_writer);

    // Call the function.
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnTestICMP,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void UploadCrashes(UploadCrashesCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kUploadCrashes);
    debugdaemon_proxy_->CallMethod(
        &method_call, kCrashSenderTimeoutMS,
        base::BindOnce(&DebugDaemonClientImpl::OnUploadCrashes,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void OnUploadCrashes(UploadCrashesCallback callback,
                       dbus::Response* response) {
    if (callback.is_null()) {
      return;
    }

    std::move(callback).Run(response != nullptr);
  }

  void EnableDebuggingFeatures(const std::string& password,
                               EnableDebuggingCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kEnableChromeDevFeatures);
    dbus::MessageWriter writer(&method_call);
    writer.AppendString(password);
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnEnableDebuggingFeatures,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void QueryDebuggingFeatures(QueryDevFeaturesCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kQueryDevFeatures);
    dbus::MessageWriter writer(&method_call);
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnQueryDebuggingFeatures,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void RemoveRootfsVerification(EnableDebuggingCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kRemoveRootfsVerification);
    dbus::MessageWriter writer(&method_call);
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnRemoveRootfsVerification,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void WaitForServiceToBeAvailable(
      chromeos::WaitForServiceToBeAvailableCallback callback) override {
    debugdaemon_proxy_->WaitForServiceToBeAvailable(std::move(callback));
  }

  void SetOomScoreAdj(const std::map<pid_t, int32_t>& pid_to_oom_score_adj,
                      SetOomScoreAdjCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kSetOomScoreAdj);
    dbus::MessageWriter writer(&method_call);

    dbus::MessageWriter sub_writer(nullptr);
    writer.OpenArray("{ii}", &sub_writer);

    dbus::MessageWriter elem_writer(nullptr);
    for (const auto& entry : pid_to_oom_score_adj) {
      sub_writer.OpenDictEntry(&elem_writer);
      elem_writer.AppendInt32(entry.first);
      elem_writer.AppendInt32(entry.second);
      sub_writer.CloseContainer(&elem_writer);
    }
    writer.CloseContainer(&sub_writer);

    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnSetOomScoreAdj,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void CupsAddManuallyConfiguredPrinter(
      const std::string& name,
      const std::string& uri,
      const std::string& language,
      const std::string& ppd_contents,
      DebugDaemonClient::CupsAddPrinterCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kCupsAddManuallyConfiguredPrinterV2);
    dbus::MessageWriter writer(&method_call);
    writer.AppendString(name);
    writer.AppendString(uri);
    writer.AppendString(language);
    writer.AppendArrayOfBytes(base::as_byte_span(ppd_contents));

    debugdaemon_proxy_->CallMethodWithErrorResponse(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnPrinterAdded,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void CupsAddAutoConfiguredPrinter(
      const std::string& name,
      const std::string& uri,
      const std::string& language,
      DebugDaemonClient::CupsAddPrinterCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kCupsAddAutoConfiguredPrinterV2);
    dbus::MessageWriter writer(&method_call);
    writer.AppendString(name);
    writer.AppendString(uri);
    writer.AppendString(language);

    debugdaemon_proxy_->CallMethodWithErrorResponse(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnPrinterAdded,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void CupsRemovePrinter(const std::string& name,
                         DebugDaemonClient::CupsRemovePrinterCallback callback,
                         base::OnceClosure error_callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kCupsRemovePrinter);
    dbus::MessageWriter writer(&method_call);
    writer.AppendString(name);

    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnPrinterRemoved,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback),
                       std::move(error_callback)));
  }

  void CupsRetrievePrinterPpd(
      const std::string& name,
      DebugDaemonClient::CupsRetrievePrinterPpdCallback callback,
      base::OnceClosure error_callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kCupsRetrievePpd);
    dbus::MessageWriter writer(&method_call);
    writer.AppendString(name);

    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnRetrievedPrinterPpd,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback),
                       std::move(error_callback)));
  }

  void StartPluginVmDispatcher(const std::string& owner_id,
                               const std::string& lang,
                               PluginVmDispatcherCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kStartVmPluginDispatcher);
    dbus::MessageWriter writer(&method_call);
    writer.AppendString(owner_id);
    writer.AppendString(lang);
    debugdaemon_proxy_->CallMethodWithErrorResponse(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnStartPluginVmDispatcher,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void StopPluginVmDispatcher(PluginVmDispatcherCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kStopVmPluginDispatcher);
    dbus::MessageWriter writer(&method_call);
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnStopPluginVmDispatcher,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void SetRlzPingSent(SetRlzPingSentCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kSetRlzPingSent);
    dbus::MessageWriter writer(&method_call);
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnSetRlzPingSent,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void SetKstaledRatio(uint8_t val, KstaledRatioCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kKstaledSetRatio);
    dbus::MessageWriter writer(&method_call);
    writer.AppendByte(val);
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnSetKstaledRatio,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void SetSchedulerConfigurationV2(
      const std::string& config_name,
      bool lock_policy,
      SetSchedulerConfigurationV2Callback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kSetSchedulerConfigurationV2);
    dbus::MessageWriter writer(&method_call);
    writer.AppendString(config_name);
    writer.AppendBool(lock_policy);
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnSetSchedulerConfigurationV2,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void SetU2fFlags(const std::set<std::string>& flags,
                   chromeos::VoidDBusMethodCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kSetU2fFlags);
    dbus::MessageWriter writer(&method_call);
    writer.AppendString(base::JoinString(
        std::vector<std::string>(flags.begin(), flags.end()), ","));
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnVoidMethod,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void GetU2fFlags(
      chromeos::DBusMethodCallback<std::set<std::string>> callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kGetU2fFlags);
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnGetU2fFlags,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void BluetoothStartBtsnoop(BluetoothBtsnoopCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kBluetoothStartBtsnoop);
    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnBluetoothStartBtsnoop,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void BluetoothStopBtsnoop(int fd,
                            BluetoothBtsnoopCallback callback) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kBluetoothStopBtsnoop);
    dbus::MessageWriter writer(&method_call);
    writer.AppendFileDescriptor(fd);

    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnBluetoothStopBtsnoop,
                       weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
  }

  void StopPacketCapture(const std::string& handle) override {
    dbus::MethodCall method_call(debugd::kDebugdInterface,
                                 debugd::kPacketCaptureStop);
    dbus::MessageWriter writer(&method_call);
    writer.AppendString(handle);

    debugdaemon_proxy_->CallMethod(
        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
        base::BindOnce(&DebugDaemonClientImpl::OnStopMethod,
                       weak_ptr_factory_.GetWeakPtr()));
  }

  // DebugDaemonClient Observer overrides.
  void AddObserver(Observer* observer) override {
    DCHECK(observer);
    observers_.AddObserver(observer);
  }

  void RemoveObserver(Observer* observer) override {
    DCHECK(observer);
    observers_.RemoveObserver(observer);
  }

  void Init(dbus::Bus* bus) override {
    debugdaemon_proxy_ =
        bus->GetObjectProxy(debugd::kDebugdServiceName,
                            dbus::ObjectPath(debugd::kDebugdServicePath));
    // Listen to D-Bus signals emitted by debugd.
    auto on_connected_callback =
        base::BindRepeating(&DebugDaemonClientImpl::SignalConnected,
                            weak_ptr_factory_.GetWeakPtr());
    debugdaemon_proxy_->ConnectToSignal(
        debugd::kDebugdInterface, debugd::kPacketCaptureStartSignal,
        base::BindRepeating(
            &DebugDaemonClientImpl::PacketCaptureStartSignalReceived,
            weak_ptr_factory_.GetWeakPtr()),
        on_connected_callback);
    debugdaemon_proxy_->ConnectToSignal(
        debugd::kDebugdInterface, debugd::kPacketCaptureStopSignal,
        base::BindRepeating(
            &DebugDaemonClientImpl::PacketCaptureStopSignalReceived,
            weak_ptr_factory_.GetWeakPtr()),
        on_connected_callback);
  }

 private:
  void OnGetRoutes(
      chromeos::DBusMethodCallback<std::vector<std::string>> callback,
      dbus::Response* response) {
    if (!response) {
      std::move(callback).Run(std::nullopt);
      return;
    }

    std::vector<std::string> routes;
    dbus::MessageReader reader(response);
    if (!reader.PopArrayOfStrings(&routes)) {
      LOG(ERROR) << "Got non-array response from GetRoutes";
      std::move(callback).Run(std::nullopt);
      return;
    }

    std::move(callback).Run(std::move(routes));
  }

  void OnGetAllLogs(GetLogsCallback callback, dbus::Response* response) {
    std::map<std::string, std::string> logs;
    bool broken = false;  // did we see a broken (k,v) pair?
    dbus::MessageReader sub_reader(NULL);
    if (!response || !dbus::MessageReader(response).PopArray(&sub_reader)) {
      std::move(callback).Run(false, logs);
      return;
    }
    while (sub_reader.HasMoreData()) {
      dbus::MessageReader sub_sub_reader(NULL);
      std::string key, value;
      if (!sub_reader.PopDictEntry(&sub_sub_reader) ||
          !sub_sub_reader.PopString(&key) ||
          !sub_sub_reader.PopString(&value)) {
        broken = true;
        break;
      }
      logs[key] = value;
    }
    std::move(callback).Run(!sub_reader.HasMoreData() && !broken, logs);
  }

  void OnFeedbackLogsResponse(base::WeakPtr<PipeReaderWrapper> pipe_reader,
                              dbus::Response* response,
                              dbus::ErrorResponse* err_response) {
    RecordGetFeedbackLogsV2DbusError(err_response);
    if (!response && pipe_reader.get()) {
      // We need to terminate the data stream if an error occurred while the
      // pipe reader is still waiting on read.
      pipe_reader->TerminateStream();
    }
  }

  void OnFeedbackBinaryLogsResponse(chromeos::VoidDBusMethodCallback callback,
                                    dbus::Response* response,
                                    dbus::ErrorResponse* err_response) {
    bool succeeded = !err_response;
    if (!succeeded) {
      LOG(ERROR) << "Failed to GetFeedbackBinaryLogs. Error: "
                 << err_response->GetErrorName();
    }
    std::move(callback).Run(succeeded);
  }

  // Called when a response for a simple start is received.
  void OnStartMethod(dbus::Response* response) {
    if (!response) {
      LOG(ERROR) << "Failed to request start";
      return;
    }
  }

  // Called when a response for a simple stop is received.
  void OnStopMethod(dbus::Response* response) {
    if (!response) {
      LOG(ERROR) << "Failed to request stop method through D-Bus";
      return;
    }
  }

  // Called when D-Bus method call which does not return the result is
  // completed or on its error.
  void OnVoidMethod(chromeos::VoidDBusMethodCallback callback,
                    dbus::Response* response) {
    std::move(callback).Run(response);
  }

  void OnUint64Method(chromeos::DBusMethodCallback<uint64_t> callback,
                      dbus::Response* response) {
    if (!response) {
      std::move(callback).Run(std::nullopt);
      return;
    }

    dbus::MessageReader reader(response);
    uint64_t result;
    if (!reader.PopUint64(&result)) {
      std::move(callback).Run(std::nullopt);
      return;
    }

    std::move(callback).Run(std::move(result));
  }

  // Called when D-Bus method call which returns a string is completed or on
  // its error.
  void OnStringMethod(chromeos::DBusMethodCallback<std::string> callback,
                      dbus::Response* response) {
    if (!response) {
      std::move(callback).Run(std::nullopt);
      return;
    }

    dbus::MessageReader reader(response);
    std::string result;
    if (!reader.PopString(&result)) {
      std::move(callback).Run(std::nullopt);
      return;
    }

    std::move(callback).Run(std::move(result));
  }

  void OnEnableDebuggingFeatures(EnableDebuggingCallback callback,
                                 dbus::Response* response) {
    if (callback.is_null())
      return;

    std::move(callback).Run(response != nullptr);
  }

  void OnQueryDebuggingFeatures(QueryDevFeaturesCallback callback,
                                dbus::Response* response) {
    if (callback.is_null())
      return;

    int32_t feature_mask = DEV_FEATURE_NONE;
    if (!response || !dbus::MessageReader(response).PopInt32(&feature_mask)) {
      std::move(callback).Run(false,
                              debugd::DevFeatureFlag::DEV_FEATURES_DISABLED);
      return;
    }

    std::move(callback).Run(true, feature_mask);
  }

  void OnRemoveRootfsVerification(EnableDebuggingCallback callback,
                                  dbus::Response* response) {
    if (callback.is_null())
      return;

    std::move(callback).Run(response != nullptr);
  }

  // Called when a response for StopAgentTracing() is received.
  void OnStopAgentTracing(dbus::Response* response) {
    if (!response) {
      LOG(ERROR) << "Failed to request systrace stop";
      // If debugd crashes or completes I/O before this message is processed
      // then pipe_reader_ can be NULL, see OnIOComplete().
      if (pipe_reader_.get()) {
        pipe_reader_.reset();
        std::move(callback_).Run(GetTracingAgentName(), GetTraceEventLabel(),
                                 scoped_refptr<base::RefCountedString>(
                                     new base::RefCountedString()));
      }
    }
    // NB: requester is signaled when i/o completes
  }

  void OnTestICMP(TestICMPCallback callback, dbus::Response* response) {
    std::string status;
    if (!response || !dbus::MessageReader(response).PopString(&status)) {
      std::move(callback).Run(std::nullopt);
      return;
    }

    std::move(callback).Run(status);
  }

  // Called when pipe i/o completes; pass data on and delete the instance.
  void OnIOComplete(std::optional<std::string> result) {
    pipe_reader_.reset();
    std::string pipe_data =
        result.has_value() ? std::move(result).value() : std::string();
    std::move(callback_).Run(
        GetTracingAgentName(), GetTraceEventLabel(),
        base::MakeRefCounted<base::RefCountedString>(std::move(pipe_data)));
  }

  void OnSetOomScoreAdj(SetOomScoreAdjCallback callback,
                        dbus::Response* response) {
    std::string output;
    if (response && dbus::MessageReader(response).PopString(&output))
      std::move(callback).Run(true, output);
    else
      std::move(callback).Run(false, "");
  }

  void OnPrinterAdded(CupsAddPrinterCallback callback,
                      dbus::Response* response,
                      dbus::ErrorResponse* err_response) {
    int32_t result;

    // If we get a normal response, we need not examine the error response.
    if (response && dbus::MessageReader(response).PopInt32(&result)) {
      DCHECK_GE(result, 0);
      std::move(callback).Run(result);
      return;
    }

    // Without a normal response, we communicate the D-Bus error response
    // to the callback.
    std::string err_str;
    if (err_response) {
      dbus::MessageReader err_reader(err_response);
      err_str = err_response->GetErrorName();
    }
    chromeos::DBusLibraryError dbus_error =
        chromeos::DBusLibraryErrorFromString(err_str);
    std::move(callback).Run(dbus_error);
  }

  void OnPrinterRemoved(CupsRemovePrinterCallback callback,
                        base::OnceClosure error_callback,
                        dbus::Response* response) {
    bool result = false;
    if (response && dbus::MessageReader(response).PopBool(&result))
      std::move(callback).Run(result);
    else
      std::move(error_callback).Run();
  }

  void OnRetrievedPrinterPpd(CupsRetrievePrinterPpdCallback callback,
                             base::OnceClosure error_callback,
                             dbus::Response* response) {
    size_t length = 0;
    const uint8_t* bytes = nullptr;

    if (!(response &&
          dbus::MessageReader(response).PopArrayOfBytes(&bytes, &length)) ||
        length == 0 || bytes == nullptr) {
      LOG(ERROR) << "Failed to retrieve printer PPD";
      std::move(error_callback).Run();
      return;
    }

    std::vector<uint8_t> data(bytes, bytes + length);
    std::move(callback).Run(data);
  }

  void OnStartPluginVmDispatcher(PluginVmDispatcherCallback callback,
                                 dbus::Response* response,
                                 dbus::ErrorResponse* error) {
    if (error) {
      LOG(ERROR) << "Failed to start dispatcher, DBus error "
                 << error->GetErrorName();
      std::move(callback).Run(false);
      return;
    }

    bool result = false;
    if (response) {
      dbus::MessageReader reader(response);
      reader.PopBool(&result);
    }
    std::move(callback).Run(result);
  }

  void OnStopPluginVmDispatcher(PluginVmDispatcherCallback callback,
                                dbus::Response* response) {
    // Debugd just sends back an empty response, so we just check if
    // the response exists
    std::move(callback).Run(response != nullptr);
  }

  void OnSetRlzPingSent(SetRlzPingSentCallback callback,
                        dbus::Response* response) {
    bool result = false;
    if (response) {
      dbus::MessageReader reader(response);
      reader.PopBool(&result);
    }
    std::move(callback).Run(result);
  }

  void OnSetKstaledRatio(KstaledRatioCallback callback,
                         dbus::Response* response) {
    if (!response) {
      LOG(ERROR) << "Failed to read debugd response";
      std::move(callback).Run(false);
      return;
    }

    bool result = false;
    dbus::MessageReader reader(response);
    if (!reader.PopBool(&result)) {
      LOG(ERROR) << "Debugd response did not contain a bool";
      std::move(callback).Run(false);
      return;
    }

    std::move(callback).Run(result);
  }

  void OnSetSchedulerConfigurationV2(
      SetSchedulerConfigurationV2Callback callback,
      dbus::Response* response) {
    if (!response) {
      std::move(callback).Run(false, 0);
      return;
    }

    bool result = false;
    uint32_t num_cores_disabled = 0;
    dbus::MessageReader reader(response);
    if (!reader.PopBool(&result) || !reader.PopUint32(&num_cores_disabled)) {
      LOG(ERROR) << "Failed to read SetSchedulerConfigurationV2 response";
      std::move(callback).Run(false, 0);
      return;
    }

    std::move(callback).Run(result, num_cores_disabled);
  }

  void OnGetU2fFlags(
      chromeos::DBusMethodCallback<std::set<std::string>> callback,
      dbus::Response* response) {
    if (!response) {
      std::move(callback).Run(std::nullopt);
      return;
    }

    std::string flags_string;
    dbus::MessageReader reader(response);
    if (!reader.PopString(&flags_string)) {
      LOG(ERROR) << "Failed to read GetU2fFlags response";
      std::move(callback).Run(std::nullopt);
      return;
    }

    std::set<std::string> flags;
    for (const auto& flag :
         base::SplitString(flags_string, ",", base::TRIM_WHITESPACE,
                           base::SPLIT_WANT_NONEMPTY)) {
      flags.insert(flag);
    }

    std::move(callback).Run(std::move(flags));
  }

  void OnBluetoothStartBtsnoop(BluetoothBtsnoopCallback callback,
                               dbus::Response* response) {
    if (!response) {
      LOG(ERROR) << "Failed to read debugd response";
    }
    std::move(callback).Run(response != nullptr);
  }

  void OnBluetoothStopBtsnoop(BluetoothBtsnoopCallback callback,
                              dbus::Response* response) {
    if (!response) {
      LOG(ERROR) << "Failed to read debugd response";
    }
    std::move(callback).Run(response != nullptr);
  }

  // Called when a D-Bus signal is initially connected.
  void SignalConnected(const std::string& interface_name,
                       const std::string& signal_name,
                       bool success) {
    if (!success)
      LOG(ERROR) << "Failed to connect to signal " << signal_name << ".";
  }

  void PacketCaptureStartSignalReceived(dbus::Signal* signal) override {
    for (auto& observer : observers_)
      observer.OnPacketCaptureStarted();
  }

  void PacketCaptureStopSignalReceived(dbus::Signal* signal) override {
    for (auto& observer : observers_)
      observer.OnPacketCaptureStopped();
  }

  raw_ptr<dbus::ObjectProxy> debugdaemon_proxy_;
  std::unique_ptr<chromeos::PipeReader> pipe_reader_;
  StopAgentTracingCallback callback_;
  scoped_refptr<base::TaskRunner> stop_agent_tracing_task_runner_;
  base::ObserverList<Observer> observers_;
  base::WeakPtrFactory<DebugDaemonClientImpl> weak_ptr_factory_{this};
};

}  // namespace

// static
DebugDaemonClient* DebugDaemonClient::Get() {
  if (g_instance_for_test)
    return g_instance_for_test;
  return g_instance;
}

// static
void DebugDaemonClient::Initialize(dbus::Bus* bus) {
  CHECK(bus);
  CHECK(!g_instance);
  g_instance = new DebugDaemonClientImpl();
  g_instance->Init(bus);
}

// static
void DebugDaemonClient::InitializeFake() {
  CHECK(!g_instance);
  g_instance = new FakeDebugDaemonClient();
  g_instance->Init(nullptr);
}

// static
void DebugDaemonClient::SetInstanceForTest(DebugDaemonClient* client) {
  g_instance_for_test = client;
}

// static
void DebugDaemonClient::Shutdown() {
  CHECK(g_instance);
  delete g_instance;
  g_instance = nullptr;
}

DebugDaemonClient::DebugDaemonClient() = default;

DebugDaemonClient::~DebugDaemonClient() = default;

// static
std::unique_ptr<DebugDaemonClient> DebugDaemonClient::CreateInstance() {
  return std::make_unique<DebugDaemonClientImpl>();
}

}  // namespace ash