Cleanup: remove SupervisedUserService::IsChildAccount.

chrome/browser/supervised_user/child_accounts/child_account_service.cc

 // Copyright 2014 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/supervised_user/child_accounts/child_account_service.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 27 matching lines @@
 
 ChildAccountService::ChildAccountService(Profile* profile)
     : profile_(profile), active_(false), weak_ptr_factory_(this) {}
 
 ChildAccountService::~ChildAccountService() {}
 
 void ChildAccountService::Init() {
   SigninManagerFactory::GetForProfile(profile_)->AddObserver(this);
   SupervisedUserServiceFactory::GetForProfile(profile_)->SetDelegate(this);
 
-  PropagateChildStatusToUser(IsChildAccount());
+  PropagateChildStatusToUser(profile_->IsChild());
 
   // If we're already signed in, fetch the flag again just to be sure.
   // (Previously, the browser might have been closed before we got the flag.
   // This also handles the graduation use case in a basic way.)
   std::string account_id = SigninManagerFactory::GetForProfile(profile_)
       ->GetAuthenticatedAccountId();
   if (!account_id.empty())
     StartFetchingServiceFlags(account_id);
 }
 
 void ChildAccountService::Shutdown() {
   CancelFetchingServiceFlags();
   SupervisedUserService* service =
       SupervisedUserServiceFactory::GetForProfile(profile_);
   service->SetDelegate(NULL);
   DCHECK(!active_);
   SigninManagerFactory::GetForProfile(profile_)->RemoveObserver(this);
 }
 
-bool ChildAccountService::IsChildAccount() const {
-  return profile_->GetPrefs()->GetString(prefs::kSupervisedUserId) ==
-             supervised_users::kChildAccountSUID;
-}
-
 bool ChildAccountService::SetActive(bool active) {
-  if (!IsChildAccount() && !active_)
+  if (!profile_->IsChild() && !active_)
     return false;
   if (active_ == active)
     return true;
   active_ = active;
 
   if (active_) {
     // In contrast to local SUs, child account SUs must sign in.
     scoped_ptr<base::Value> allow_signin(new base::FundamentalValue(true));
     SupervisedUserSettingsService* settings_service =
         SupervisedUserSettingsServiceFactory::GetForProfile(profile_);
@@ skipping 81 matching lines @@
 void ChildAccountService::GoogleSigninSucceeded(const std::string& account_id,
                                                 const std::string& username,
                                                 const std::string& password) {
   DCHECK(!account_id.empty());
 
   StartFetchingServiceFlags(account_id);
 }
 
 void ChildAccountService::GoogleSignedOut(const std::string& account_id,
                                           const std::string& username) {
-  DCHECK(!IsChildAccount());
+  DCHECK(!profile_->IsChild());
   CancelFetchingServiceFlags();
 }
 
 void ChildAccountService::OnGetFamilyMembersSuccess(
     const std::vector<FamilyInfoFetcher::FamilyMember>& members) {
   bool hoh_found = false;
   bool parent_found = false;
   for (const FamilyInfoFetcher::FamilyMember& member : members) {
     if (member.role == FamilyInfoFetcher::HEAD_OF_HOUSEHOLD) {
       hoh_found = true;
@@ skipping 59 matching lines @@
 
   account_id_.clear();
 
   bool is_child_account =
       std::find(flags.begin(), flags.end(),
                 kIsChildAccountServiceFlagName) != flags.end();
   SetIsChildAccount(is_child_account);
 }
 
 void ChildAccountService::SetIsChildAccount(bool is_child_account) {
-  if (IsChildAccount() == is_child_account)
+  if (profile_->IsChild() == is_child_account)
     return;
 
   if (is_child_account) {
     profile_->GetPrefs()->SetString(prefs::kSupervisedUserId,
                                     supervised_users::kChildAccountSUID);
   } else {
     profile_->GetPrefs()->ClearPref(prefs::kSupervisedUserId);
   }
   PropagateChildStatusToUser(is_child_account);
 }
@@ skipping 69 matching lines @@
     command_line->AppendSwitch(switches::kEnableSupervisedUserBlacklist);
 
   // Query-based filtering also defaults to enabled.
   bool has_enable_safesites =
       command_line->HasSwitch(switches::kEnableSupervisedUserSafeSites);
   bool has_disable_safesites =
       command_line->HasSwitch(switches::kDisableSupervisedUserSafeSites);
   if (!has_enable_safesites && !has_disable_safesites)
     command_line->AppendSwitch(switches::kEnableSupervisedUserSafeSites);
 }