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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
|
// 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_CHROMEOS_SETTINGS_DEVICE_SETTINGS_TEST_HELPER_H_
#define CHROME_BROWSER_CHROMEOS_SETTINGS_DEVICE_SETTINGS_TEST_HELPER_H_
#include <map>
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/message_loop/message_loop.h"
#include "base/strings/string_util.h"
#include "chrome/browser/chromeos/login/users/fake_user_manager.h"
#include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
#include "chrome/browser/chromeos/policy/device_policy_builder.h"
#include "chrome/browser/chromeos/settings/device_settings_service.h"
#include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
#include "chromeos/dbus/session_manager_client.h"
#include "components/ownership/mock_owner_key_util.h"
#include "content/public/test/test_browser_thread_bundle.h"
#include "testing/gtest/include/gtest/gtest.h"
class TestingProfile;
namespace chromeos {
class DBusThreadManagerSetter;
// A helper class for tests mocking out session_manager's device settings
// interface. The pattern is to initialize DeviceSettingsService with the helper
// for the SessionManagerClient pointer. The helper records calls made by
// DeviceSettingsService. The test can then verify state, after which it should
// call one of the Flush() variants that will resume processing.
class DeviceSettingsTestHelper : public SessionManagerClient {
public:
// Wraps a device settings service instance for testing.
DeviceSettingsTestHelper();
virtual ~DeviceSettingsTestHelper();
// Runs all pending store callbacks.
void FlushStore();
// Runs all pending retrieve callbacks.
void FlushRetrieve();
// Flushes all pending operations.
void Flush();
// Checks whether any asynchronous Store/Retrieve operations are pending.
bool HasPendingOperations() const;
bool store_result() {
return device_policy_.store_result_;
}
void set_store_result(bool store_result) {
device_policy_.store_result_ = store_result;
}
const std::string& policy_blob() {
return device_policy_.policy_blob_;
}
void set_policy_blob(const std::string& policy_blob) {
device_policy_.policy_blob_ = policy_blob;
}
const std::string& device_local_account_policy_blob(
const std::string& id) const {
const std::map<std::string, PolicyState>::const_iterator entry =
device_local_account_policy_.find(id);
return entry == device_local_account_policy_.end() ?
base::EmptyString() : entry->second.policy_blob_;
}
void set_device_local_account_policy_blob(const std::string& id,
const std::string& policy_blob) {
device_local_account_policy_[id].policy_blob_ = policy_blob;
}
// SessionManagerClient:
virtual void Init(dbus::Bus* bus) override;
virtual void SetStubDelegate(SessionManagerClient::StubDelegate* delegate)
override;
virtual void AddObserver(Observer* observer) override;
virtual void RemoveObserver(Observer* observer) override;
virtual bool HasObserver(const Observer* observer) const override;
virtual void EmitLoginPromptVisible() override;
virtual void RestartJob(int pid, const std::string& command_line) override;
virtual void StartSession(const std::string& user_email) override;
virtual void StopSession() override;
virtual void NotifySupervisedUserCreationStarted() override;
virtual void NotifySupervisedUserCreationFinished() override;
virtual void StartDeviceWipe() override;
virtual void RequestLockScreen() override;
virtual void NotifyLockScreenShown() override;
virtual void NotifyLockScreenDismissed() override;
virtual void RetrieveActiveSessions(
const ActiveSessionsCallback& callback) override;
virtual void RetrieveDevicePolicy(
const RetrievePolicyCallback& callback) override;
virtual void RetrievePolicyForUser(
const std::string& username,
const RetrievePolicyCallback& callback) override;
virtual std::string BlockingRetrievePolicyForUser(
const std::string& username) override;
virtual void RetrieveDeviceLocalAccountPolicy(
const std::string& account_id,
const RetrievePolicyCallback& callback) override;
virtual void StoreDevicePolicy(const std::string& policy_blob,
const StorePolicyCallback& callback) override;
virtual void StorePolicyForUser(const std::string& username,
const std::string& policy_blob,
const StorePolicyCallback& callback) override;
virtual void StoreDeviceLocalAccountPolicy(
const std::string& account_id,
const std::string& policy_blob,
const StorePolicyCallback& callback) override;
virtual void SetFlagsForUser(
const std::string& account_id,
const std::vector<std::string>& flags) override;
virtual void GetServerBackedStateKeys(
const StateKeysCallback& callback) override;
private:
struct PolicyState {
bool store_result_;
std::string policy_blob_;
std::vector<StorePolicyCallback> store_callbacks_;
std::vector<RetrievePolicyCallback> retrieve_callbacks_;
PolicyState();
~PolicyState();
bool HasPendingOperations() const {
return !store_callbacks_.empty() || !retrieve_callbacks_.empty();
}
};
PolicyState device_policy_;
std::map<std::string, PolicyState> device_local_account_policy_;
DISALLOW_COPY_AND_ASSIGN(DeviceSettingsTestHelper);
};
// Wraps the singleton device settings and initializes it to the point where it
// reports OWNERSHIP_NONE for the ownership status.
class ScopedDeviceSettingsTestHelper : public DeviceSettingsTestHelper {
public:
ScopedDeviceSettingsTestHelper();
virtual ~ScopedDeviceSettingsTestHelper();
private:
DISALLOW_COPY_AND_ASSIGN(ScopedDeviceSettingsTestHelper);
};
// A convenience test base class that initializes a DeviceSettingsService
// instance for testing and allows for straightforward updating of device
// settings. |device_settings_service_| starts out in uninitialized state, so
// startup code gets tested as well.
class DeviceSettingsTestBase : public testing::Test {
protected:
DeviceSettingsTestBase();
virtual ~DeviceSettingsTestBase();
virtual void SetUp() override;
virtual void TearDown() override;
// Flushes any pending device settings operations.
void FlushDeviceSettings();
// Triggers an owner key and device settings reload on
// |device_settings_service_| and flushes the resulting load operation.
void ReloadDeviceSettings();
void InitOwner(const std::string& user_id, bool tpm_is_ready);
content::TestBrowserThreadBundle thread_bundle_;
policy::DevicePolicyBuilder device_policy_;
DeviceSettingsTestHelper device_settings_test_helper_;
// Note that FakeUserManager is used by ProfileHelper, which some of the
// tested classes depend on implicitly.
FakeUserManager* user_manager_;
ScopedUserManagerEnabler user_manager_enabler_;
scoped_refptr<ownership::MockOwnerKeyUtil> owner_key_util_;
// Local DeviceSettingsService instance for tests. Avoid using in combination
// with the global instance (DeviceSettingsService::Get()).
DeviceSettingsService device_settings_service_;
scoped_ptr<TestingProfile> profile_;
scoped_ptr<DBusThreadManagerSetter> dbus_setter_;
private:
DISALLOW_COPY_AND_ASSIGN(DeviceSettingsTestBase);
};
} // namespace chromeos
#endif // CHROME_BROWSER_CHROMEOS_SETTINGS_DEVICE_SETTINGS_TEST_HELPER_H_
|
