Set ENABLE_MANAGED_USERS #ifdef on Android.

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/prefs/scoped_user_pref_update.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_service_unittest.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/managed_mode/custodian_profile_downloader_service.h"
 #include "chrome/browser/managed_mode/custodian_profile_downloader_service_factory.h"
 #include "chrome/browser/managed_mode/managed_user_service.h"
 #include "chrome/browser/managed_mode/managed_user_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/signin/fake_profile_oauth2_token_service.h"
+#include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/features/feature_channel.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/common/extension_builder.h"
 #include "extensions/common/manifest_constants.h"
@@ skipping 33 matching lines @@
   void Reset() {
     message_loop_runner_ = new MessageLoopRunner;
   }
 
   ManagedModeURLFilter* url_filter_;
   scoped_refptr<MessageLoopRunner> message_loop_runner_;
 };
 
 class ManagedUserServiceTest : public ::testing::Test {
  public:
-  ManagedUserServiceTest() {
-    managed_user_service_ = ManagedUserServiceFactory::GetForProfile(&profile_);
+  ManagedUserServiceTest() {}
+
+  virtual void SetUp() OVERRIDE {
+    TestingProfile::Builder builder;
+    builder.AddTestingFactory(ProfileOAuth2TokenServiceFactory::GetInstance(),
+                              FakeProfileOAuth2TokenService::Build);
+    profile_ = builder.Build();
+    managed_user_service_ =
+        ManagedUserServiceFactory::GetForProfile(profile_.get());
+  }
+
+  virtual void TearDown() OVERRIDE {
+    profile_.reset();
   }
 
   virtual ~ManagedUserServiceTest() {}
 
  protected:
   content::TestBrowserThreadBundle thread_bundle_;
-  TestingProfile profile_;
+  scoped_ptr<TestingProfile> profile_;
   ManagedUserService* managed_user_service_;
 };
 
 }  // namespace
 
 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(),
+    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));
   EXPECT_EQ(ManagedUserService::MANUAL_BLOCK,
             managed_user_service_->GetManualBehaviorForURL(kExampleBarURL));
   EXPECT_EQ(ManagedUserService::MANUAL_ALLOW,
             managed_user_service_->GetManualBehaviorForURL(
                 kExampleFooNoWWWURL));
   EXPECT_EQ(ManagedUserService::MANUAL_ALLOW,
             managed_user_service_->GetManualBehaviorForURL(kBlurpURL));
   EXPECT_EQ(ManagedUserService::MANUAL_NONE,
             managed_user_service_->GetManualBehaviorForURL(kMooseURL));
   std::vector<GURL> 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(),
+    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));
   EXPECT_EQ(ManagedUserService::MANUAL_NONE,
             managed_user_service_->GetManualBehaviorForURL(kExampleBarURL));
   EXPECT_EQ(ManagedUserService::MANUAL_ALLOW,
             managed_user_service_->GetManualBehaviorForURL(
                 kExampleFooNoWWWURL));
   EXPECT_EQ(ManagedUserService::MANUAL_ALLOW,
             managed_user_service_->GetManualBehaviorForURL(kBlurpURL));
   EXPECT_EQ(ManagedUserService::MANUAL_NONE,
             managed_user_service_->GetManualBehaviorForURL(kMooseURL));
 }
 
 // Ensure that the CustodianProfileDownloaderService shuts down cleanly. If no
 // DCHECK is hit when the service is destroyed, this test passed.
 TEST_F(ManagedUserServiceTest, ShutDownCustodianProfileDownloader) {
   CustodianProfileDownloaderService* downloader_service =
-      CustodianProfileDownloaderServiceFactory::GetForProfile(
-          &profile_);
+      CustodianProfileDownloaderServiceFactory::GetForProfile(profile_.get());
 
   // Emulate being logged in, then start to download a profile so a
   // ProfileDownloader gets created.
-  profile_.GetPrefs()->SetString(prefs::kGoogleServicesUsername, "Logged In");
+  profile_->GetPrefs()->SetString(prefs::kGoogleServicesUsername, "Logged In");
   downloader_service->DownloadProfile(base::Bind(&OnProfileDownloadedFail));
 }
 
+#if !defined(OS_ANDROID)
 class ManagedUserServiceExtensionTestBase : public ExtensionServiceTestBase {
  public:
   explicit ManagedUserServiceExtensionTestBase(bool is_managed)
       : is_managed_(is_managed),
         channel_(chrome::VersionInfo::CHANNEL_DEV) {}
   virtual ~ManagedUserServiceExtensionTestBase() {}
 
   virtual void SetUp() OVERRIDE {
     ExtensionServiceTestBase::SetUp();
     ExtensionServiceTestBase::ExtensionServiceInitParams params =
@@ skipping 212 matching lines @@
   sites.clear();
   site_lists[0]->GetSites(&sites);
   ASSERT_EQ(1u, sites.size());
   EXPECT_EQ(ASCIIToUTF16("Moose"), sites[0].name);
 
   EXPECT_EQ(ManagedModeURLFilter::WARN,
             url_filter->GetFilteringBehaviorForURL(example_url));
   EXPECT_EQ(ManagedModeURLFilter::ALLOW,
             url_filter->GetFilteringBehaviorForURL(moose_url));
 }
+#endif  // !defined(OS_ANDROID)