Update ManagedUserService tests to create the service using ManagedUserServiceFactory

chrome/browser/managed_mode/managed_user_service_unittest.cc

 // Copyright (c) 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 "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_service_unittest.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/managed_mode/managed_user_service.h"
@@ skipping 40 matching lines @@
     message_loop_runner_ = new MessageLoopRunner;
   }
 
   ManagedModeURLFilter* url_filter_;
   scoped_refptr<MessageLoopRunner> message_loop_runner_;
 };
 
 class ManagedUserServiceTest : public ::testing::Test {
  public:
   ManagedUserServiceTest() : ui_thread_(content::BrowserThread::UI,
-                                        &message_loop_),
-                             managed_user_service_(&profile_) {}
+                                        &message_loop_) {
+    managed_user_service_ = ManagedUserServiceFactory::GetForProfile(&profile_);
+  }
+
   virtual ~ManagedUserServiceTest() {}
 
  protected:
   base::MessageLoop message_loop_;
   content::TestBrowserThread ui_thread_;
   TestingProfile profile_;
-  ManagedUserService managed_user_service_;
+  ManagedUserService* managed_user_service_;
 };
 
 }  // namespace
 
 TEST_F(ManagedUserServiceTest, ExtensionManagementPolicyProviderUnmanaged) {
-  EXPECT_FALSE(managed_user_service_.ProfileIsManaged());
+  EXPECT_FALSE(managed_user_service_->ProfileIsManaged());
 
   string16 error_1;
-  EXPECT_TRUE(managed_user_service_.UserMayLoad(NULL, &error_1));
+  EXPECT_TRUE(managed_user_service_->UserMayLoad(NULL, &error_1));
   EXPECT_EQ(string16(), error_1);
 
   string16 error_2;
-  EXPECT_TRUE(managed_user_service_.UserMayModifySettings(NULL, &error_2));
+  EXPECT_TRUE(managed_user_service_->UserMayModifySettings(NULL, &error_2));
   EXPECT_EQ(string16(), error_2);
 }
 
 TEST_F(ManagedUserServiceTest, ExtensionManagementPolicyProviderManaged) {
   ManagedModeURLFilterObserver observer(
-      managed_user_service_.GetURLFilterForUIThread());
-  managed_user_service_.InitForTesting();
-  EXPECT_TRUE(managed_user_service_.ProfileIsManaged());
+      managed_user_service_->GetURLFilterForUIThread());
+  managed_user_service_->InitForTesting();
+  EXPECT_TRUE(managed_user_service_->ProfileIsManaged());
 
   string16 error_1;
-  EXPECT_FALSE(managed_user_service_.UserMayLoad(NULL, &error_1));
+  EXPECT_FALSE(managed_user_service_->UserMayLoad(NULL, &error_1));
   EXPECT_FALSE(error_1.empty());
 
   string16 error_2;
-  EXPECT_FALSE(managed_user_service_.UserMayModifySettings(NULL, &error_2));
+  EXPECT_FALSE(managed_user_service_->UserMayModifySettings(NULL, &error_2));
   EXPECT_FALSE(error_2.empty());
 
 #ifndef NDEBUG
-  EXPECT_FALSE(managed_user_service_.GetDebugPolicyProviderName().empty());
+  EXPECT_FALSE(managed_user_service_->GetDebugPolicyProviderName().empty());
 #endif
   // Wait for the initial update to finish (otherwise we'll get leaks).
   observer.Wait();
 }
 
 TEST_F(ManagedUserServiceTest, GetManualExceptionsForHost) {
   GURL kExampleFooURL("http://www.example.com/foo");
   GURL kExampleBarURL("http://www.example.com/bar");
   GURL kExampleFooNoWWWURL("http://example.com/foo");
   GURL kBlurpURL("http://blurp.net/bla");
   GURL kMooseURL("http://moose.org/baz");
   {
     DictionaryPrefUpdate update(profile_.GetPrefs(),
                                 prefs::kManagedModeManualURLs);
     base::DictionaryValue* dict = update.Get();
     dict->SetBooleanWithoutPathExpansion(kExampleFooURL.spec(), true);
     dict->SetBooleanWithoutPathExpansion(kExampleBarURL.spec(), false);
     dict->SetBooleanWithoutPathExpansion(kExampleFooNoWWWURL.spec(), true);
     dict->SetBooleanWithoutPathExpansion(kBlurpURL.spec(), true);
   }
 
   EXPECT_EQ(ManagedUserService::MANUAL_ALLOW,
-            managed_user_service_.GetManualBehaviorForURL(kExampleFooURL));
+            managed_user_service_->GetManualBehaviorForURL(kExampleFooURL));
   EXPECT_EQ(ManagedUserService::MANUAL_BLOCK,
-            managed_user_service_.GetManualBehaviorForURL(kExampleBarURL));
+            managed_user_service_->GetManualBehaviorForURL(kExampleBarURL));
   EXPECT_EQ(ManagedUserService::MANUAL_ALLOW,
-            managed_user_service_.GetManualBehaviorForURL(kExampleFooNoWWWURL));
+            managed_user_service_->GetManualBehaviorForURL(
+                kExampleFooNoWWWURL));
   EXPECT_EQ(ManagedUserService::MANUAL_ALLOW,
-            managed_user_service_.GetManualBehaviorForURL(kBlurpURL));
+            managed_user_service_->GetManualBehaviorForURL(kBlurpURL));
   EXPECT_EQ(ManagedUserService::MANUAL_NONE,
-            managed_user_service_.GetManualBehaviorForURL(kMooseURL));
+            managed_user_service_->GetManualBehaviorForURL(kMooseURL));
   std::vector<GURL> exceptions;
