Fix the new First Run sentinel file path determination.

chrome/browser/first_run/first_run.cc

 // Copyright (c) 2012 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/first_run/first_run.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 29 matching lines @@
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/signin/signin_promo.h"
 #include "chrome/browser/signin/signin_tracker.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/browser/ui/global_error/global_error_service.h"
 #include "chrome/browser/ui/global_error/global_error_service_factory.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/webui/ntp/new_tab_ui.h"
+#include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/installer/util/master_preferences.h"
 #include "chrome/installer/util/master_preferences_constants.h"
 #include "chrome/installer/util/util_constants.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
@@ skipping 381 matching lines @@
       if (g_browser_process->local_state()->GetBoolean(
           prefs::kDefaultBrowserSettingEnabled)) {
         ShellIntegration::SetAsDefaultBrowser();
       }
     } else if (make_chrome_default_for_user) {
         ShellIntegration::SetAsDefaultBrowser();
     }
   }
 }
 
-bool IsFirstRunSentinelPresent() {
-  base::FilePath first_run_sentinel;
-  // Treat sentinel as being present if the path can't be obtained.
-  if (!first_run::internal::GetFirstRunSentinelFilePath(&first_run_sentinel) ||
-      base::PathExists(first_run_sentinel)) {
-    return true;
-  }
-  // Sentinel is truly absent if there's no legacy path or legacy doesn't exist.
-  base::FilePath legacy_first_run_sentinel;
-  if (!first_run::internal::GetLegacyFirstRunSentinelFilePath(
-          &legacy_first_run_sentinel) ||
-      !base::PathExists(legacy_first_run_sentinel)) {
-    return false;
-  }
-  // Migrate the legacy sentinel to the new location if it was found. This does
-  // a copy instead of a move to avoid breaking the developer build case where
-  // the First Run sentinel is dropped beside chrome.exe by a build action
-  // (i.e., at the legacy path).
-  bool migrated = base::CopyFile(legacy_first_run_sentinel, first_run_sentinel);
-  DPCHECK(migrated);
-  // Sentinel is present regardless of whether or not it was migrated.
-  return true;
-}
-
 }  // namespace
 
 namespace first_run {
 namespace internal {
 
 FirstRunState first_run_ = FIRST_RUN_UNKNOWN;
 
 void SetupMasterPrefsFromInstallPrefs(
     const installer::MasterPreferences& install_prefs,
     MasterPrefs* out_prefs) {
@@ skipping 74 matching lines @@
 
   out_prefs->variations_seed = install_prefs.GetVariationsSeed();
   out_prefs->variations_seed_signature =
       install_prefs.GetVariationsSeedSignature();
 
   install_prefs.GetString(
       installer::master_preferences::kDistroSuppressDefaultBrowserPromptPref,
       &out_prefs->suppress_default_browser_prompt_for_version);
 }
 
+bool GetFirstRunSentinelFilePath(base::FilePath* path) {
+  base::FilePath user_data_dir;
+  if (!PathService::Get(chrome::DIR_USER_DATA, &user_data_dir))
+    return false;
+  *path = user_data_dir.Append(chrome::kFirstRunSentinel);
+  return true;
+}
+
 bool CreateSentinel() {
   base::FilePath first_run_sentinel;
-  if (!internal::GetFirstRunSentinelFilePath(&first_run_sentinel))
-    return false;
-  return base::WriteFile(first_run_sentinel, "", 0) != -1;
+  return GetFirstRunSentinelFilePath(&first_run_sentinel) &&
+      base::WriteFile(first_run_sentinel, "", 0) != -1;
 }
 
 // -- Platform-specific functions --
 
 #if !defined(OS_LINUX) && !defined(OS_BSD)
 bool IsOrganicFirstRun() {
   std::string brand;
   google_util::GetBrand(&brand);
   return google_util::IsOrganicFirstRun(brand);
 }
 #endif
 
 }  // namespace internal
 
 MasterPrefs::MasterPrefs()
     : ping_delay(0),
       homepage_defined(false),
       do_import_items(0),
       dont_import_items(0),
       make_chrome_default_for_user(false),
       suppress_first_run_default_browser_prompt(false) {
 }
 
 MasterPrefs::~MasterPrefs() {}
 
 bool IsChromeFirstRun() {
-  if (internal::first_run_ != internal::FIRST_RUN_UNKNOWN)
-    return internal::first_run_ == internal::FIRST_RUN_TRUE;
-
-  internal::first_run_ = internal::FIRST_RUN_FALSE;
-
-  base::FilePath first_run_sentinel;
-  const CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kForceFirstRun)) {
-    internal::first_run_ = internal::FIRST_RUN_TRUE;
-  } else if (!command_line->HasSwitch(switches::kNoFirstRun) &&
-             !IsFirstRunSentinelPresent()) {
-    internal::first_run_ = internal::FIRST_RUN_TRUE;
+  if (internal::first_run_ == internal::FIRST_RUN_UNKNOWN) {
+    internal::first_run_ = internal::FIRST_RUN_FALSE;
+    const CommandLine* command_line = CommandLine::ForCurrentProcess();
+    if (command_line->HasSwitch(switches::kForceFirstRun) ||
+        (!command_line->HasSwitch(switches::kNoFirstRun) &&
+         !internal::IsFirstRunSentinelPresent())) {
+      internal::first_run_ = internal::FIRST_RUN_TRUE;
+    }
   }
-
   return internal::first_run_ == internal::FIRST_RUN_TRUE;
 }
 
 bool IsFirstRunSuppressed(const CommandLine& command_line) {
   return command_line.HasSwitch(switches::kNoFirstRun);
 }
 
 void CreateSentinelIfNeeded() {
   if (IsChromeFirstRun())
     internal::CreateSentinel();
 }
 
 std::string GetPingDelayPrefName() {
   return base::StringPrintf("%s.%s",
                             installer::master_preferences::kDistroDict,
                             installer::master_preferences::kDistroPingDelay);
 }
 
 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterIntegerPref(
       GetPingDelayPrefName().c_str(),
       0,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 bool RemoveSentinel() {
   base::FilePath first_run_sentinel;
-  if (!internal::GetFirstRunSentinelFilePath(&first_run_sentinel))
-    return false;
-  return base::DeleteFile(first_run_sentinel, false);
+  return internal::GetFirstRunSentinelFilePath(&first_run_sentinel) &&
+      base::DeleteFile(first_run_sentinel, false);
 }
 
 bool SetShowFirstRunBubblePref(FirstRunBubbleOptions show_bubble_option) {
   PrefService* local_state = g_browser_process->local_state();
   if (!local_state)
     return false;
   if (local_state->GetInteger(
           prefs::kShowFirstRunBubbleOption) != FIRST_RUN_BUBBLE_SUPPRESS) {
     // Set the new state as long as the bubble wasn't explicitly suppressed
     // already.
@@ skipping 162 matching lines @@
   SetShouldDoPersonalDataManagerFirstRun();
 
   internal::DoPostImportPlatformSpecificTasks(profile);
 }
 
 uint16 auto_import_state() {
   return g_auto_import_state;
 }
 
 }  // namespace first_run