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

#ifndef CHROME_CREDENTIAL_PROVIDER_TEST_GCP_FAKES_H_
#define CHROME_CREDENTIAL_PROVIDER_TEST_GCP_FAKES_H_

#include <deque>
#include <list>
#include <map>
#include <memory>
#include <string>
#include <thread>
#include <unordered_map>
#include <vector>

#include "base/memory/raw_ptr.h"
#include "base/memory/raw_ref.h"
#include "base/synchronization/waitable_event.h"
#include "base/task/single_thread_task_runner.h"
#include "base/test/test_reg_util_win.h"
#include "base/win/scoped_handle.h"
#include "chrome/credential_provider/extension/extension_utils.h"
#include "chrome/credential_provider/extension/os_service_manager.h"
#include "chrome/credential_provider/extension/task_manager.h"
#include "chrome/credential_provider/gaiacp/associated_user_validator.h"
#include "chrome/credential_provider/gaiacp/chrome_availability_checker.h"
#include "chrome/credential_provider/gaiacp/device_policies_manager.h"
#include "chrome/credential_provider/gaiacp/event_logging_api_manager.h"
#include "chrome/credential_provider/gaiacp/event_logs_upload_manager.h"
#include "chrome/credential_provider/gaiacp/gem_device_details_manager.h"
#include "chrome/credential_provider/gaiacp/internet_availability_checker.h"
#include "chrome/credential_provider/gaiacp/os_process_manager.h"
#include "chrome/credential_provider/gaiacp/os_user_manager.h"
#include "chrome/credential_provider/gaiacp/password_recovery_manager.h"
#include "chrome/credential_provider/gaiacp/scoped_lsa_policy.h"
#include "chrome/credential_provider/gaiacp/scoped_user_profile.h"
#include "chrome/credential_provider/gaiacp/token_generator.h"
#include "chrome/credential_provider/gaiacp/user_policies_manager.h"
#include "chrome/credential_provider/gaiacp/win_http_url_fetcher.h"
#include "chrome/credential_provider/setup/gcpw_files.h"

class GaiaId;

namespace base {
class WaitableEvent;
}

namespace credential_provider {

enum class FAILEDOPERATIONS {
  ADD_USER,
  CHANGE_PASSWORD,
  GET_USER_FULLNAME,
  SET_USER_FULLNAME
};

void InitializeRegistryOverrideForTesting(
    registry_util::RegistryOverrideManager* registry_override);

///////////////////////////////////////////////////////////////////////////////

class FakeOSProcessManager : public OSProcessManager {
 public:
  FakeOSProcessManager();
  ~FakeOSProcessManager() override;

  // OSProcessManager
  HRESULT GetTokenLogonSID(const base::win::ScopedHandle& token,
                           PSID* sid) override;
  HRESULT SetupPermissionsForLogonSid(PSID sid) override;
  HRESULT CreateProcessWithToken(
      const base::win::ScopedHandle& logon_token,
      const base::CommandLine& command_line,
      _STARTUPINFOW* startupinfo,
      base::win::ScopedProcessInformation* procinfo) override;

 private:
  raw_ptr<OSProcessManager> original_manager_;
  DWORD next_rid_ = 0;
};

///////////////////////////////////////////////////////////////////////////////

class FakeOSUserManager : public OSUserManager {
 public:
  FakeOSUserManager();
  ~FakeOSUserManager() override;

  // OSUserManager
  HRESULT GenerateRandomPassword(wchar_t* password, int length) override;
  HRESULT AddUser(const wchar_t* username,
                  const wchar_t* password,
                  const wchar_t* fullname,
                  const wchar_t* comment,
                  bool add_to_users_group,
                  BSTR* sid,
                  DWORD* error) override;
  // Add a user to the OS with domain associated with it.
  HRESULT AddUser(const wchar_t* username,
                  const wchar_t* password,
                  const wchar_t* fullname,
                  const wchar_t* comment,
                  bool add_to_users_group,
                  const wchar_t* domain,
                  BSTR* sid,
                  DWORD* error);
  HRESULT ChangeUserPassword(const wchar_t* domain,
                             const wchar_t* username,
                             const wchar_t* password,
                             const wchar_t* old_password) override;
  HRESULT SetUserPassword(const wchar_t* domain,
                          const wchar_t* username,
                          const wchar_t* password) override;
  HRESULT SetUserFullname(const wchar_t* domain,
                          const wchar_t* username,
                          const wchar_t* full_name) override;
  HRESULT IsWindowsPasswordValid(const wchar_t* domain,
                                 const wchar_t* username,
                                 const wchar_t* password) override;

