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.h" 11 #include "chrome/browser/chromeos/ownership/owner_settings_service_factory.h" 12 #include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h" 13 #include "chrome/browser/chromeos/settings/device_settings_service.h" 14 #include "chrome/browser/chromeos/settings/mock_owner_key_util.h" 15 #include "chrome/test/base/testing_profile.h" 16 #include "chromeos/dbus/dbus_thread_manager.h" 17 #include "chromeos/dbus/fake_dbus_thread_manager.h" 18 #include "chromeos/network/network_handler.h" 19 #include "content/public/browser/browser_thread.h" 20 21 namespace chromeos { 22 23 DeviceSettingsTestHelper::DeviceSettingsTestHelper() {} 24 25 DeviceSettingsTestHelper::~DeviceSettingsTestHelper() {} 26 27 void DeviceSettingsTestHelper::FlushLoops() { 28 // DeviceSettingsService may trigger operations that hop back and forth 29 // between the message loop and the blocking pool. 2 iterations are currently 30 // sufficient (key loading, signing). 31 for (int i = 0; i < 2; ++i) { 32 base::MessageLoop::current()->RunUntilIdle(); 33 content::BrowserThread::GetBlockingPool()->FlushForTesting(); 34 } 35 base::MessageLoop::current()->RunUntilIdle(); 36 } 37 38 void DeviceSettingsTestHelper::FlushStore() { 39 std::vector<StorePolicyCallback> callbacks; 40 callbacks.swap(device_policy_.store_callbacks_); 41 for (std::vector<StorePolicyCallback>::iterator cb(callbacks.begin()); 42 cb != callbacks.end(); ++cb) { 43 cb->Run(device_policy_.store_result_); 44 } 45 46 std::map<std::string, PolicyState>::iterator device_local_account_state; 47 for (device_local_account_state = device_local_account_policy_.begin(); 48 device_local_account_state != device_local_account_policy_.end(); 49 ++device_local_account_state) { 50 callbacks.swap(device_local_account_state->second.store_callbacks_); 51 for (std::vector<StorePolicyCallback>::iterator cb(callbacks.begin()); 52 cb != callbacks.end(); ++cb) { 53 cb->Run(device_local_account_state->second.store_result_); 54 } 55 } 56 } 57 58 void DeviceSettingsTestHelper::FlushRetrieve() { 59 std::vector<RetrievePolicyCallback> callbacks; 60 callbacks.swap(device_policy_.retrieve_callbacks_); 61 for (std::vector<RetrievePolicyCallback>::iterator cb(callbacks.begin()); 62 cb != callbacks.end(); ++cb) { 63 cb->Run(device_policy_.policy_blob_); 64 } 65 66 std::map<std::string, PolicyState>::iterator device_local_account_state; 67 for (device_local_account_state = device_local_account_policy_.begin(); 68 device_local_account_state != device_local_account_policy_.end(); 69 ++device_local_account_state) { 70 std::vector<RetrievePolicyCallback> callbacks; 71 callbacks.swap(device_local_account_state->second.retrieve_callbacks_); 72 for (std::vector<RetrievePolicyCallback>::iterator cb(callbacks.begin()); 73 cb != callbacks.end(); ++cb) { 74 cb->Run(device_local_account_state->second.policy_blob_); 75 } 76 } 77 } 78 79 void DeviceSettingsTestHelper::Flush() { 80 do { 81 FlushLoops(); 82 FlushStore(); 83 FlushLoops(); 84 FlushRetrieve(); 85 FlushLoops(); 86 } while (HasPendingOperations()); 87 } 88 89 bool DeviceSettingsTestHelper::HasPendingOperations() const { 90 if (device_policy_.HasPendingOperations()) 91 return true; 92 93 std::map<std::string, PolicyState>::const_iterator device_local_account_state; 94 for (device_local_account_state = device_local_account_policy_.begin(); 95 device_local_account_state != device_local_account_policy_.end(); 96 ++device_local_account_state) { 97 if (device_local_account_state->second.HasPendingOperations()) 98 return true; 99 } 100 101 return false; 102 } 103 104 void DeviceSettingsTestHelper::Init(dbus::Bus* bus) {} 105 106 void DeviceSettingsTestHelper::SetStubDelegate( 107 SessionManagerClient::StubDelegate* delegate) {} 108 109 void DeviceSettingsTestHelper::AddObserver(Observer* observer) {} 110 111 void DeviceSettingsTestHelper::RemoveObserver(Observer* observer) {} 112 113 bool DeviceSettingsTestHelper::HasObserver(Observer* observer) { 114 return false; 115 } 116 117 void DeviceSettingsTestHelper::EmitLoginPromptVisible() {} 118 119 void DeviceSettingsTestHelper::RestartJob(int pid, 120 const std::string& command_line) {} 121 122 void DeviceSettingsTestHelper::StartSession(const std::string& user_email) {} 123 124 void DeviceSettingsTestHelper::StopSession() {} 125 126 void DeviceSettingsTestHelper::StartDeviceWipe() {} 127 128 void DeviceSettingsTestHelper::RequestLockScreen() {} 129 130 void DeviceSettingsTestHelper::NotifyLockScreenShown() {} 131 132 void DeviceSettingsTestHelper::NotifyLockScreenDismissed() {} 133 134 void DeviceSettingsTestHelper::RetrieveActiveSessions( 135 const ActiveSessionsCallback& callback) {} 136 137 void DeviceSettingsTestHelper::RetrieveDevicePolicy( 138 const RetrievePolicyCallback& callback) { 139 device_policy_.retrieve_callbacks_.push_back(callback); 140 } 141 142 void DeviceSettingsTestHelper::RetrievePolicyForUser( 143 const std::string& username, 144 const RetrievePolicyCallback& callback) { 145 } 146 147 std::string DeviceSettingsTestHelper::BlockingRetrievePolicyForUser( 148 const std::string& username) { 149 return ""; 150 } 151 152 void DeviceSettingsTestHelper::RetrieveDeviceLocalAccountPolicy( 153 const std::string& account_id, 154 const RetrievePolicyCallback& callback) { 155 device_local_account_policy_[account_id].retrieve_callbacks_.push_back( 156 callback); 157 } 158 159 void DeviceSettingsTestHelper::StoreDevicePolicy( 160 const std::string& policy_blob, 161 const StorePolicyCallback& callback) { 162 device_policy_.policy_blob_ = policy_blob; 163 device_policy_.store_callbacks_.push_back(callback); 164 } 165 166 void DeviceSettingsTestHelper::StorePolicyForUser( 167 const std::string& username, 168 const std::string& policy_blob, 169 const StorePolicyCallback& callback) { 170 } 171 172 void DeviceSettingsTestHelper::StoreDeviceLocalAccountPolicy( 173 const std::string& account_id, 174 const std::string& policy_blob, 175 const StorePolicyCallback& callback) { 176 device_local_account_policy_[account_id].policy_blob_ = policy_blob; 177 device_local_account_policy_[account_id].store_callbacks_.push_back(callback); 178 } 179 180 void DeviceSettingsTestHelper::SetFlagsForUser( 181 const std::string& account_id, 182 const std::vector<std::string>& flags) {} 183 184 void DeviceSettingsTestHelper::GetServerBackedStateKeys( 185 const StateKeysCallback& callback) {} 186 187 DeviceSettingsTestHelper::PolicyState::PolicyState() 188 : store_result_(true) {} 189 190 DeviceSettingsTestHelper::PolicyState::~PolicyState() {} 191 192 ScopedDeviceSettingsTestHelper::ScopedDeviceSettingsTestHelper() { 193 DeviceSettingsService::Initialize(); 194 DeviceSettingsService::Get()->SetSessionManager(this, new MockOwnerKeyUtil()); 195 DeviceSettingsService::Get()->Load(); 196 Flush(); 197 } 198 199 ScopedDeviceSettingsTestHelper::~ScopedDeviceSettingsTestHelper() { 200 Flush(); 201 DeviceSettingsService::Get()->UnsetSessionManager(); 202 DeviceSettingsService::Shutdown(); 203 } 204 205 DeviceSettingsTestBase::DeviceSettingsTestBase() 206 : user_manager_(new FakeUserManager()), 207 user_manager_enabler_(user_manager_), 208 owner_key_util_(new MockOwnerKeyUtil()), 209 fake_dbus_thread_manager_(new FakeDBusThreadManager()) { 210 fake_dbus_thread_manager_->SetFakeClients(); 211 } 212 213 DeviceSettingsTestBase::~DeviceSettingsTestBase() { 214 base::RunLoop().RunUntilIdle(); 215 } 216 217 void DeviceSettingsTestBase::SetUp() { 218 // Initialize DBusThreadManager with a stub implementation. 219 chromeos::DBusThreadManager::InitializeForTesting(fake_dbus_thread_manager_); 220 221 NetworkHandler::Initialize(); 222 base::RunLoop().RunUntilIdle(); 223 224 device_policy_.payload().mutable_metrics_enabled()->set_metrics_enabled( 225 false); 226 owner_key_util_->SetPublicKeyFromPrivateKey(*device_policy_.GetSigningKey()); 227 device_policy_.Build(); 228 device_settings_test_helper_.set_policy_blob(device_policy_.GetBlob()); 229 device_settings_service_.SetSessionManager(&device_settings_test_helper_, 230 owner_key_util_); 231 OwnerSettingsService::SetOwnerKeyUtilForTesting(owner_key_util_.get()); 232 OwnerSettingsService::SetDeviceSettingsServiceForTesting( 233 &device_settings_service_); 234 profile_.reset(new TestingProfile()); 235 } 236 237 void DeviceSettingsTestBase::TearDown() { 238 OwnerSettingsService::SetOwnerKeyUtilForTesting(NULL); 239 OwnerSettingsService::SetDeviceSettingsServiceForTesting(NULL); 240 FlushDeviceSettings(); 241 device_settings_service_.UnsetSessionManager(); 242 NetworkHandler::Shutdown(); 243 DBusThreadManager::Shutdown(); 244 } 245 246 void DeviceSettingsTestBase::FlushDeviceSettings() { 247 device_settings_test_helper_.Flush(); 248 } 249 250 void DeviceSettingsTestBase::ReloadDeviceSettings() { 251 device_settings_service_.OwnerKeySet(true); 252 FlushDeviceSettings(); 253 } 254 255 void DeviceSettingsTestBase::InitOwner(const std::string& user_id, 256 bool tpm_is_ready) { 257 const User* user = user_manager_->FindUser(user_id); 258 if (!user) { 259 user = user_manager_->AddUser(user_id); 260 profile_->set_profile_name(user_id); 261 user_manager_->SetProfileForUser(user, profile_.get()); 262 } 263 OwnerSettingsService* service = 264 OwnerSettingsServiceFactory::GetForProfile(profile_.get()); 265 CHECK(service); 266 if (tpm_is_ready) 267 service->OnTPMTokenReady(); 268 OwnerSettingsServiceFactory::GetInstance()->SetUsername(user_id); 269 } 270 271 } // namespace chromeos 272