ChildAccountService: periodically re-fetch parent info; retry on failure

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 18 matching lines @@
 #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";
 
-// Normally, re-check the child account flag once per day.
-const int kStatusFlagUpdateIntervalSeconds = 60 * 60 * 24;
+// Normally, re-check the child account flag and the family info once per day.
+const int kUpdateIntervalSeconds = 60 * 60 * 24;
 
-// In case of an error while getting the flag, retry with exponential backoff.
-const net::BackoffEntry::Policy kFlagFetchBackoffPolicy = {
+// In case of an error while getting the flag or the family info, retry with
+// exponential backoff.
+const net::BackoffEntry::Policy kBackoffPolicy = {
   // Number of initial errors (in sequence) to ignore before applying
   // exponential back-off rules.
   0,
 
   // Initial delay for exponential backoff in ms.
   2000,
 
   // Factor by which the waiting time will be multiplied.
   2,
 
   // Fuzzing percentage. ex: 10% will spread requests randomly
   // between 90%-100% of the calculated time.
   0.2, // 20%
 
   // Maximum amount of time we are willing to delay our request in ms.
   1000 * 60 * 60 * 4, // 4 hours.
 
   // Time to keep an entry from being discarded even when it
   // has no significant state, -1 to never discard.
   -1,
 
   // Don't use initial delay unless the last request was an error.
   false,
 };
 
 ChildAccountService::ChildAccountService(Profile* profile)
     : profile_(profile), active_(false),
-      flag_fetch_backoff_(&kFlagFetchBackoffPolicy),
+      flag_fetch_backoff_(&kBackoffPolicy),
+      family_fetch_backoff_(&kBackoffPolicy),
       weak_ptr_factory_(this) {}
 
 ChildAccountService::~ChildAccountService() {}
 
 void ChildAccountService::SetIsChildAccount(bool is_child_account) {
   if (profile_->IsChild() == is_child_account)
     return;
 
   if (is_child_account) {
     profile_->GetPrefs()->SetString(prefs::kSupervisedUserId,
@@ skipping 39 matching lines @@
         SupervisedUserSettingsServiceFactory::GetForProfile(profile_);
     settings_service->SetLocalSetting(supervised_users::kSigninAllowed,
                                       allow_signin.Pass());
 #if !defined(OS_CHROMEOS)
     // This is also used by user policies (UserPolicySigninService), but since
     // child accounts can not also be Dasher accounts, there shouldn't be any
     // problems.
     SigninManagerFactory::GetForProfile(profile_)->ProhibitSignout(true);
 #endif
 
-    // TODO(treib): Maybe only fetch the parents on the first start, and then
-    // refresh occasionally (like once every 24h)? That's what
-    // GAIAInfoUpdateService does.
-    family_fetcher_.reset(new FamilyInfoFetcher(
-        this,
-        SigninManagerFactory::GetForProfile(profile_)
-            ->GetAuthenticatedAccountId(),
-        ProfileOAuth2TokenServiceFactory::GetForProfile(profile_),
-        profile_->GetRequestContext()));
-    family_fetcher_->StartGetFamilyMembers();
+    // TODO(treib): Maybe store the last update time in a pref, so we don't

[Marc Treib, 2015/01/26 13:19:31]

WDYT?

[Bernhard Bauer, 2015/01/26 13:41:23]

That seems like a good idea. We could check at every start[*]; if the last check
was more than 24 hours ago, we re-check, if not, we set a timer for the
remaining period.

[*]Or ideally even a bit later than directly at startup, to reduce network
contention.

+    // have to re-fetch on every start.
+    StartFetchingFamilyInfo();
 
     SupervisedUserService* service =
         SupervisedUserServiceFactory::GetForProfile(profile_);
     service->AddPermissionRequestCreator(
         PermissionRequestCreatorApiary::CreateWithProfile(profile_));
 
     EnableExperimentalFiltering();
   } else {
     SupervisedUserSettingsService* settings_service =
         SupervisedUserSettingsServiceFactory::GetForProfile(profile_);
@@ skipping 47 matching lines @@
                 ->GetAuthenticatedAccountId(),
             account_id);
 
   StartFetchingServiceFlags();
 }
 
 void ChildAccountService::GoogleSignedOut(const std::string& account_id,
                                           const std::string& username) {
   DCHECK(!profile_->IsChild());
   CancelFetchingServiceFlags();
+  CancelFetchingFamilyInfo();
 }
 
 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;
       SetFirstCustodianPrefs(member);
     } else if (member.role == FamilyInfoFetcher::PARENT) {
       parent_found = true;
       SetSecondCustodianPrefs(member);
     }
     if (hoh_found && parent_found)
       break;
   }
   if (!hoh_found) {
     DLOG(WARNING) << "GetFamilyMembers didn't return a HOH?!";
     ClearFirstCustodianPrefs();
   }
   if (!parent_found)
     ClearSecondCustodianPrefs();
   family_fetcher_.reset();
