Re-enable child account detection, now behind a flag.

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/metrics/field_trial.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/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 kChildAccountDetectionFieldTrialName[] = "ChildAccountDetection";
+
 const char kIsChildAccountServiceFlagName[] = "uca";
 
 // 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 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.
@@ skipping 21 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
+bool ChildAccountService::IsChildAccountDetectionEnabled() {
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  bool is_enabled =
+      command_line->HasSwitch(switches::kEnableChildAccountDetection);
+  bool is_disabled =
+      command_line->HasSwitch(switches::kDisableChildAccountDetection);
+
+  // If any arg is specified, disable the field trial.

[Alexei Svitkine (slow), 2015/03/09 16:51:20]

Can you instead follow the best practices described at go/finch-and-flags?

[Marc Treib, 2015/03/09 17:32:18]

Done.

+  if (is_enabled || is_disabled) {
+    base::FieldTrial* field_trial =
+        base::FieldTrialList::Find(kChildAccountDetectionFieldTrialName);
+    if (field_trial)
+      field_trial->Disable();
+
+    return is_enabled && !is_disabled;
+  }
+
+  // Find the trial group we're in. This also initializes the field trial if
+  // necessary.
+  std::string trial_group =
+      base::FieldTrialList::FindFullName(kChildAccountDetectionFieldTrialName);
+  if (trial_group == "Enabled")
+    return true;
+
+  return false;
+}
+
 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);
@@ skipping 164 matching lines @@
   family_fetcher_.reset();
   family_fetch_timer_.Stop();
 }
 
 void ChildAccountService::ScheduleNextFamilyInfoUpdate(base::TimeDelta delay) {
   family_fetch_timer_.Start(
       FROM_HERE, delay, this, &ChildAccountService::StartFetchingFamilyInfo);
 }
 
 void ChildAccountService::StartFetchingServiceFlags() {
+  if (!IsChildAccountDetectionEnabled()) {
+    SetIsChildAccount(false);
+    return;
+  }
   account_id_ = SigninManagerFactory::GetForProfile(profile_)
       ->GetAuthenticatedAccountId();
+  flag_fetcher_.reset(new AccountServiceFlagFetcher(
+      account_id_,
+      ProfileOAuth2TokenServiceFactory::GetForProfile(profile_),
+      profile_->GetRequestContext(),
+      base::Bind(&ChildAccountService::OnFlagsFetched,
+                 weak_ptr_factory_.GetWeakPtr())));
 }
 
 void ChildAccountService::CancelFetchingServiceFlags() {
   flag_fetcher_.reset();
   account_id_.clear();
   flag_fetch_timer_.Stop();
 }
 
 void ChildAccountService::OnFlagsFetched(
     AccountServiceFlagFetcher::ResultCode result,
@@ skipping 101 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);
 }