  HRESULT CreateLogonToken(const wchar_t* domain,
                           const wchar_t* username,
                           const wchar_t* password,
                           bool interactive,
                           base::win::ScopedHandle* token) override;

  HRESULT GetUserSID(const wchar_t* domain,
                     const wchar_t* username,
                     PSID* sid) override;

  HRESULT FindUserBySID(const wchar_t* sid,
                        wchar_t* username,
                        DWORD username_size,
                        wchar_t* domain,
                        DWORD domain_size) override;
  HRESULT RemoveUser(const wchar_t* username, const wchar_t* password) override;

  HRESULT GetUserFullname(const wchar_t* domain,
                          const wchar_t* username,
                          std::wstring* fullname) override;

  HRESULT ModifyUserAccessWithLogonHours(const wchar_t* domain,
                                         const wchar_t* username,
                                         bool allow) override;

  HRESULT SetDefaultPasswordChangePolicies(const wchar_t* domain,
                                           const wchar_t* username) override;

  bool IsDeviceDomainJoined() override;

  void SetIsDeviceDomainJoined(bool is_device_domain_joined) {
    is_device_domain_joined_ = is_device_domain_joined;
  }

  void FailFindUserBySID(const wchar_t* sid, int number_of_failures);

  struct UserInfo {
    UserInfo(const wchar_t* domain,
             const wchar_t* password,
             const wchar_t* fullname,
             const wchar_t* comment,
             const wchar_t* sid);
    UserInfo();
    UserInfo(const UserInfo& other);
    ~UserInfo();

    bool operator==(const UserInfo& other) const;

    std::wstring domain;
    std::wstring password;
    std::wstring fullname;
    std::wstring comment;
    std::wstring sid;
  };
  const UserInfo GetUserInfo(const wchar_t* username);

  // Creates a new unique sid.  Free returned sid with FreeSid().
  HRESULT CreateNewSID(PSID* sid);

  // Creates a fake user with the given |username|, |password|, |fullname|,
  // |comment|. If |gaia_id| is non-empty, also associates the user with
  // the given gaia id. If |email| is non-empty, sets the email to use for
  // reauth to be this one.
  // |sid| is allocated and filled with the SID of the new user.
  HRESULT CreateTestOSUser(const std::wstring& username,
                           const std::wstring& password,
                           const std::wstring& fullname,
                           const std::wstring& comment,
                           const GaiaId& gaia_id,
                           const std::wstring& email,
                           BSTR* sid);

  // Creates a fake user with the given |username|, |password|, |fullname|,
  // |comment| and |domain|. If |gaia_id| is non-empty, also associates the
  // user with the given gaia id. If |email| is non-empty, sets the email to
  // use for reauth to be this one.
  // |sid| is allocated and filled with the SID of the new user.
  HRESULT CreateTestOSUser(const std::wstring& username,
                           const std::wstring& password,
                           const std::wstring& fullname,
                           const std::wstring& comment,
                           const GaiaId& gaia_id,
                           const std::wstring& email,
                           const std::wstring& domain,
                           BSTR* sid);

  size_t GetUserCount() const { return username_to_info_.size(); }
  std::vector<std::pair<std::wstring, std::wstring>> GetUsers() const;

  void SetFailureReason(FAILEDOPERATIONS failed_operaetion,
                        HRESULT failure_reason) {
    failure_reasons_[failed_operaetion] = failure_reason;
  }