+
+  family_fetch_backoff_.InformOfRequest(true);
+
+  ScheduleNextFamilyInfoUpdate(
+      base::TimeDelta::FromSeconds(kUpdateIntervalSeconds));
 }
 
 void ChildAccountService::OnFailure(FamilyInfoFetcher::ErrorCode error) {
   DLOG(WARNING) << "GetFamilyMembers failed with code " << error;
+  family_fetch_backoff_.InformOfRequest(false);
+  ScheduleNextFamilyInfoUpdate(family_fetch_backoff_.GetTimeUntilRelease());
+}
+
+void ChildAccountService::StartFetchingFamilyInfo() {
+  family_fetcher_.reset(new FamilyInfoFetcher(
+      this,
+      SigninManagerFactory::GetForProfile(profile_)
+          ->GetAuthenticatedAccountId(),
+      ProfileOAuth2TokenServiceFactory::GetForProfile(profile_),
+      profile_->GetRequestContext()));
+  family_fetcher_->StartGetFamilyMembers();
+}
+
+void ChildAccountService::CancelFetchingFamilyInfo() {
   family_fetcher_.reset();
-  // TODO(treib): Retry after a while?
+  family_fetch_timer_.Stop();
+}
+
+void ChildAccountService::ScheduleNextFamilyInfoUpdate(base::TimeDelta delay) {
+  family_fetch_timer_.Start(
+      FROM_HERE, delay, this, &ChildAccountService::StartFetchingFamilyInfo);
 }
 
 void ChildAccountService::StartFetchingServiceFlags() {
   account_id_ = SigninManagerFactory::GetForProfile(profile_)
       ->GetAuthenticatedAccountId();
   flag_fetcher_.reset(new AccountServiceFlagFetcher(
       account_id_,
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile_),
       profile_->GetRequestContext(),
       base::Bind(&ChildAccountService::OnFlagsFetched,
@@ skipping 27 matching lines @@
     return;
   }
 
   flag_fetch_backoff_.InformOfRequest(true);
 
   bool is_child_account =
       std::find(flags.begin(), flags.end(),
                 kIsChildAccountServiceFlagName) != flags.end();
   SetIsChildAccount(is_child_account);
 
-  ScheduleNextStatusFlagUpdate(base::TimeDelta::FromSeconds(
-      kStatusFlagUpdateIntervalSeconds));
+  ScheduleNextStatusFlagUpdate(
+      base::TimeDelta::FromSeconds(kUpdateIntervalSeconds));
 }
 
 void ChildAccountService::ScheduleNextStatusFlagUpdate(base::TimeDelta delay) {
   flag_fetch_timer_.Start(
       FROM_HERE, delay, this, &ChildAccountService::StartFetchingServiceFlags);
 }
 
 void ChildAccountService::PropagateChildStatusToUser(bool is_child) {
 #if defined(OS_CHROMEOS)
   user_manager::User* user =
@@ skipping 63 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);
 }