Show Goodies page to new Chromebook users

chrome/browser/chromeos/login/session/user_session_manager.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/chromeos/login/session/user_session_manager.h"
 
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
@@ skipping 101 matching lines @@
 namespace {
 
 // Milliseconds until we timeout our attempt to fetch flags from the child
 // account service.
 static const int kFlagsFetchingLoginTimeoutMs = 1000;
 
 // The maximum ammount of time that we are willing to delay a browser restart
 // for, waiting for a session restore to finish.
 static const int kMaxRestartDelaySeconds = 10;
 
+// Max days after initial login that we're willing to show Goodies.
+static const int kMaxDaysAfterOobeForGoodies = 14;
+
 // ChromeVox tutorial URL (used in place of "getting started" url when
 // accessibility is enabled).
 const char kChromeVoxTutorialURLPattern[] =
     "http://www.chromevox.com/tutorial/index.html?lang=%s";
 
 void InitLocaleAndInputMethodsForNewUser(
     UserSessionManager* session_manager,
     Profile* profile,
     const std::string& public_session_locale,
     const std::string& public_session_input_method) {
@@ skipping 74 matching lines @@
 
   // Save the preferred languages in the user's preferences.
   prefs->SetString(prefs::kLanguagePreferredLanguages,
                    base::JoinString(language_codes, ","));
 
   // Indicate that we need to merge the syncable input methods when we sync,
   // since we have not applied the synced prefs before.
   prefs->SetBoolean(prefs::kLanguageShouldMergeInputMethods, true);
 }
 
+// We want to show Goodies page the first time a new browser window is opened
+// on a new Chromebook.  kCanShowOobeGoodiesPage defaults to |true|; we set it
+// to |false| (return |false|) for any device over kMaxDaysAfterOobeForGoodies
+// days old, to avoid showing it after update on older devices.
+static bool CheckGoodiesPrefAgainstOobeTimestamp() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
+  const base::FilePath oobe_timestamp_file =
+      StartupUtils::GetOobeCompleteFlagPath();
+  base::File::Info fileInfo;
+  if (base::GetFileInfo(oobe_timestamp_file, &fileInfo)) {
+    base::TimeDelta time_since_oobe =
+        base::Time::Now() - fileInfo.creation_time;
+    if (time_since_oobe >
+        base::TimeDelta::FromDays(kMaxDaysAfterOobeForGoodies))
+      return false;
+  }
+  return true;
+}
+
+// Callback into main thread to set pref to |false| if too long since oobe.
+static void UpdateGoodiesPrefCantShow(bool can_show_goodies) {
+  if (can_show_goodies)
+    return;
+  PrefService* prefs = g_browser_process->local_state();
+  prefs->SetBoolean(prefs::kCanShowOobeGoodiesPage, false);
+}
+
 #if defined(ENABLE_RLZ)
 // Flag file that disables RLZ tracking, when present.
 const base::FilePath::CharType kRLZDisabledFlagName[] =
     FILE_PATH_LITERAL(".rlz_disabled");
 
 base::FilePath GetRlzDisabledFlagPath() {
   base::FilePath homedir;
   PathService::Get(base::DIR_HOME, &homedir);
   return homedir.Append(kRLZDisabledFlagName);
 }
@@ skipping 117 matching lines @@
                                              true /* path is absolute */,
                                              false /* don't create */);
     }
   }
 }
 
 // static
 void UserSessionManager::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterStringPref(prefs::kRLZBrand, std::string());
   registry->RegisterBooleanPref(prefs::kRLZDisabled, false);
+  registry->RegisterBooleanPref(prefs::kCanShowOobeGoodiesPage, true);
 }
 
 UserSessionManager::UserSessionManager()
     : delegate_(nullptr),
       authenticator_(nullptr),
       has_auth_cookies_(false),
       user_sessions_restored_(false),
       user_sessions_restore_in_progress_(false),
       exit_after_session_restore_(false),
       session_restore_strategy_(
@@ skipping 767 matching lines @@
             profile, base::Bind(&UserSessionManager::OnTokenHandleObtained,
                                 weak_factory_.GetWeakPtr()));
       }
     }
   }
 
   // Now that profile is ready, proceed to either alternative login flows or
   // launch browser.
   bool browser_launched = InitializeUserSession(profile);
 
+  CheckCanShowGoodiesPref();

[Greg Levin, 2015/09/09 23:20:33]

My choice to put this here was a little arbitrary.  It just needs to go
*somewhere* during session or browser startup.  I chose here because (i) the
browser thread has started by this point, (ii) there's other first-run-type
URL/info stuff going on here, and (iii) this class already has a RegisterPrefs()
function.  However, I'd be open to suggestions for better places to put it.

+
   // TODO(nkostylev): This pointer should probably never be NULL, but it looks
   // like OnProfileCreated() may be getting called before
   // UserSessionManager::PrepareProfile() has set |delegate_| when Chrome is
   // killed during shutdown in tests -- see http://crosbug.com/18269.  Replace
   // this 'if' statement with a CHECK(delegate_) once the underlying issue is
   // resolved.
   if (delegate_)
     delegate_->OnProfilePrepared(profile, browser_launched);
 }
 
@@ skipping 35 matching lines @@
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         ::switches::kSilentLaunch);
     first_run::MaybeLaunchDialogAfterSessionStart();
   } else {
     for (size_t i = 0; i < start_urls.size(); ++i) {
       base::CommandLine::ForCurrentProcess()->AppendArg(start_urls[i]);
     }
   }
 }
 
+void UserSessionManager::CheckCanShowGoodiesPref() {
+  PrefService* prefs = g_browser_process->local_state();
+  bool can_show_goodies = prefs->GetBoolean(prefs::kCanShowOobeGoodiesPage);
+  if (can_show_goodies)
+    content::BrowserThread::PostTaskAndReplyWithResult(
+        content::BrowserThread::FILE, FROM_HERE,
+        base::Bind(&CheckGoodiesPrefAgainstOobeTimestamp),
+        base::Bind(&UpdateGoodiesPrefCantShow));
+}
+
 bool UserSessionManager::InitializeUserSession(Profile* profile) {
   ChildAccountService* child_service =
       ChildAccountServiceFactory::GetForProfile(profile);
   child_service->AddChildStatusReceivedCallback(
       base::Bind(&UserSessionManager::ChildAccountStatusReceivedCallback,
                  weak_factory_.GetWeakPtr(), profile));
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&UserSessionManager::StopChildStatusObserving,
                             weak_factory_.GetWeakPtr(), profile),
       base::TimeDelta::FromMilliseconds(kFlagsFetchingLoginTimeoutMs));
@@ skipping 551 matching lines @@
   token_handle_util_.reset();
 }
 
 void UserSessionManager::CreateTokenUtilIfMissing() {
   if (!token_handle_util_.get())
     token_handle_util_.reset(
         new TokenHandleUtil(user_manager::UserManager::Get()));
 }
 
 }  // namespace chromeos