  bool DoesOperationFail(FAILEDOPERATIONS op) {
    return failure_reasons_.find(op) != failure_reasons_.end();
  }

  void RestoreOperation(FAILEDOPERATIONS op) { failure_reasons_.erase(op); }

 private:
  raw_ptr<OSUserManager> original_manager_;
  DWORD next_rid_ = 0;
  std::map<std::wstring, UserInfo> username_to_info_;
  bool is_device_domain_joined_ = false;
  std::map<FAILEDOPERATIONS, HRESULT> failure_reasons_;
  std::map<std::wstring, int> to_be_failed_find_user_sids_;
};

///////////////////////////////////////////////////////////////////////////////

class FakeScopedLsaPolicyFactory {
 public:
  FakeScopedLsaPolicyFactory();
  virtual ~FakeScopedLsaPolicyFactory();

  ScopedLsaPolicy::CreatorCallback GetCreatorCallback();

  // PrivateDataMap is a string-to-string key/value store that maps private
  // names to their corresponding data strings.  The term "private" here is
  // used to reflect the name of the underlying OS calls.  This data is meant
  // to be shared by all ScopedLsaPolicy instances created by this factory.
  using PrivateDataMap = std::map<std::wstring, std::wstring>;
  PrivateDataMap& private_data() { return private_data_; }

 private:
  std::unique_ptr<ScopedLsaPolicy> Create(ACCESS_MASK mask);

  ScopedLsaPolicy::CreatorCallback original_creator_;
  PrivateDataMap private_data_;
};

class FakeScopedLsaPolicy : public ScopedLsaPolicy {
 public:
  ~FakeScopedLsaPolicy() override;

  // ScopedLsaPolicy
  HRESULT StorePrivateData(const wchar_t* key, const wchar_t* value) override;
  HRESULT RemovePrivateData(const wchar_t* key) override;
  HRESULT RetrievePrivateData(const wchar_t* key,
                              wchar_t* value,
                              size_t length) override;
  bool PrivateDataExists(const wchar_t* key) override;
  HRESULT AddAccountRights(PSID sid,
                           const std::vector<std::wstring>& rights) override;
  HRESULT RemoveAccountRights(PSID sid,
                              const std::vector<std::wstring>& rights) override;
  HRESULT RemoveAccount(PSID sid) override;

 private:
  friend class FakeScopedLsaPolicyFactory;

  explicit FakeScopedLsaPolicy(FakeScopedLsaPolicyFactory* factory);

  FakeScopedLsaPolicyFactory::PrivateDataMap& private_data() {
    return factory_->private_data();
  }

  raw_ptr<FakeScopedLsaPolicyFactory> factory_;
};

///////////////////////////////////////////////////////////////////////////////

// A scoped FakeScopedUserProfile factory.  Installs itself when constructed
// and removes itself when deleted.
class FakeScopedUserProfileFactory {
 public:
  FakeScopedUserProfileFactory();
  virtual ~FakeScopedUserProfileFactory();

 private:
  std::unique_ptr<ScopedUserProfile> Create(const std::wstring& sid,
                                            const std::wstring& domain,
                                            const std::wstring& username,
                                            const std::wstring& password);

  ScopedUserProfile::CreatorCallback original_creator_;
};

class FakeScopedUserProfile : public ScopedUserProfile {
 public:
  HRESULT SaveAccountInfo(const base::Value::Dict& properties) override;

 private:
  friend class FakeScopedUserProfileFactory;

  FakeScopedUserProfile(const std::wstring& sid,
                        const std::wstring& domain,
                        const std::wstring& username,
                        const std::wstring& password);
  ~FakeScopedUserProfile() override;

  bool is_valid_ = false;
};

///////////////////////////////////////////////////////////////////////////////

// A scoped FakeWinHttpUrlFetcher factory.  Installs itself when constructed
// and removes itself when deleted.
class FakeWinHttpUrlFetcherFactory {
 public:
  FakeWinHttpUrlFetcherFactory();
  ~FakeWinHttpUrlFetcherFactory();