-  managed_user_service_.GetManualExceptionsForHost("www.example.com",
-                                                   &exceptions);
+  managed_user_service_->GetManualExceptionsForHost("www.example.com",
+                                                    &exceptions);
   ASSERT_EQ(2u, exceptions.size());
   EXPECT_EQ(kExampleBarURL, exceptions[0]);
   EXPECT_EQ(kExampleFooURL, exceptions[1]);
 
   {
     DictionaryPrefUpdate update(profile_.GetPrefs(),
                                 prefs::kManagedModeManualURLs);
     base::DictionaryValue* dict = update.Get();
     for (std::vector<GURL>::iterator it = exceptions.begin();
          it != exceptions.end(); ++it) {
       dict->RemoveWithoutPathExpansion(it->spec(), NULL);
     }
   }
 
   EXPECT_EQ(ManagedUserService::MANUAL_NONE,
-            managed_user_service_.GetManualBehaviorForURL(kExampleFooURL));
+            managed_user_service_->GetManualBehaviorForURL(kExampleFooURL));
   EXPECT_EQ(ManagedUserService::MANUAL_NONE,
-            managed_user_service_.GetManualBehaviorForURL(kExampleBarURL));
+            managed_user_service_->GetManualBehaviorForURL(kExampleBarURL));
   EXPECT_EQ(ManagedUserService::MANUAL_ALLOW,
-            managed_user_service_.GetManualBehaviorForURL(kExampleFooNoWWWURL));
+            managed_user_service_->GetManualBehaviorForURL(
+                kExampleFooNoWWWURL));
   EXPECT_EQ(ManagedUserService::MANUAL_ALLOW,
-            managed_user_service_.GetManualBehaviorForURL(kBlurpURL));
+            managed_user_service_->GetManualBehaviorForURL(kBlurpURL));
   EXPECT_EQ(ManagedUserService::MANUAL_NONE,
-            managed_user_service_.GetManualBehaviorForURL(kMooseURL));
+            managed_user_service_->GetManualBehaviorForURL(kMooseURL));
 }
 
 class ManagedUserServiceExtensionTest : public ExtensionServiceTestBase {
  public:
   ManagedUserServiceExtensionTest() {}
   virtual ~ManagedUserServiceExtensionTest() {}
 
   virtual void SetUp() OVERRIDE {
     ExtensionServiceTestBase::SetUp();
     InitializeEmptyExtensionService();
   }
 
   virtual void TearDown() OVERRIDE {
     ExtensionServiceTestBase::TearDown();
   }
 
  protected:
   ScopedVector<ManagedModeSiteList> GetActiveSiteLists(
       ManagedUserService* managed_user_service) {
     return managed_user_service->GetActiveSiteLists();
   }
 };
 
 TEST_F(ManagedUserServiceExtensionTest, NoContentPacks) {
-  ManagedUserService managed_user_service(profile_.get());
-  managed_user_service.Init();
+  ManagedUserService* managed_user_service =
+      ManagedUserServiceFactory::GetForProfile(profile_.get());
+  managed_user_service->Init();
   ManagedModeURLFilter* url_filter =
-      managed_user_service.GetURLFilterForUIThread();
+      managed_user_service->GetURLFilterForUIThread();
 
   GURL url("http://youtube.com");
   ScopedVector<ManagedModeSiteList> site_lists =
-      GetActiveSiteLists(&managed_user_service);
+      GetActiveSiteLists(managed_user_service);
   ASSERT_EQ(0u, site_lists.size());
   EXPECT_EQ(ManagedModeURLFilter::ALLOW,
             url_filter->GetFilteringBehaviorForURL(url));
 }
 
 #if !defined(OS_CHROMEOS)
 TEST_F(ManagedUserServiceExtensionTest, InstallContentPacks) {
   ManagedUserService* managed_user_service =
       ManagedUserServiceFactory::GetForProfile(profile_.get());
   managed_user_service->InitForTesting();
@@ skipping 101 matching lines @@
 
   EXPECT_EQ(ManagedModeURLFilter::WARN,
             url_filter->GetFilteringBehaviorForURL(example_url));
 #if defined(ENABLE_CONFIGURATION_POLICY)
   EXPECT_EQ(ManagedModeURLFilter::ALLOW,
             url_filter->GetFilteringBehaviorForURL(moose_url));
 #endif
 }
 
 #endif  // OS_CHROMEOS