MD User Manager: Supervised user logic should be inside ENABLE_SUPERVISED_USERS flag

chrome/browser/ui/webui/signin/signin_create_profile_handler_unittest.cc

 // Copyright 2016 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/ui/webui/signin/signin_create_profile_handler.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/prefs/browser_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_attributes_entry.h"
 #include "chrome/browser/profiles/profile_attributes_storage.h"
 #include "chrome/browser/profiles/profile_avatar_icon_util.h"
 #include "chrome/browser/signin/fake_signin_manager_builder.h"
 #include "chrome/browser/signin/signin_error_controller_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
-#include "chrome/browser/supervised_user/legacy/supervised_user_sync_service.h"
-#include "chrome/browser/supervised_user/legacy/supervised_user_sync_service_factory.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/test/base/browser_with_test_window_test.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "components/signin/core/browser/fake_auth_status_provider.h"
 #include "components/syncable_prefs/testing_pref_service_syncable.h"
 #include "content/public/test/test_web_ui.h"
 #include "sync/api/fake_sync_change_processor.h"
 #include "sync/api/sync_data.h"
 #include "sync/api/sync_error_factory_mock.h"
 #include "sync/internal_api/public/attachments/attachment_service_proxy_for_test.h"
 #include "sync/protocol/sync.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
+#if defined(ENABLE_SUPERVISED_USERS)
+#include "chrome/browser/supervised_user/legacy/supervised_user_sync_service.h"
+#include "chrome/browser/supervised_user/legacy/supervised_user_sync_service_factory.h"
+#endif
+
 // Gmock matchers and actions.
 using testing::_;
 using testing::Invoke;
 
 namespace {
 
 const char kTestProfileName[] = "test-profile-name";
 
 const char kTestGaiaId1[] = "test-gaia-id-1";
 const char kTestEmail1[] = "foo1@bar.com";
 
 const char kTestGaiaId2[] = "test-gaia-id-2";
 const char kTestEmail2[] = "foo2@bar.com";
 
 const char kTestWebUIResponse[] = "cr.webUIListenerCallback";
 
+#if defined(ENABLE_SUPERVISED_USERS)
 const char kSupervisedUserId1[] = "test-supervised-id-1";
 const char kSupervisedUserId2[] = "test-supervised-id-2";
 
 const char kSupervisedUsername1[] = "test-supervised-username-1";
 const char kSupervisedUsername2[] = "test-supervised-username-2";
 
 const char kSupervisedUserAvatarName1[] = "chrome-avatar-index:0";
 const char kSupervisedUserAvatarName2[] = "chrome-avatar-index:1";
 
 syncer::SyncData CreateSyncData(const std::string& id,
                                 const std::string& name,
                                 const std::string& chrome_avatar) {
   sync_pb::EntitySpecifics specifics;
   specifics.mutable_managed_user()->set_id(id);
   specifics.mutable_managed_user()->set_name(name);
   specifics.mutable_managed_user()->set_acknowledged(true);
   specifics.mutable_managed_user()->set_chrome_avatar(chrome_avatar);
 
   return syncer::SyncData::CreateRemoteData(
       1,
       specifics,
       base::Time(),
       syncer::AttachmentIdList(),
       syncer::AttachmentServiceProxyForTest::Create());
 }
+#endif
 
 }  // namespace
 
 class TestSigninCreateProfileHandler : public SigninCreateProfileHandler {
  public:
   explicit TestSigninCreateProfileHandler(
       content::WebUI* web_ui,
       TestingProfileManager* profile_manager)
           : profile_manager_(profile_manager) {
     set_web_ui(web_ui);
@@ skipping 42 matching lines @@
                void(Profile* profile, Profile::CreateStatus status));
 
   // We don't actually need to register supervised users in the test. Mock this
   // method to fake the registration part.
   MOCK_METHOD4(RegisterSupervisedUser,
                void(bool create_shortcut,
                     const std::string& supervised_user_id,
                     Profile* custodian_profile,
                     Profile* new_profile));
 
+#if defined(ENABLE_SUPERVISED_USERS)
   // Calls the callback method to resume profile creation flow.
   void RealRegisterSupervisedUser(bool create_shortcut,
                                   const std::string& supervised_user_id,
                                   Profile* custodian_profile,
                                   Profile* new_profile) {
     // Call the callback method to resume profile creation flow.
     SigninCreateProfileHandler::OnSupervisedUserRegistered(
         create_shortcut,
         custodian_profile,
         new_profile,
         GoogleServiceAuthError(GoogleServiceAuthError::NONE));
   }
+#endif
 
  private:
   TestingProfileManager* profile_manager_;
   DISALLOW_COPY_AND_ASSIGN(TestSigninCreateProfileHandler);
 };
 
 class SigninCreateProfileHandlerTest : public BrowserWithTestWindowTest {
  public:
   SigninCreateProfileHandlerTest()
       : web_ui_(new content::TestWebUI) {}
@@ skipping 18 matching lines @@
         0,
         std::string(),
         factories);
 
     // Authenticate the custodian profile.
     fake_signin_manager_ = static_cast<FakeSigninManagerForTesting*>(
         SigninManagerFactory::GetForProfile(custodian_));
     fake_signin_manager_->SetAuthenticatedAccountInfo(kTestGaiaId1,
                                                       kTestEmail1);
 