  // Returns the fetcher callback function being used. This can be used to
  // install the same fake explicitly in all the components being used. Those
  // components would otherwise have different fakes created automatically when
  // they get initialized.
  WinHttpUrlFetcher::CreatorCallback GetCreatorCallback();

  // Sets the given |response| for any number of HTTP requests made for |url|.
  void SetFakeResponse(
      const GURL& url,
      const WinHttpUrlFetcher::Headers& headers,
      const std::string& response,
      HANDLE send_response_event_handle = INVALID_HANDLE_VALUE);

  // Queues the given |response| for the specified |num_requests| number of HTTP
  // requests made for |url|. Different responses for the URL can be set by
  // calling this function multiple times with different responses.
  void SetFakeResponseForSpecifiedNumRequests(
      const GURL& url,
      const WinHttpUrlFetcher::Headers& headers,
      const std::string& response,
      unsigned int num_requests,
      HANDLE send_response_event_handle = INVALID_HANDLE_VALUE);

  // Sets the response as a failed http attempt. The return result
  // from http_url_fetcher.Fetch() would be set as the input HRESULT
  // to this method.
  void SetFakeFailedResponse(const GURL& url, HRESULT failed_hr);

  // Sets the option to collect request data for each URL fetcher created.
  void SetCollectRequestData(bool value) { collect_request_data_ = value; }

  // Data used to make each HTTP request by the fetcher.
  struct RequestData {
    RequestData();
    RequestData(const RequestData& rhs);
    ~RequestData();
    WinHttpUrlFetcher::Headers headers;
    std::string body;
    int timeout_in_millis;
  };

  // Returns the request data for the request identified by |request_index|.
  RequestData GetRequestData(size_t request_index) const;

  // Returns the number of requests created.
  size_t requests_created() const { return requests_created_; }

 private:
  std::unique_ptr<WinHttpUrlFetcher> Create(const GURL& url);

  WinHttpUrlFetcher::CreatorCallback original_creator_;
  WinHttpUrlFetcher::CreatorCallback fake_creator_;

  struct Response {
    Response();
    Response(const Response& rhs);
    Response(const WinHttpUrlFetcher::Headers& new_headers,
             const std::string& new_response,
             HANDLE new_send_response_event_handle);
    ~Response();
    WinHttpUrlFetcher::Headers headers;
    std::string response;
    HANDLE send_response_event_handle;
  };

  std::map<GURL, std::deque<Response>> fake_responses_;
  std::map<GURL, HRESULT> failed_http_fetch_hr_;
  size_t requests_created_ = 0;
  bool collect_request_data_ = false;
  bool remove_fake_response_when_created_ = false;
  std::vector<RequestData> requests_data_;
};

class FakeWinHttpUrlFetcher : public WinHttpUrlFetcher {
 public:
  explicit FakeWinHttpUrlFetcher(const GURL& url);
  ~FakeWinHttpUrlFetcher() override;

  using WinHttpUrlFetcher::Headers;

  const Headers& response_headers() const { return response_headers_; }

  // WinHttpUrlFetcher
  bool IsValid() const override;
  HRESULT SetRequestHeader(const char* name, const char* value) override;
  HRESULT SetRequestBody(const char* body) override;
  HRESULT SetHttpRequestTimeout(const int timeout_in_millis) override;
  HRESULT Fetch(std::vector<char>* response) override;
  HRESULT Close() override;

 private:
  friend FakeWinHttpUrlFetcherFactory;
  typedef FakeWinHttpUrlFetcherFactory::RequestData RequestData;

  Headers response_headers_;
  std::string response_;
  HANDLE send_response_event_handle_;
  HRESULT response_hr_ = S_OK;
  raw_ptr<RequestData> request_data_ = nullptr;
};

///////////////////////////////////////////////////////////////////////////////

class FakeAssociatedUserValidator : public AssociatedUserValidator {
 public:
  FakeAssociatedUserValidator();
  explicit FakeAssociatedUserValidator(base::TimeDelta validation_timeout);
  ~FakeAssociatedUserValidator() override;

