Make CrosSettings and DeviceSettingsService non Lazy instances

chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos_unittest.cc

 // 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.
 
 #include "chrome/browser/chromeos/policy/device_cloud_policy_manager_chromeos.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_registry_simple.h"
@@ skipping 37 matching lines @@
     : public chromeos::DeviceSettingsTestBase {
  protected:
   DeviceCloudPolicyManagerChromeOSTest()
       : cryptohome_library_(chromeos::CryptohomeLibrary::GetImpl(true)),
         stub_cryptohome_client_(chromeos::CryptohomeClient::Create(
             chromeos::STUB_DBUS_CLIENT_IMPLEMENTATION, NULL)),
         install_attributes_(cryptohome_library_.get(),
                             stub_cryptohome_client_.get()),
         store_(new DeviceCloudPolicyStoreChromeOS(&device_settings_service_,
                                                   &install_attributes_)),
-        manager_(make_scoped_ptr(store_), &install_attributes_) {}
+        manager_(new DeviceCloudPolicyManagerChromeOS(make_scoped_ptr(store_),
+                                                      &install_attributes_)) {
+  }
 
   virtual void SetUp() OVERRIDE {
     DeviceSettingsTestBase::SetUp();
     chrome::RegisterLocalState(local_state_.registry());
-    manager_.Init();
+    manager_->Init();
   }
 
   virtual void TearDown() OVERRIDE {
-    manager_.Shutdown();
+    manager_->Shutdown();
+    manager_.reset();
     DeviceSettingsTestBase::TearDown();
   }
 
   scoped_ptr<chromeos::CryptohomeLibrary> cryptohome_library_;
   scoped_ptr<chromeos::CryptohomeClient> stub_cryptohome_client_;
   EnterpriseInstallAttributes install_attributes_;
 
   TestingPrefServiceSimple local_state_;
   MockDeviceManagementService device_management_service_;
 
   DeviceCloudPolicyStoreChromeOS* store_;
-  DeviceCloudPolicyManagerChromeOS manager_;
+  scoped_ptr<DeviceCloudPolicyManagerChromeOS> manager_;

[Mattias Nissler (ping if slow), 2013/04/17 13:10:30]

Any reason this still needs to be wrapped in a scoped_ptr? If not, please revert
to a regular class member.

[stevenjb, 2013/04/17 16:27:12]

With the changes to DeviceSettingsTestBase I can revert these too. Done.

 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeviceCloudPolicyManagerChromeOSTest);
 };
 
 TEST_F(DeviceCloudPolicyManagerChromeOSTest, FreshDevice) {
   owner_key_util_->Clear();
   FlushDeviceSettings();
-  EXPECT_TRUE(manager_.IsInitializationComplete(POLICY_DOMAIN_CHROME));
+  EXPECT_TRUE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
 
-  manager_.Connect(&local_state_, &device_management_service_,
-                   scoped_ptr<CloudPolicyClient::StatusProvider>(NULL));
+  manager_->Connect(&local_state_, &device_management_service_,
+                    scoped_ptr<CloudPolicyClient::StatusProvider>(NULL));
 
   PolicyBundle bundle;
-  EXPECT_TRUE(manager_.policies().Equals(bundle));
+  EXPECT_TRUE(manager_->policies().Equals(bundle));
 }
 
 TEST_F(DeviceCloudPolicyManagerChromeOSTest, EnrolledDevice) {
   base::RunLoop loop;
   EnterpriseInstallAttributes::LockResult result;
   install_attributes_.LockDevice(PolicyBuilder::kFakeUsername,
                                  DEVICE_MODE_ENTERPRISE,
                                  PolicyBuilder::kFakeDeviceId,
                                  base::Bind(&CopyLockResult, &loop, &result));
   loop.Run();
   ASSERT_EQ(EnterpriseInstallAttributes::LOCK_SUCCESS, result);
 
   FlushDeviceSettings();
   EXPECT_EQ(CloudPolicyStore::STATUS_OK, store_->status());
-  EXPECT_TRUE(manager_.IsInitializationComplete(POLICY_DOMAIN_CHROME));
+  EXPECT_TRUE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
 
   PolicyBundle bundle;
   bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
       .Set(key::kDeviceMetricsReportingEnabled,
            POLICY_LEVEL_MANDATORY,
            POLICY_SCOPE_MACHINE,
            Value::CreateBooleanValue(false));
-  EXPECT_TRUE(manager_.policies().Equals(bundle));
+  EXPECT_TRUE(manager_->policies().Equals(bundle));
 
-  manager_.Connect(&local_state_, &device_management_service_,
-                   scoped_ptr<CloudPolicyClient::StatusProvider>(NULL));
-  EXPECT_TRUE(manager_.policies().Equals(bundle));
+  manager_->Connect(&local_state_, &device_management_service_,
+                    scoped_ptr<CloudPolicyClient::StatusProvider>(NULL));
+  EXPECT_TRUE(manager_->policies().Equals(bundle));
 
-  manager_.Shutdown();
-  EXPECT_TRUE(manager_.policies().Equals(bundle));
+  manager_->Shutdown();
+  EXPECT_TRUE(manager_->policies().Equals(bundle));
 }
 
 TEST_F(DeviceCloudPolicyManagerChromeOSTest, ConsumerDevice) {
   FlushDeviceSettings();
   EXPECT_EQ(CloudPolicyStore::STATUS_BAD_STATE, store_->status());
-  EXPECT_TRUE(manager_.IsInitializationComplete(POLICY_DOMAIN_CHROME));
+  EXPECT_TRUE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
 
   PolicyBundle bundle;
-  EXPECT_TRUE(manager_.policies().Equals(bundle));
+  EXPECT_TRUE(manager_->policies().Equals(bundle));
 
-  manager_.Connect(&local_state_, &device_management_service_,
-                   scoped_ptr<CloudPolicyClient::StatusProvider>(NULL));
-  EXPECT_TRUE(manager_.policies().Equals(bundle));
+  manager_->Connect(&local_state_, &device_management_service_,
+                    scoped_ptr<CloudPolicyClient::StatusProvider>(NULL));
+  EXPECT_TRUE(manager_->policies().Equals(bundle));
 
-  manager_.Shutdown();
-  EXPECT_TRUE(manager_.policies().Equals(bundle));
+  manager_->Shutdown();
+  EXPECT_TRUE(manager_->policies().Equals(bundle));
 }
 
 class DeviceCloudPolicyManagerChromeOSEnrollmentTest
     : public DeviceCloudPolicyManagerChromeOSTest {
  public:
   void Done(EnrollmentStatus status) {
     status_ = status;
     done_ = true;
   }
 
@@ skipping 19 matching lines @@
 
     register_response_.mutable_register_response()->set_device_management_token(
         PolicyBuilder::kFakeToken);
     fetch_response_.mutable_policy_response()->add_response()->CopyFrom(
         device_policy_.policy());
     loaded_blob_ = device_policy_.GetBlob();
 
     // Initialize the manager.
     FlushDeviceSettings();
     EXPECT_EQ(CloudPolicyStore::STATUS_BAD_STATE, store_->status());
-    EXPECT_TRUE(manager_.IsInitializationComplete(POLICY_DOMAIN_CHROME));
+    EXPECT_TRUE(manager_->IsInitializationComplete(POLICY_DOMAIN_CHROME));
 
     PolicyBundle bundle;
-    EXPECT_TRUE(manager_.policies().Equals(bundle));
+    EXPECT_TRUE(manager_->policies().Equals(bundle));
 
-    manager_.Connect(&local_state_, &device_management_service_,
-                     scoped_ptr<CloudPolicyClient::StatusProvider>(NULL));
+    manager_->Connect(&local_state_, &device_management_service_,
+                      scoped_ptr<CloudPolicyClient::StatusProvider>(NULL));
   }
 
   void ExpectFailedEnrollment(EnrollmentStatus::Status status) {
     EXPECT_EQ(status, status_.status());
     EXPECT_FALSE(store_->is_managed());
     PolicyBundle empty_bundle;
-    EXPECT_TRUE(manager_.policies().Equals(empty_bundle));
+    EXPECT_TRUE(manager_->policies().Equals(empty_bundle));
   }
 
   void ExpectSuccessfulEnrollment() {
     EXPECT_EQ(EnrollmentStatus::STATUS_SUCCESS, status_.status());
     EXPECT_EQ(DEVICE_MODE_ENTERPRISE, install_attributes_.GetMode());
     EXPECT_TRUE(store_->has_policy());
     EXPECT_TRUE(store_->is_managed());
-    ASSERT_TRUE(manager_.core()->client());
-    EXPECT_TRUE(manager_.core()->client()->is_registered());
+    ASSERT_TRUE(manager_->core()->client());
+    EXPECT_TRUE(manager_->core()->client()->is_registered());
 
     PolicyBundle bundle;
     bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
         .Set(key::kDeviceMetricsReportingEnabled,
              POLICY_LEVEL_MANDATORY,
              POLICY_SCOPE_MACHINE,
              Value::CreateBooleanValue(false));
-    EXPECT_TRUE(manager_.policies().Equals(bundle));
+    EXPECT_TRUE(manager_->policies().Equals(bundle));
   }
 
   void RunTest() {
     // Trigger enrollment.
     MockDeviceManagementJob* register_job = NULL;
     EXPECT_CALL(device_management_service_,
                 CreateJob(DeviceManagementRequestJob::TYPE_REGISTRATION))
         .Times(AtMost(1))
         .WillOnce(device_management_service_.CreateAsyncJob(&register_job));
     EXPECT_CALL(device_management_service_, StartJob(_, _, _, _, _, _, _))
         .Times(AtMost(1))
         .WillOnce(DoAll(SaveArg<5>(&client_id_),
                         SaveArg<6>(&register_request_)));
     DeviceCloudPolicyManagerChromeOS::AllowedDeviceModes modes;
     modes[DEVICE_MODE_ENTERPRISE] = true;
-    manager_.StartEnrollment(
+    manager_->StartEnrollment(
         "auth token", is_auto_enrollment_, modes,
         base::Bind(&DeviceCloudPolicyManagerChromeOSEnrollmentTest::Done,
                    base::Unretained(this)));
     Mock::VerifyAndClearExpectations(&device_management_service_);
 
     if (done_)
       return;
 
     // Process registration.
     ASSERT_TRUE(register_job);
@@ skipping 124 matching lines @@
 TEST_F(DeviceCloudPolicyManagerChromeOSEnrollmentTest, LoadError) {
   loaded_blob_.clear();
   RunTest();
   ExpectFailedEnrollment(EnrollmentStatus::STATUS_STORE_ERROR);
   EXPECT_EQ(CloudPolicyStore::STATUS_LOAD_ERROR,
             status_.store_status());
 }
 
 }  // namespace
 }  // namespace policy