Fix build when ENABLE_MANAGED_USERS is not defined

chrome/browser/ui/webui/options/create_profile_handler.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/ui/webui/options/create_profile_handler.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/value_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profile_metrics.h"
 #include "chrome/browser/profiles/profiles_state.h"
+#include "chrome/browser/sync/profile_sync_service.h"
+#include "chrome/browser/sync/profile_sync_service_factory.h"
+#include "chrome/browser/ui/webui/options/options_handlers_helper.h"
+#include "chrome/common/pref_names.h"
+#include "content/public/browser/web_ui.h"
+#include "grit/generated_resources.h"
+#include "ui/base/l10n/l10n_util.h"
+
+#if defined(ENABLE_MANAGED_USERS)
 #include "chrome/browser/supervised_user/supervised_user_registration_utility.h"
 #include "chrome/browser/supervised_user/supervised_user_service.h"
 #include "chrome/browser/supervised_user/supervised_user_service_factory.h"
 #include "chrome/browser/supervised_user/supervised_user_sync_service.h"
 #include "chrome/browser/supervised_user/supervised_user_sync_service_factory.h"
-#include "chrome/browser/sync/profile_sync_service.h"
-#include "chrome/browser/sync/profile_sync_service_factory.h"
-#include "chrome/browser/ui/webui/options/options_handlers_helper.h"
-#include "chrome/common/pref_names.h"
-#include "grit/generated_resources.h"
-#include "ui/base/l10n/l10n_util.h"
+#endif
 
 namespace options {
 
 CreateProfileHandler::CreateProfileHandler()
     : profile_creation_type_(NO_CREATION_IN_PROGRESS),
       weak_ptr_factory_(this) {
 }
 
 CreateProfileHandler::~CreateProfileHandler() {
   CancelProfileRegistration(false);
@@ skipping 44 matching lines @@
   if (args->GetString(0, &name) && args->GetString(1, &icon)) {
     if (args->GetBoolean(2, &create_shortcut)) {
       bool success = args->GetBoolean(3, &supervised_user);
       DCHECK(success);
       success = args->GetString(4, &supervised_user_id);
       DCHECK(success);
     }
   }
 
   if (supervised_user) {
+#if defined(ENABLE_MANAGED_USERS)

[James Hawkins, 2014/06/27 21:09:57]

OK, you're not gonna like this.  (At least) the webui code that deals with
managed users needs to be refactored such that we don't have this ifdef
splattered across the code.

[mckev, 2014/06/27 21:14:10]

Haha, no worries at all.  I'd be happy to assist if that makes sense.  There is
a similar issue with signin that required a wrapper.  Does that approach make
sense here?

     if (!IsValidExistingSupervisedUserId(supervised_user_id))
       return;
 
     profile_creation_type_ = SUPERVISED_PROFILE_IMPORT;
     if (supervised_user_id.empty()) {
       profile_creation_type_ = SUPERVISED_PROFILE_CREATION;
       supervised_user_id =
           SupervisedUserRegistrationUtility::GenerateNewSupervisedUserId();
 
       // If sync is not yet fully initialized, the creation may take extra time,
       // so show a message. Import doesn't wait for an acknowledgement, so it
       // won't have the same potential delay.
       ProfileSyncService* sync_service =
           ProfileSyncServiceFactory::GetInstance()->GetForProfile(
               current_profile);
       ProfileSyncService::SyncStatusSummary status =
           sync_service->QuerySyncStatusSummary();
       if (status == ProfileSyncService::DATATYPES_NOT_INITIALIZED) {
         ShowProfileCreationWarning(l10n_util::GetStringUTF16(
             IDS_PROFILES_CREATE_SUPERVISED_JUST_SIGNED_IN));
       }
     }
+#else
+  DCHECK(false) << "Supervised users aren't enabled.";
+#endif
   }
 
   ProfileMetrics::LogProfileAddNewUser(ProfileMetrics::ADD_NEW_USER_DIALOG);
 
   profile_path_being_created_ = ProfileManager::CreateMultiProfileAsync(
       name, icon,
       base::Bind(&CreateProfileHandler::OnProfileCreated,
                  weak_ptr_factory_.GetWeakPtr(),
                  create_shortcut,
                  helper::GetDesktopType(web_ui()),
@@ skipping 58 matching lines @@
       NOTREACHED();
       break;
   }
 }
 
 void CreateProfileHandler::RegisterSupervisedUser(
     bool create_shortcut,
     chrome::HostDesktopType desktop_type,
     const std::string& supervised_user_id,
     Profile* new_profile) {
+#if defined(ENABLE_MANAGED_USERS)

[Bernhard Bauer, 2014/06/30 16:04:19]

We might also want to move this whole method (and the one below) into the
#ifdef. Basically, anything that has "supervised user" in its name shouldn't
exist if the #define is not present.

   DCHECK_EQ(profile_path_being_created_.value(),
             new_profile->GetPath().value());
 
   SupervisedUserService* supervised_user_service =
       SupervisedUserServiceFactory::GetForProfile(new_profile);
 
   // Register the supervised user using the profile of the custodian.
   supervised_user_registration_utility_ =
       SupervisedUserRegistrationUtility::Create(Profile::FromWebUI(web_ui()));
   supervised_user_service->RegisterAndInitSync(
       supervised_user_registration_utility_.get(),
       Profile::FromWebUI(web_ui()),
       supervised_user_id,
       base::Bind(&CreateProfileHandler::OnSupervisedUserRegistered,
                  weak_ptr_factory_.GetWeakPtr(),
                  create_shortcut,
                  desktop_type,
                  new_profile));
+#else
+  DCHECK(false) << "Supervised users aren't enabled.";
+#endif
 }
 
 void CreateProfileHandler::OnSupervisedUserRegistered(
     bool create_shortcut,
     chrome::HostDesktopType desktop_type,
     Profile* profile,
     const GoogleServiceAuthError& error) {
   GoogleServiceAuthError::State state = error.state();
   RecordSupervisedProfileCreationMetrics(state);
   if (state == GoogleServiceAuthError::NONE) {
@@ skipping 93 matching lines @@
   if (!new_profile->IsSupervised())
     return;
 
   if (user_initiated) {
     UMA_HISTOGRAM_MEDIUM_TIMES(
         "Profile.CreateTimeCanceledNoTimeout",
         base::TimeTicks::Now() - profile_creation_start_time_);
     RecordProfileCreationMetrics(Profile::CREATE_STATUS_CANCELED);
   }
 
+#if defined(ENABLE_MANAGED_USERS)
   DCHECK(supervised_user_registration_utility_.get());
   supervised_user_registration_utility_.reset();
+#endif
 
   DCHECK_NE(NO_CREATION_IN_PROGRESS, profile_creation_type_);
   profile_creation_type_ = NO_CREATION_IN_PROGRESS;
 
   // Cancelling registration means the callback passed into
   // RegisterAndInitSync() won't be called, so the cleanup must be done here.
   profile_path_being_created_.clear();
   helper::DeleteProfileAtPath(new_profile->GetPath(), web_ui());
 }
 
@@ skipping 66 matching lines @@
           "BrowserOptions.showManagedUserImportError" :
           "BrowserOptions.showCreateProfileError";
   }
 
   NOTREACHED();
   return std::string();
 }
 
 bool CreateProfileHandler::IsValidExistingSupervisedUserId(
     const std::string& existing_supervised_user_id) const {
+#if defined(ENABLE_MANAGED_USERS)
   if (existing_supervised_user_id.empty())
     return true;
 
   Profile* profile = Profile::FromWebUI(web_ui());
   const base::DictionaryValue* dict =
       SupervisedUserSyncServiceFactory::GetForProfile(profile)->
           GetSupervisedUsers();
   if (!dict->HasKey(existing_supervised_user_id))
     return false;
 
   // Check if this supervised user already exists on this machine.
   const ProfileInfoCache& cache =
       g_browser_process->profile_manager()->GetProfileInfoCache();
   for (size_t i = 0; i < cache.GetNumberOfProfiles(); ++i) {
     if (existing_supervised_user_id ==
             cache.GetSupervisedUserIdOfProfileAtIndex(i))
       return false;
   }
   return true;
+#else
+  DCHECK(false) << "Supervised users aren't enabled.";
+  return false;
+#endif
 }
 
 }  // namespace options