File: fake_sync_engine.h

package info (click to toggle)
chromium 139.0.7258.127-1
  • links: PTS, VCS
  • area: main
  • in suites:
  • size: 6,122,068 kB
  • sloc: cpp: 35,100,771; ansic: 7,163,530; javascript: 4,103,002; python: 1,436,920; asm: 946,517; xml: 746,709; pascal: 187,653; perl: 88,691; sh: 88,436; objc: 79,953; sql: 51,488; cs: 44,583; fortran: 24,137; makefile: 22,147; tcl: 15,277; php: 13,980; yacc: 8,984; ruby: 7,485; awk: 3,720; lisp: 3,096; lex: 1,327; ada: 727; jsp: 228; sed: 36
file content (140 lines) | stat: -rw-r--r-- 4,600 bytes parent folder | download | duplicates (6)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef COMPONENTS_SYNC_TEST_FAKE_SYNC_ENGINE_H_
#define COMPONENTS_SYNC_TEST_FAKE_SYNC_ENGINE_H_

#include <memory>
#include <string>
#include <vector>

#include "base/compiler_specific.h"
#include "base/functional/callback_forward.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "components/sync/engine/configure_reason.h"
#include "components/sync/engine/sync_engine.h"
#include "components/sync/engine/sync_status.h"
#include "google_apis/gaia/core_account_id.h"

namespace syncer {

// A fake of the SyncEngine.
//
// This class implements the bare minimum required for the SyncServiceImpl to
// get through initialization. It often returns null pointers or nonsense
// values; it is not intended to be used in tests that depend on SyncEngine
// behavior.
class FakeSyncEngine final : public SyncEngine {
 public:
  static constexpr char kTestBirthday[] = "1";

  FakeSyncEngine(bool allow_init_completion,
                 bool is_first_time_sync_configure,
                 const base::RepeatingClosure& sync_transport_data_cleared_cb);
  ~FakeSyncEngine() override;

  CoreAccountId authenticated_account_id() const {
    return authenticated_account_id_;
  }

  ConfigureReason last_configure_reason() const {
    return last_configure_reason_;
  }

  bool started_handling_invalidations() {
    return started_handling_invalidations_;
  }

  void SetPollIntervalElapsed(bool elapsed);

  // Manual completion of Initialize(), required if auto-completion was disabled
  // in the constructor.
  void TriggerInitializationCompletion(bool success);

  void SetDetailedStatus(const SyncStatus& status);

  // Immediately calls params.host->OnEngineInitialized.
  void Initialize(InitParams params) override;

  bool IsInitialized() const override;

  void TriggerRefresh(const DataTypeSet& types) override;

  void UpdateCredentials(const SyncCredentials& credentials) override;

  void InvalidateCredentials() override;

  std::string GetCacheGuid() const override;

  std::string GetBirthday() const override;

  base::Time GetLastSyncedTimeForDebugging() const override;

  void StartConfiguration() override;

  void StartHandlingInvalidations() override;

  void StartSyncingWithServer() override;

  void SetEncryptionPassphrase(
      const std::string& passphrase,
      const KeyDerivationParams& key_derivation_params) override;

  void SetExplicitPassphraseDecryptionKey(std::unique_ptr<Nigori> key) override;

  void AddTrustedVaultDecryptionKeys(
      const std::vector<std::vector<uint8_t>>& keys,
      base::OnceClosure done_cb) override;

  void StopSyncingForShutdown() override;

  void Shutdown(ShutdownReason reason) override;

  void ConfigureDataTypes(ConfigureParams params) override;

  void ConnectDataType(DataType type,
                       std::unique_ptr<DataTypeActivationResponse>) override;
  void DisconnectDataType(DataType type) override;

  const SyncStatus& GetDetailedStatus() const override;

  void HasUnsyncedItemsForTest(
      base::OnceCallback<void(bool)> cb) const override;
  void GetThrottledDataTypesForTest(
      base::OnceCallback<void(DataTypeSet)> cb) const override;

  void RequestBufferedProtocolEventsAndEnableForwarding() override;
  void DisableProtocolEventForwarding() override;

  void OnCookieJarChanged(bool account_mismatch,
                          base::OnceClosure callback) override;
  bool IsNextPollTimeInThePast() const override;
  void ClearNigoriDataForMigration() override;
  void GetNigoriNodeForDebugging(AllNodesCallback callback) override;
  void RecordNigoriMemoryUsageAndCountsHistograms() override;

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

 private:
  const bool allow_init_completion_;
  const bool is_first_time_sync_configure_;
  const base::RepeatingClosure sync_transport_data_cleared_cb_;
  // AcrossTasksDanglingUntriaged because it is assigned a
  // AcrossTasksDanglingUntriaged pointer.
  raw_ptr<SyncEngineHost, AcrossTasksDanglingUntriaged> host_ = nullptr;
  bool initialized_ = false;
  SyncStatus sync_status_;
  CoreAccountId authenticated_account_id_;
  bool started_handling_invalidations_ = false;
  bool is_next_poll_time_in_the_past_ = false;
  ConfigureReason last_configure_reason_ = CONFIGURE_REASON_UNKNOWN;
  base::WeakPtrFactory<FakeSyncEngine> weak_ptr_factory_{this};
};

}  // namespace syncer

#endif  // COMPONENTS_SYNC_TEST_FAKE_SYNC_ENGINE_H_