  using AssociatedUserValidator::ForceRefreshTokenHandlesForTesting;
  using AssociatedUserValidator::IsUserAccessBlockedForTesting;

 private:
  raw_ptr<AssociatedUserValidator> original_validator_ = nullptr;
};

///////////////////////////////////////////////////////////////////////////////

class FakeChromeAvailabilityChecker : public ChromeAvailabilityChecker {
 public:
  enum HasSupportedChromeCheckType {
    kChromeForceYes,
    kChromeForceNo,
    kChromeDontForce  // Uses the original checker to get result.
  };

  FakeChromeAvailabilityChecker(
      HasSupportedChromeCheckType has_supported_chrome = kChromeForceYes);
  ~FakeChromeAvailabilityChecker() override;

  bool HasSupportedChromeVersion() override;
  void SetHasSupportedChrome(HasSupportedChromeCheckType has_supported_chrome);

 private:
  raw_ptr<ChromeAvailabilityChecker> original_checker_ = nullptr;

  // Used during tests to force the credential provider to believe if a
  // supported Chrome version is installed or not. In production a real
  // check is performed at runtime.
  HasSupportedChromeCheckType has_supported_chrome_ = kChromeForceYes;
};

///////////////////////////////////////////////////////////////////////////////

class FakeInternetAvailabilityChecker : public InternetAvailabilityChecker {
 public:
  enum HasInternetConnectionCheckType { kHicForceYes, kHicForceNo };

  FakeInternetAvailabilityChecker(
      HasInternetConnectionCheckType has_internet_connection = kHicForceYes);
  ~FakeInternetAvailabilityChecker() override;

  bool HasInternetConnection() override;
  void SetHasInternetConnection(
      HasInternetConnectionCheckType has_internet_connection);

 private:
  raw_ptr<InternetAvailabilityChecker> original_checker_ = nullptr;

  // Used during tests to force the credential provider to believe if an
  // internet connection is possible or not.  In production the value is
  // always set to HIC_CHECK_ALWAYS to perform a real check at runtime.
  HasInternetConnectionCheckType has_internet_connection_ = kHicForceYes;
};

///////////////////////////////////////////////////////////////////////////////

class FakePasswordRecoveryManager : public PasswordRecoveryManager {
 public:
  FakePasswordRecoveryManager();
  explicit FakePasswordRecoveryManager(
      base::TimeDelta encryption_key_request_timeout,
      base::TimeDelta decryption_key_request_timeout);
  ~FakePasswordRecoveryManager() override;

  using PasswordRecoveryManager::MakeGenerateKeyPairResponseForTesting;
  using PasswordRecoveryManager::MakeGetPrivateKeyResponseForTesting;
  using PasswordRecoveryManager::SetRequestTimeoutForTesting;

 private:
  raw_ptr<PasswordRecoveryManager> original_validator_ = nullptr;
};

///////////////////////////////////////////////////////////////////////////////

class FakeGemDeviceDetailsManager : public GemDeviceDetailsManager {
 public:
  FakeGemDeviceDetailsManager();
  explicit FakeGemDeviceDetailsManager(
      base::TimeDelta upload_device_details_request_timeout);
  ~FakeGemDeviceDetailsManager() override;

  using GemDeviceDetailsManager::GetRequestDictForTesting;
  using GemDeviceDetailsManager::GetUploadStatusForTesting;
  using GemDeviceDetailsManager::SetRequestTimeoutForTesting;

 private:
  raw_ptr<GemDeviceDetailsManager> original_manager_ = nullptr;
};

///////////////////////////////////////////////////////////////////////////////

class FakeEventLoggingApiManager : public EventLoggingApiManager {
 public:
  typedef EventLogsUploadManager::EventLogEntry EventLogEntry;

  EVT_HANDLE EvtQuery(EVT_HANDLE session,
                      LPCWSTR path,
                      LPCWSTR query,
                      DWORD flags) override;

  EVT_HANDLE EvtOpenPublisherMetadata(EVT_HANDLE session,
                                      LPCWSTR publisher_id,
                                      LPCWSTR log_file_path,
                                      LCID locale,
                                      DWORD flags) override;

