Refactoring startup logic for upcoming FRE changes (non-Win 10).

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 <utility>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
+#include "chrome/browser/first_run/first_run_features.h"
 #include "chrome/browser/first_run/first_run_internal.h"
 #include "chrome/browser/google/google_brand.h"
 #include "chrome/browser/importer/external_process_importer_host.h"
 #include "chrome/browser/importer/importer_list.h"
 #include "chrome/browser/importer/importer_progress_observer.h"
 #include "chrome/browser/importer/importer_uma.h"
 #include "chrome/browser/importer/profile_writer.h"
 #include "chrome/browser/prefs/chrome_pref_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profiles_state.h"
@@ skipping 37 matching lines @@
 #include "url/gurl.h"
 
 namespace content {
 class BrowserContext;
 }
 
 using base::UserMetricsAction;
 
 namespace {
 
+// Constants: Magic words used by Master Prefs files to indicate that internal
+// pages should appear on first run.
+const char* kNewTabMagicWord = "new_tab_page";

[grt (UTC plus 2), 2016/07/29 06:56:15]

use "UrlHost" or something rather than "MagicWord"

[grt (UTC plus 2), 2016/07/29 06:56:15]

constexpr char kNewTabMagicWord[] = ...

[grt (UTC plus 2), 2016/08/01 06:23:14]

I find that "Keyword" is still vague. Neither the constant's name nor the doc
comment that accompanies it convey that the constant is the host part of an URL.
By replacing "Keyword" with "UrlHost" (and updating the comment), I think this
is fairly clear.

[tmartino, 2016/08/02 23:46:50]

Aha! In fact, I've been pointedly avoiding calling these UrlHost because they
explicitly are *not* hosts, or any other part of an actual URL. They're constant
strings, defined by convention, which partners include *in place* of a valid URL
in their Master Prefs file, and which we are replacing with something resolvable
in this function.

[grt (UTC plus 2), 2016/08/04 10:59:27]

I see it from the other side: they are magic values placed in the host portion
of a URL. The fact that they don't resolve is irrelevant. An URL is still an URL
if the host doesn't resolve, and the host portion of the URL is still the host
portion of the URL even if it's gibberish.

+const char* kWelcomePageMagicWord = "welcome_page";
+
 // A bitfield formed from values in AutoImportState to record the state of
 // AutoImport. This is used in testing to verify import startup actions that
 // occur before an observer can be registered in the test.
 uint16_t g_auto_import_state = first_run::AUTO_IMPORT_NONE;
 
 // Flags for functions of similar name.
 bool g_should_show_welcome_page = false;
 bool g_should_do_autofill_personal_data_manager_first_run = false;
 
 // This class acts as an observer for the ImporterProgressObserver::ImportEnded
@@ skipping 389 matching lines @@
             prefs::kDefaultBrowserSettingEnabled)) {
       if (g_browser_process->local_state()->GetBoolean(
           prefs::kDefaultBrowserSettingEnabled)) {
         shell_integration::SetAsDefaultBrowser();
       }
     } else if (make_chrome_default_for_user) {
       shell_integration::SetAsDefaultBrowser();
     }
   }
 }
-

[grt (UTC plus 2), 2016/07/29 06:56:15]

nit: retain this blank line

 }  // namespace
 
 namespace first_run {
 namespace internal {
 
 FirstRunState g_first_run = FIRST_RUN_UNKNOWN;
 
 void SetupMasterPrefsFromInstallPrefs(
     const installer::MasterPreferences& install_prefs,
     MasterPrefs* out_prefs) {
@@ skipping 135 matching lines @@
         base::CommandLine::ForCurrentProcess();
     if (command_line->HasSwitch(switches::kForceFirstRun) ||
         (!command_line->HasSwitch(switches::kNoFirstRun) &&
          !internal::IsFirstRunSentinelPresent())) {
       internal::g_first_run = internal::FIRST_RUN_TRUE;
     }
   }
   return internal::g_first_run == internal::FIRST_RUN_TRUE;
 }
 
+void SetFirstRunForTesting(bool is_first_run) {
+  internal::g_first_run =
+      is_first_run ? internal::FIRST_RUN_TRUE : internal::FIRST_RUN_FALSE;
+}
+
 #if defined(OS_MACOSX)
 bool IsFirstRunSuppressed(const base::CommandLine& command_line) {
   return command_line.HasSwitch(switches::kNoFirstRun);
 }
 #endif
 
 bool IsMetricsReportingOptIn() {
 #if defined(OS_CHROMEOS)
   return false;
 #elif defined(OS_ANDROID)
@@ skipping 47 matching lines @@
 void SetShouldShowWelcomePage() {
   g_should_show_welcome_page = true;
 }
 
 bool ShouldShowWelcomePage() {
   bool retval = g_should_show_welcome_page;
   g_should_show_welcome_page = false;
   return retval;
 }
 
+GURL GetWelcomePageURL() {
+  // TODO(tmartino): Once Consolidated FRE page is implemented, return that
+  // here when kUseConsolidatedFirstRun is true.
+  return GURL(l10n_util::GetStringUTF8(IDS_WELCOME_PAGE_URL));
+}
+
+bool IsWin10() {
+#if defined(OS_WIN)
+  return os_info->version() >= base::win::VERSION_WIN10;

[grt (UTC plus 2), 2016/07/29 06:56:15]

base::win::GetVersion()

and #include "base/win/windows_version.h" wrapped in #if defined(OS_WIN) up
above

+#else
+  return false;
+#endif
+}
+
+std::vector<GURL> GetOnboardingTabs() {
+  std::vector<GURL> tabs;
+  if (IsWin10()) {
+    // TODO(tmartino): Win 10 logic is more complex and will be added in its
+    // own change.
+  } else if (IsChromeFirstRun()) {
+    tabs.push_back(GetWelcomePageURL());
+  }
+  return tabs;
+}
+
+std::vector<GURL> ProcessMasterPrefsTabs(const std::vector<GURL>& tabs) {
+  std::vector<GURL> processed_tabs;
+  if (IsChromeFirstRun()) {
+    for (GURL tab : tabs) {

[grt (UTC plus 2), 2016/07/29 06:56:15]

const GURL& tab to avoid a copy here

+      if (tab.host() == kNewTabMagicWord) {
+        processed_tabs.push_back(GURL(chrome::kChromeUINewTabURL));
+      } else if (tab.host() == kWelcomePageMagicWord) {
+        processed_tabs.push_back(GetWelcomePageURL());
+      } else {
+        processed_tabs.push_back(tab);
+      }
+    }
+  }
+  return processed_tabs;
+}
+
 void SetShouldDoPersonalDataManagerFirstRun() {
   g_should_do_autofill_personal_data_manager_first_run = true;
 }
 
 bool ShouldDoPersonalDataManagerFirstRun() {
   bool retval = g_should_do_autofill_personal_data_manager_first_run;
   g_should_do_autofill_personal_data_manager_first_run = false;
   return retval;
 }
 
@@ skipping 131 matching lines @@
   SetShouldDoPersonalDataManagerFirstRun();
 
   internal::DoPostImportPlatformSpecificTasks(profile);
 }
 
 uint16_t auto_import_state() {
   return g_auto_import_state;
 }
 
 }  // namespace first_run