Removing FRE UI for unicorn accounts.

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"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/supervised_user/child_accounts/permission_request_creator_apiary.h"
 #include "chrome/browser/supervised_user/supervised_user_constants.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_settings_service.h"
 #include "chrome/browser/supervised_user/supervised_user_settings_service_factory.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
+#include "components/pref_registry/pref_registry_syncable.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "components/user_manager/user_manager.h"
 #endif
 
 const char kIsChildAccountServiceFlagName[] = "uca";
 
@@ skipping 29 matching lines @@
 };
 
 ChildAccountService::ChildAccountService(Profile* profile)
     : profile_(profile), active_(false),
       flag_fetch_backoff_(&kBackoffPolicy),
       family_fetch_backoff_(&kBackoffPolicy),
       weak_ptr_factory_(this) {}
 
 ChildAccountService::~ChildAccountService() {}
 
+// static
+void ChildAccountService::RegisterProfilePrefs(
+    user_prefs::PrefRegistrySyncable* registry) {
+  registry->RegisterBooleanPref(
+      prefs::kChildAccountStatusKnown,
+      false,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+}
+
 void ChildAccountService::SetIsChildAccount(bool is_child_account) {
   PropagateChildStatusToUser(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);
   }
 }
 
 void ChildAccountService::Init() {
   SigninManagerFactory::GetForProfile(profile_)->AddObserver(this);
   SupervisedUserServiceFactory::GetForProfile(profile_)->SetDelegate(this);
 
   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.)
   if (SigninManagerFactory::GetForProfile(profile_)->IsAuthenticated())
     StartFetchingServiceFlags();
 }
 
+bool ChildAccountService::IsChildAccountStatusKnown() {
+  return profile_->GetPrefs()->GetBoolean(prefs::kChildAccountStatusKnown);
+}
+
 void ChildAccountService::Shutdown() {
   family_fetcher_.reset();
   CancelFetchingServiceFlags();
   SupervisedUserServiceFactory::GetForProfile(profile_)->SetDelegate(NULL);
   DCHECK(!active_);
   SigninManagerFactory::GetForProfile(profile_)->RemoveObserver(this);
 }
 
+
+void ChildAccountService::AddChildStatusReceivedCallback(
+    base::Closure callback) {
+  status_received_callback_list_.push_back(callback);

[Marc Treib, 2015/03/10 12:01:35]

What if the status is already known? We might want to call the callback
directly, or otherwise at least add some warning that it won't ever be called.

+}
+
 bool ChildAccountService::SetActive(bool 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));
@@ skipping 166 matching lines @@
     flag_fetch_backoff_.InformOfRequest(false);
     ScheduleNextStatusFlagUpdate(flag_fetch_backoff_.GetTimeUntilRelease());
     return;
   }
 
   flag_fetch_backoff_.InformOfRequest(true);
 
   bool is_child_account =
       std::find(flags.begin(), flags.end(),
                 kIsChildAccountServiceFlagName) != flags.end();
+
+  bool status_was_known = profile_->GetPrefs()->GetBoolean(
+      prefs::kChildAccountStatusKnown);
+  profile_->GetPrefs()->SetBoolean(prefs::kChildAccountStatusKnown, true);
+
+  if (!status_was_known) {
+    for (auto& callback : status_received_callback_list_)
+      callback.Run();
+  }

[Marc Treib, 2015/03/10 12:01:35]

Also clear the list of callbacks here, since we won't need them again?

[merkulova, 2015/03/10 13:36:18]

Done.

+
   SetIsChildAccount(is_child_account);
 
   ScheduleNextStatusFlagUpdate(
       base::TimeDelta::FromSeconds(kUpdateIntervalSeconds));
 }
 
 void ChildAccountService::ScheduleNextStatusFlagUpdate(base::TimeDelta delay) {
   flag_fetch_timer_.Start(
       FROM_HERE, delay, this, &ChildAccountService::StartFetchingServiceFlags);
 }
@@ skipping 67 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);
 }