  EVT_HANDLE EvtCreateRenderContext(DWORD value_paths_count,
                                    LPCWSTR* value_paths,
                                    DWORD flags) override;

  BOOL EvtNext(EVT_HANDLE result_set,
               DWORD events_size,
               PEVT_HANDLE events,
               DWORD timeout,
               DWORD flags,
               PDWORD num_returned) override;

  BOOL EvtGetQueryInfo(EVT_HANDLE query,
                       EVT_QUERY_PROPERTY_ID property_id,
                       DWORD value_buffer_size,
                       PEVT_VARIANT value_buffer,
                       PDWORD value_buffer_used) override;

  BOOL EvtRender(EVT_HANDLE context,
                 EVT_HANDLE evt_handle,
                 DWORD flags,
                 DWORD buffer_size,
                 PVOID buffer,
                 PDWORD buffer_used,
                 PDWORD property_count) override;

  BOOL EvtFormatMessage(EVT_HANDLE publisher_metadata,
                        EVT_HANDLE event,
                        DWORD message_id,
                        DWORD value_count,
                        PEVT_VARIANT values,
                        DWORD flags,
                        DWORD buffer_size,
                        LPWSTR buffer,
                        PDWORD buffer_used) override;

  BOOL EvtClose(EVT_HANDLE handle) override;

  DWORD GetLastError() override;

  explicit FakeEventLoggingApiManager(const std::vector<EventLogEntry>& logs);

  ~FakeEventLoggingApiManager() override;

 private:
  raw_ptr<EventLoggingApiManager> original_manager_ = nullptr;

  const raw_ref<const std::vector<EventLogEntry>> logs_;
  EVT_HANDLE query_handle_, publisher_metadata_, render_context_;
  DWORD last_error_;
  size_t next_event_idx_;
  std::vector<EVT_HANDLE> event_handles_;
  std::unordered_map<EVT_HANDLE, size_t> handle_to_index_map_;
};

class FakeEventLogsUploadManager : public EventLogsUploadManager {
 public:
  typedef EventLogsUploadManager::EventLogEntry EventLogEntry;

  // Construct with the logs that should be present in the fake event log.
  explicit FakeEventLogsUploadManager(const std::vector<EventLogEntry>& logs);
  ~FakeEventLogsUploadManager() override;

  // Get the last upload status of the call to UploadEventViewerLogs.
  HRESULT GetUploadStatus();

  // Get the number of successfully uploaded event logs.
  uint64_t GetNumLogsUploaded();

 private:
  raw_ptr<EventLogsUploadManager> original_manager_ = nullptr;
  FakeEventLoggingApiManager api_manager_;
};

///////////////////////////////////////////////////////////////////////////////

class FakeUserPoliciesManager : public UserPoliciesManager {
 public:
  FakeUserPoliciesManager();
  explicit FakeUserPoliciesManager(bool cloud_policies_enabled);
  ~FakeUserPoliciesManager() override;

  HRESULT FetchAndStoreCloudUserPolicies(
      const std::wstring& sid,
      const std::string& access_token) override;

  // Specify the policy to use for a user.
  void SetUserPolicies(const std::wstring& sid, const UserPolicies& policies);

  bool GetUserPolicies(const std::wstring& sid,
                       UserPolicies* policies) const override;

  // Specify whether user policy is valid for a user.
  void SetUserPolicyStaleOrMissing(const std::wstring& sid, bool status);

  bool IsUserPolicyStaleOrMissing(const std::wstring& sid) const override;

  // Returns the number of times FetchAndStoreCloudUserPolicies method was
  // called.
  int GetNumTimesFetchAndStoreCalled() const;

 private:
  raw_ptr<UserPoliciesManager> original_manager_ = nullptr;
  std::map<std::wstring, UserPolicies> user_policies_;
  int num_times_fetch_called_ = 0;
  std::map<std::wstring, bool> user_policies_stale_;
};

///////////////////////////////////////////////////////////////////////////////

class FakeDevicePoliciesManager : public DevicePoliciesManager {
 public:
  explicit FakeDevicePoliciesManager(bool cloud_policies_enabled);
  ~FakeDevicePoliciesManager() override;

