1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
6
7#include "base/message_loop/message_loop.h"
8#include "base/run_loop.h"
9#include "base/threading/sequenced_worker_pool.h"
10#include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos.h"
11#include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos_factory.h"
12#include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
13#include "chrome/browser/chromeos/profiles/profile_helper.h"
14#include "chrome/browser/chromeos/settings/device_settings_service.h"
15#include "chrome/test/base/testing_browser_process.h"
16#include "chrome/test/base/testing_profile.h"
17#include "chromeos/dbus/dbus_thread_manager.h"
18#include "components/ownership/mock_owner_key_util.h"
19#include "content/public/browser/browser_thread.h"
20#include "content/public/test/test_utils.h"
21
22namespace chromeos {
23
24DeviceSettingsTestHelper::DeviceSettingsTestHelper() {}
25
26DeviceSettingsTestHelper::~DeviceSettingsTestHelper() {}
27
28void DeviceSettingsTestHelper::FlushStore() {
29  std::vector<StorePolicyCallback> callbacks;
30  callbacks.swap(device_policy_.store_callbacks_);
31  for (std::vector<StorePolicyCallback>::iterator cb(callbacks.begin());
32       cb != callbacks.end(); ++cb) {
33    cb->Run(device_policy_.store_result_);
34  }
35
36  std::map<std::string, PolicyState>::iterator device_local_account_state;
37  for (device_local_account_state = device_local_account_policy_.begin();
38       device_local_account_state != device_local_account_policy_.end();
39       ++device_local_account_state) {
40    callbacks.swap(device_local_account_state->second.store_callbacks_);
41    for (std::vector<StorePolicyCallback>::iterator cb(callbacks.begin());
42         cb != callbacks.end(); ++cb) {
43      cb->Run(device_local_account_state->second.store_result_);
44    }
45  }
46}
47
48void DeviceSettingsTestHelper::FlushRetrieve() {
49  std::vector<RetrievePolicyCallback> callbacks;
50  callbacks.swap(device_policy_.retrieve_callbacks_);
51  for (std::vector<RetrievePolicyCallback>::iterator cb(callbacks.begin());
52       cb != callbacks.end(); ++cb) {
53    cb->Run(device_policy_.policy_blob_);
54  }
55
56  std::map<std::string, PolicyState>::iterator device_local_account_state;
57  for (device_local_account_state = device_local_account_policy_.begin();
58       device_local_account_state != device_local_account_policy_.end();
59       ++device_local_account_state) {
60    std::vector<RetrievePolicyCallback> callbacks;
61    callbacks.swap(device_local_account_state->second.retrieve_callbacks_);
62    for (std::vector<RetrievePolicyCallback>::iterator cb(callbacks.begin());
63         cb != callbacks.end(); ++cb) {
64      cb->Run(device_local_account_state->second.policy_blob_);
65    }
66  }
67}
68
69void DeviceSettingsTestHelper::Flush() {
70  do {
71    content::RunAllBlockingPoolTasksUntilIdle();
72    FlushStore();
73    content::RunAllBlockingPoolTasksUntilIdle();
74    FlushRetrieve();
75    content::RunAllBlockingPoolTasksUntilIdle();
76  } while (HasPendingOperations());
77}
78
79bool DeviceSettingsTestHelper::HasPendingOperations() const {
80  if (device_policy_.HasPendingOperations())
81    return true;
82
83  std::map<std::string, PolicyState>::const_iterator device_local_account_state;
84  for (device_local_account_state = device_local_account_policy_.begin();
85       device_local_account_state != device_local_account_policy_.end();
86       ++device_local_account_state) {
87    if (device_local_account_state->second.HasPendingOperations())
88      return true;
89  }
90
91  return false;
92}
93
94void DeviceSettingsTestHelper::Init(dbus::Bus* bus) {}
95
96void DeviceSettingsTestHelper::SetStubDelegate(
97    SessionManagerClient::StubDelegate* delegate) {}
98
99void DeviceSettingsTestHelper::AddObserver(Observer* observer) {}
100
101void DeviceSettingsTestHelper::RemoveObserver(Observer* observer) {}
102
103bool DeviceSettingsTestHelper::HasObserver(Observer* observer) {
104  return false;
105}
106
107void DeviceSettingsTestHelper::EmitLoginPromptVisible() {}
108
109void DeviceSettingsTestHelper::RestartJob(int pid,
110                                          const std::string& command_line) {}
111
112void DeviceSettingsTestHelper::StartSession(const std::string& user_email) {}
113
114void DeviceSettingsTestHelper::StopSession() {}
115
116void DeviceSettingsTestHelper::StartDeviceWipe() {}
117
118void DeviceSettingsTestHelper::RequestLockScreen() {}
119
120void DeviceSettingsTestHelper::NotifyLockScreenShown() {}
121
122void DeviceSettingsTestHelper::NotifyLockScreenDismissed() {}
123
124void DeviceSettingsTestHelper::RetrieveActiveSessions(
125      const ActiveSessionsCallback& callback) {}
126
127void DeviceSettingsTestHelper::RetrieveDevicePolicy(
128    const RetrievePolicyCallback& callback) {
129  device_policy_.retrieve_callbacks_.push_back(callback);
130}
131
132void DeviceSettingsTestHelper::RetrievePolicyForUser(
133    const std::string& username,
134    const RetrievePolicyCallback& callback) {
135}
136
137std::string DeviceSettingsTestHelper::BlockingRetrievePolicyForUser(
138    const std::string& username) {
139  return "";
140}
141
142void DeviceSettingsTestHelper::RetrieveDeviceLocalAccountPolicy(
143    const std::string& account_id,
144    const RetrievePolicyCallback& callback) {
145  device_local_account_policy_[account_id].retrieve_callbacks_.push_back(
146      callback);
147}
148
149void DeviceSettingsTestHelper::StoreDevicePolicy(
150    const std::string& policy_blob,
151    const StorePolicyCallback& callback) {
152  device_policy_.policy_blob_ = policy_blob;
153  device_policy_.store_callbacks_.push_back(callback);
154}
155
156void DeviceSettingsTestHelper::StorePolicyForUser(
157    const std::string& username,
158    const std::string& policy_blob,
159    const StorePolicyCallback& callback) {
160}
161
162void DeviceSettingsTestHelper::StoreDeviceLocalAccountPolicy(
163    const std::string& account_id,
164    const std::string& policy_blob,
165    const StorePolicyCallback& callback) {
166  device_local_account_policy_[account_id].policy_blob_ = policy_blob;
167  device_local_account_policy_[account_id].store_callbacks_.push_back(callback);
168}
169
170void DeviceSettingsTestHelper::SetFlagsForUser(
171    const std::string& account_id,
172    const std::vector<std::string>& flags) {}
173
174void DeviceSettingsTestHelper::GetServerBackedStateKeys(
175    const StateKeysCallback& callback) {}
176
177DeviceSettingsTestHelper::PolicyState::PolicyState()
178    : store_result_(true) {}
179
180DeviceSettingsTestHelper::PolicyState::~PolicyState() {}
181
182ScopedDeviceSettingsTestHelper::ScopedDeviceSettingsTestHelper() {
183  DeviceSettingsService::Initialize();
184  DeviceSettingsService::Get()->SetSessionManager(
185      this, new ownership::MockOwnerKeyUtil());
186  DeviceSettingsService::Get()->Load();
187  Flush();
188}
189
190ScopedDeviceSettingsTestHelper::~ScopedDeviceSettingsTestHelper() {
191  Flush();
192  DeviceSettingsService::Get()->UnsetSessionManager();
193  DeviceSettingsService::Shutdown();
194}
195
196DeviceSettingsTestBase::DeviceSettingsTestBase()
197    : user_manager_(new FakeUserManager()),
198      user_manager_enabler_(user_manager_),
199      owner_key_util_(new ownership::MockOwnerKeyUtil()) {
200  OwnerSettingsServiceChromeOSFactory::GetInstance()->SetOwnerKeyUtilForTesting(
201      owner_key_util_);
202}
203
204DeviceSettingsTestBase::~DeviceSettingsTestBase() {
205  base::RunLoop().RunUntilIdle();
206}
207
208void DeviceSettingsTestBase::SetUp() {
209  // Initialize DBusThreadManager with a stub implementation.
210  dbus_setter_ = chromeos::DBusThreadManager::GetSetterForTesting();
211
212  base::RunLoop().RunUntilIdle();
213
214  device_policy_.payload().mutable_metrics_enabled()->set_metrics_enabled(
215      false);
216  owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey());
217  device_policy_.Build();
218  device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob());
219  device_settings_service_.SetSessionManager(&device_settings_test_helper_,
220                                             owner_key_util_);
221  OwnerSettingsServiceChromeOS::SetDeviceSettingsServiceForTesting(
222      &device_settings_service_);
223  profile_.reset(new TestingProfile());
224}
225
226void DeviceSettingsTestBase::TearDown() {
227  OwnerSettingsServiceChromeOS::SetDeviceSettingsServiceForTesting(NULL);
228  FlushDeviceSettings();
229  device_settings_service_.UnsetSessionManager();
230  DBusThreadManager::Shutdown();
231}
232
233void DeviceSettingsTestBase::FlushDeviceSettings() {
234  device_settings_test_helper_.Flush();
235}
236
237void DeviceSettingsTestBase::ReloadDeviceSettings() {
238  device_settings_service_.OwnerKeySet(true);
239  FlushDeviceSettings();
240}
241
242void DeviceSettingsTestBase::InitOwner(const std::string& user_id,
243                                       bool tpm_is_ready) {
244  const user_manager::User* user = user_manager_->FindUser(user_id);
245  if (!user) {
246    user = user_manager_->AddUser(user_id);
247    profile_->set_profile_name(user_id);
248
249    ProfileHelper::Get()->SetUserToProfileMappingForTesting(user,
250                                                            profile_.get());
251  }
252  OwnerSettingsServiceChromeOS* service =
253      OwnerSettingsServiceChromeOSFactory::GetForProfile(profile_.get());
254  CHECK(service);
255  if (tpm_is_ready)
256    service->OnTPMTokenReady(true /* token is enabled */);
257}
258
259}  // namespace chromeos
260