+#if defined(ENABLE_SUPERVISED_USERS)
     // Add supervised users to the custodian profile.
     SupervisedUserSyncService* sync_service_ =
         SupervisedUserSyncServiceFactory::GetForProfile(custodian_);
     syncer::SyncDataList sync_data;
     sync_data.push_back(CreateSyncData(kSupervisedUserId1,
                                        kSupervisedUsername1,
                                        kSupervisedUserAvatarName1));
     sync_data.push_back(CreateSyncData(kSupervisedUserId2,
                                        kSupervisedUsername2,
                                        kSupervisedUserAvatarName2));
@@ skipping 11 matching lines @@
     profile_manager()->CreateTestingProfile(
         kSupervisedUsername2,
         std::unique_ptr<syncable_prefs::PrefServiceSyncable>(),
         base::UTF8ToUTF16(kSupervisedUsername2),
         0,
         kSupervisedUserId2,  // supervised_user_id
         TestingProfile::TestingFactories());
 
     EXPECT_EQ(2u,
         profile_manager()->profile_attributes_storage()->GetNumberOfProfiles());
+#endif
   }
 
   void TearDown() override {
     profile_manager_.reset();
     handler_.reset();
     BrowserWithTestWindowTest::TearDown();
   }
 
   content::TestWebUI* web_ui() {
     return web_ui_.get();
@@ skipping 130 matching lines @@
   ASSERT_TRUE(profile->GetString("name", &profile_name));
   EXPECT_NE("", profile_name);
   std::string profile_path;
   ASSERT_TRUE(profile->GetString("filePath", &profile_path));
   EXPECT_NE("", profile_path);
   bool is_supervised;
   ASSERT_TRUE(profile->GetBoolean("isSupervised", &is_supervised));
   ASSERT_FALSE(is_supervised);
 }
 
+#if defined(ENABLE_SUPERVISED_USERS)
+
 TEST_F(SigninCreateProfileHandlerTest, CreateSupervisedUser) {
   // Expect the call to create the profile.
   EXPECT_CALL(*handler(), DoCreateProfile(_, _, _, _, _))
       .WillOnce(Invoke(handler(),
                        &TestSigninCreateProfileHandler::RealDoCreateProfile));
 
   // Expect the call to register the supervised user.
   EXPECT_CALL(*handler(), RegisterSupervisedUser(_, _, _, _))
       .WillOnce(Invoke(
             handler(),
@@ skipping 209 matching lines @@
   std::string callback_name;
   ASSERT_TRUE(web_ui()->call_data()[0]->arg1()->GetAsString(&callback_name));
   EXPECT_EQ("create-profile-error", callback_name);
 
   base::string16 expected_error_message = l10n_util::GetStringUTF16(
       IDS_PROFILES_CREATE_SUPERVISED_NOT_ALLOWED_BY_POLICY);
   base::string16 error_message;
   ASSERT_TRUE(web_ui()->call_data()[0]->arg2()->GetAsString(&error_message));
   EXPECT_EQ(expected_error_message, error_message);
 }
+
+#endif