  // Specify the policy to use for the device.
  void SetDevicePolicies(const DevicePolicies& policies);

  void GetDevicePolicies(DevicePolicies* device_policies) override;

 private:
  raw_ptr<DevicePoliciesManager> original_manager_ = nullptr;
  DevicePolicies device_policies_;
};

///////////////////////////////////////////////////////////////////////////////

class FakeGCPWFiles : public GCPWFiles {
 public:
  FakeGCPWFiles();
  ~FakeGCPWFiles() override;

  std::vector<base::FilePath::StringType> GetEffectiveInstallFiles() override;

 private:
  raw_ptr<GCPWFiles> original_files = nullptr;
};

///////////////////////////////////////////////////////////////////////////////

class FakeOSServiceManager : public extension::OSServiceManager {
 public:
  FakeOSServiceManager();
  ~FakeOSServiceManager() override;

  DWORD GetServiceStatus(SERVICE_STATUS* service_status) override;

  DWORD InstallService(const base::FilePath& service_binary_path,
                       extension::ScopedScHandle* sc_handle) override;

  DWORD StartServiceCtrlDispatcher(
      LPSERVICE_MAIN_FUNCTION service_main) override;

  DWORD RegisterCtrlHandler(
      LPHANDLER_FUNCTION handler_proc,
      SERVICE_STATUS_HANDLE* service_status_handle) override;

  DWORD SetServiceStatus(SERVICE_STATUS_HANDLE service_status_handle,
                         SERVICE_STATUS service) override;

  void SendControlRequestForTesting(DWORD control_request) {
    std::unique_lock<std::mutex> lock(m);
    queue.push_back(control_request);
    cv.notify_one();
  }

  DWORD DeleteService() override;

  DWORD ChangeServiceConfig(DWORD dwServiceType,
                            DWORD dwStartType,
                            DWORD dwErrorControl) override;

 private:
  DWORD GetControlRequestForTesting() {
    std::unique_lock<std::mutex> lock(m);
    cv.wait(lock, [&]() { return !queue.empty(); });
    DWORD result = queue.front();
    queue.pop_front();
    return result;
  }

  struct ServiceInfo {
    LPHANDLER_FUNCTION control_handler_cb_;
    SERVICE_STATUS service_status_;
  };

  // Primitives that are used to synchronize with the thread running service
  // main and the thread testing the code.
  std::list<DWORD> queue;
  std::mutex m;
  std::condition_variable cv;

  // Original instance of OSServiceManager.
  raw_ptr<extension::OSServiceManager> os_service_manager_ = nullptr;
  std::map<std::wstring, ServiceInfo> service_lookup_from_name_;
};

///////////////////////////////////////////////////////////////////////////////

class FakeTaskManager : public extension::TaskManager {
 public:
  FakeTaskManager();
  ~FakeTaskManager() override;

  int NumOfTimesExecuted(const std::string& task_name) {
    return num_of_times_executed_[task_name];
  }

 private:
  void ExecuteTask(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
                   const std::string& task_name) override;

  // Original instance of TaskManager.
  raw_ptr<extension::TaskManager> task_manager_ = nullptr;

  // Counts the number of execution per task.
  std::map<std::string, int> num_of_times_executed_;
};

///////////////////////////////////////////////////////////////////////////////

class FakeTokenGenerator : public TokenGenerator {
 public:
  FakeTokenGenerator();
  ~FakeTokenGenerator() override;

  std::string GenerateToken() override;

  void SetTokensForTesting(const std::vector<std::string>& test_tokens);

 private:
  raw_ptr<TokenGenerator> token_generator_ = nullptr;
  std::vector<std::string> test_tokens_;
};

///////////////////////////////////////////////////////////////////////////////

}  // namespace credential_provider

#endif  // CHROME_CREDENTIAL_PROVIDER_TEST_GCP_FAKES_H_