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
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_MOCK_H_
#define CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_MOCK_H_
#include <string>
#include <vector>
#include "base/memory/weak_ptr.h"
#include "base/strings/string16.h"
#include "chrome/browser/sync/glue/change_processor.h"
#include "chrome/browser/sync/glue/data_type_controller.h"
#include "chrome/browser/sync/glue/device_info.h"
#include "chrome/browser/sync/profile_sync_service.h"
#include "chrome/test/base/testing_profile.h"
#include "google_apis/gaia/google_service_auth_error.h"
#include "sync/internal_api/public/base/model_type.h"
#include "sync/protocol/sync_protocol_error.h"
#include "testing/gmock/include/gmock/gmock.h"
using ::testing::Invoke;
class ProfileSyncServiceMock : public ProfileSyncService {
public:
// no-arg constructor provided so TestingProfile can use NiceMock.
ProfileSyncServiceMock();
explicit ProfileSyncServiceMock(Profile* profile);
virtual ~ProfileSyncServiceMock();
// A utility used by sync tests to create a TestingProfile with a Google
// Services username stored in a (Testing)PrefService.
static TestingProfile* MakeSignedInTestingProfile();
// Helper routine to be used in conjunction with
// BrowserContextKeyedServiceFactory::SetTestingFactory().
static BrowserContextKeyedService* BuildMockProfileSyncService(
content::BrowserContext* profile);
MOCK_METHOD0(DisableForUser, void());
MOCK_METHOD3(OnBackendInitialized,
void(const syncer::WeakHandle<syncer::JsBackend>&,
const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&,
bool));
MOCK_METHOD0(OnSyncCycleCompleted, void());
MOCK_METHOD0(OnAuthError, void());
MOCK_METHOD4(OnUserSubmittedAuth,
void(const std::string& username,
const std::string& password,
const std::string& captcha,
const std::string& access_code));
MOCK_METHOD0(OnUserCancelledDialog, void());
MOCK_CONST_METHOD0(GetAuthenticatedUsername, string16());
MOCK_METHOD2(OnUserChoseDatatypes,
void(bool sync_everything,
syncer::ModelTypeSet chosen_types));
MOCK_METHOD2(OnUnrecoverableError,
void(const tracked_objects::Location& location,
const std::string& message));
MOCK_METHOD3(DisableBrokenDatatype, void(syncer::ModelType,
const tracked_objects::Location&,
std::string message));
MOCK_CONST_METHOD0(GetUserShare, syncer::UserShare*());
MOCK_METHOD3(ActivateDataType,
void(syncer::ModelType, syncer::ModelSafeGroup,
browser_sync::ChangeProcessor*));
MOCK_METHOD1(DeactivateDataType, void(syncer::ModelType));
MOCK_METHOD0(UnsuppressAndStart, void());
MOCK_METHOD1(AddObserver, void(ProfileSyncServiceBase::Observer*));
MOCK_METHOD1(RemoveObserver, void(ProfileSyncServiceBase::Observer*));
MOCK_METHOD0(GetJsController, base::WeakPtr<syncer::JsController>());
MOCK_CONST_METHOD0(HasSyncSetupCompleted, bool());
MOCK_CONST_METHOD0(EncryptEverythingEnabled, bool());
MOCK_METHOD0(EnableEncryptEverything, void());
MOCK_METHOD1(ChangePreferredDataTypes,
void(syncer::ModelTypeSet preferred_types));
MOCK_CONST_METHOD0(GetActiveDataTypes, syncer::ModelTypeSet());
MOCK_CONST_METHOD0(GetPreferredDataTypes, syncer::ModelTypeSet());
MOCK_CONST_METHOD0(GetRegisteredDataTypes, syncer::ModelTypeSet());
MOCK_CONST_METHOD0(GetLastSessionSnapshot,
syncer::sessions::SyncSessionSnapshot());
MOCK_METHOD1(QueryDetailedSyncStatus,
bool(browser_sync::SyncBackendHost::Status* result));
MOCK_CONST_METHOD0(GetAuthError, const GoogleServiceAuthError&());
MOCK_CONST_METHOD0(FirstSetupInProgress, bool());
MOCK_CONST_METHOD0(GetLastSyncedTimeString, string16());
MOCK_CONST_METHOD0(HasUnrecoverableError, bool());
MOCK_CONST_METHOD0(sync_initialized, bool());
MOCK_CONST_METHOD0(IsStartSuppressed, bool());
MOCK_CONST_METHOD0(waiting_for_auth, bool());
MOCK_METHOD1(OnActionableError, void(
const syncer::SyncProtocolError&));
MOCK_METHOD1(SetSetupInProgress, void(bool));
MOCK_METHOD0(GetSessionModelAssociator,
browser_sync::SessionModelAssociator*());
MOCK_CONST_METHOD0(GetAllSignedInDevicesMock,
std::vector<browser_sync::DeviceInfo*>* ());
// This is to get around the fact that GMOCK does not handle Scoped*.
virtual ScopedVector<browser_sync::DeviceInfo>
GetAllSignedInDevices() const OVERRIDE;
// DataTypeManagerObserver mocks.
MOCK_METHOD0(OnConfigureBlocked, void());
MOCK_METHOD1(OnConfigureDone,
void(const browser_sync::DataTypeManager::ConfigureResult&));
MOCK_METHOD0(OnConfigureRetry, void());
MOCK_METHOD0(OnConfigureStart, void());
MOCK_METHOD0(IsSyncEnabledAndLoggedIn, bool());
MOCK_CONST_METHOD0(IsManaged, bool());
MOCK_METHOD0(IsOAuthRefreshTokenAvailable, bool());
MOCK_CONST_METHOD0(IsPassphraseRequired, bool());
MOCK_CONST_METHOD0(IsPassphraseRequiredForDecryption, bool());
MOCK_CONST_METHOD0(IsUsingSecondaryPassphrase, bool());
MOCK_CONST_METHOD0(GetPassphraseType, syncer::PassphraseType());
MOCK_CONST_METHOD0(GetPassphraseTime, base::Time());
MOCK_CONST_METHOD0(GetExplicitPassphraseTime, base::Time());
MOCK_METHOD1(SetDecryptionPassphrase, bool(const std::string& passphrase));
MOCK_METHOD2(SetEncryptionPassphrase, void(const std::string& passphrase,
PassphraseType type));
};
#endif // CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_MOCK_H_
|
