ProfileManager doesn't depend on "--login-profile" switch.

chrome/browser/chromeos/policy/cloud_external_data_policy_observer_unittest.cc

 // Copyright 2013 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.
 
 #include "chrome/browser/chromeos/policy/cloud_external_data_policy_observer.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/policy/cloud_external_data_manager_base_test_util.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/policy/device_local_account_external_data_manager.h"
 #include "chrome/browser/chromeos/policy/device_local_account_policy_provider.h"
 #include "chrome/browser/chromeos/policy/device_local_account_policy_service.h"
 #include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
+#include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
+#include "chrome/test/base/testing_profile_manager.h"
 #include "components/policy/core/common/cloud/cloud_policy_core.h"
 #include "components/policy/core/common/cloud/cloud_policy_store.h"
 #include "components/policy/core/common/cloud/mock_cloud_external_data_manager.h"
 #include "components/policy/core/common/cloud/policy_builder.h"
 #include "components/policy/core/common/external_data_fetcher.h"
 #include "components/policy/core/common/mock_configuration_policy_provider.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/core/common/policy_service.h"
 #include "components/policy/core/common/policy_service_impl.h"
 #include "components/policy/core/common/policy_types.h"
@@ skipping 107 matching lines @@
   scoped_ptr<TestingProfile> profile_;
 
   scoped_ptr<CloudExternalDataPolicyObserver> observer_;
 
   std::vector<std::string> set_calls_;
   std::vector<std::string> cleared_calls_;
   std::vector<FetchedCall> fetched_calls_;
 
   ExternalDataFetcher::FetchCallback fetch_callback_;
 
+  TestingProfileManager profile_manager_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(CloudExternalDataPolicyObserverTest);
 };
 
 CloudExternalDataPolicyObserverTest::CloudExternalDataPolicyObserverTest()
     : device_local_account_user_id_(GenerateDeviceLocalAccountUserId(
           kDeviceLocalAccount,
           DeviceLocalAccount::TYPE_PUBLIC_SESSION)),
-      cros_settings_(&device_settings_service_) {
+      cros_settings_(&device_settings_service_),
+      profile_manager_(TestingBrowserProcess::GetGlobal()) {
 }
 
 CloudExternalDataPolicyObserverTest::~CloudExternalDataPolicyObserverTest() {
 }
 
 void CloudExternalDataPolicyObserverTest::SetUp() {
   chromeos::DeviceSettingsTestBase::SetUp();
+  ASSERT_TRUE(profile_manager_.SetUp());
   device_local_account_policy_service_.reset(
       new DeviceLocalAccountPolicyService(&device_settings_test_helper_,
                                           &device_settings_service_,
                                           &cros_settings_,
                                           base::MessageLoopProxy::current(),
                                           base::MessageLoopProxy::current(),
                                           base::MessageLoopProxy::current(),
                                           base::MessageLoopProxy::current(),
                                           NULL));
   url_fetcher_factory_.set_remove_fetcher_on_delete(true);
@@ skipping 121 matching lines @@
 }
 
 void CloudExternalDataPolicyObserverTest::RefreshDeviceLocalAccountPolicy(
     DeviceLocalAccountPolicyBroker* broker) {
   broker->core()->store()->Load();
   device_settings_test_helper_.Flush();
 }
 
 void CloudExternalDataPolicyObserverTest::LogInAsDeviceLocalAccount(
     const std::string& user_id) {
+  user_manager_->AddUser(user_id);
+
   device_local_account_policy_provider_.reset(
       new DeviceLocalAccountPolicyProvider(
           user_id,
           device_local_account_policy_service_.get(),
           scoped_ptr<PolicyMap>()));
 
   PolicyServiceImpl::Providers providers;
   providers.push_back(device_local_account_policy_provider_.get());
   TestingProfile::Builder builder;
   builder.SetPolicyService(
       scoped_ptr<PolicyService>(new PolicyServiceImpl(providers)));
+  builder.SetPath(chromeos::ProfileHelper::Get()->GetProfilePathByUserIdHash(
+      chromeos::ProfileHelper::GetUserIdHashByUserIdForTesting(user_id)));
 
   profile_ = builder.Build();
   profile_->set_profile_name(user_id);
 
-  user_manager_->AddUser(user_id);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
       content::NotificationService::AllSources(),
       content::Details<Profile>(profile_.get()));
 }
 
 void CloudExternalDataPolicyObserverTest::SetRegularUserAvatarPolicy(
     const std::string& value) {
   PolicyMap policy_map;
   if (!value.empty()) {
     policy_map.Set(
         key::kUserAvatarImage,
         POLICY_LEVEL_MANDATORY,
         POLICY_SCOPE_USER,
         new base::StringValue(value),
         external_data_manager_.CreateExternalDataFetcher(
             key::kUserAvatarImage).release());
   }
   user_policy_provider_.UpdateChromePolicy(policy_map);
 }
 
 void CloudExternalDataPolicyObserverTest::LogInAsRegularUser() {
+  user_manager_->AddUser(kRegularUserID);
+
   PolicyServiceImpl::Providers providers;
   providers.push_back(&user_policy_provider_);
   TestingProfile::Builder builder;
   builder.SetPolicyService(
       scoped_ptr<PolicyService>(new PolicyServiceImpl(providers)));
+  builder.SetPath(chromeos::ProfileHelper::Get()->GetProfilePathByUserIdHash(
+      chromeos::ProfileHelper::GetUserIdHashByUserIdForTesting(
+          kRegularUserID)));
 
   profile_ = builder.Build();
   profile_->set_profile_name(kRegularUserID);
 
-  user_manager_->AddUser(kRegularUserID);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_LOGIN_USER_PROFILE_PREPARED,
       content::NotificationService::AllSources(),
       content::Details<Profile>(profile_.get()));
 }
 
 // Verifies that when an external data reference is set for a device-local
 // account, a corresponding notification is emitted and a fetch is started.
 // Further verifies that when the fetch succeeds, a notification containing the
 // external data is emitted.
@@ skipping 560 matching lines @@
 
   EXPECT_TRUE(set_calls_.empty());
   EXPECT_TRUE(cleared_calls_.empty());
   ASSERT_EQ(1u, fetched_calls_.size());
   EXPECT_EQ(kRegularUserID, fetched_calls_.front().first);
   EXPECT_EQ(avatar_policy_2_data_, fetched_calls_.front().second);
   ClearObservations();
 }
 
 }  // namespace policy