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";
+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();
     }
   }
 }
-
 }  // 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) {
+  if (is_first_run) {
+    internal::g_first_run = internal::FIRST_RUN_TRUE;
+  } else {
+    internal::g_first_run = internal::FIRST_RUN_FALSE;
+  }
+}

[Roger Tawa OOO till Jul 10th, 2016/07/26 15:00:26]

Nit:

  internal::g_first_run =
      is_first_run ? internal::FIRST_RUN_TRUE
                   : internal::FIRST_RUN_FALSE;

[tmartino, 2016/07/27 18:40:43]

Done.

+
 #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() {
+  if (base::FeatureList::IsEnabled(features::kUseNewFirstRun)) {
+    return GURL("http://www.startribune.com");
+  } else {
+    return GURL(l10n_util::GetStringUTF8(IDS_WELCOME_PAGE_URL));
+  }
+}
+
+bool IsWin10() {
+#if defined(OS_WIN)
+  return os_info->version() >= base::win::VERSION_WIN10;
+#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.
+    NOTREACHED();
+  } else if (IsChromeFirstRun()) {
+    tabs.push_back(GetWelcomePageURL());
+  }
+  return tabs;
+}

[Roger Tawa OOO till Jul 10th, 2016/07/26 15:00:26]

Might be better to move some parts of GetOnboardingTabs() to internal:: so that
each platform can have its own logic.  Probably shouldn't NOTREACHED() if the
win10 changes will be implemented in a followup CL :-)

[tmartino, 2016/07/27 18:40:43]

Hmm. I've thought about this a bit and the best way to structure it using
internal:: still isn't clear to me. The issue is that our division is not
actually "here is the mac code, here is the windows code" etc. To use
platform-specific logic, it'd look like:

_win.cc:
if (IsWin10()) {
  // Do special flow
} else {
  // Same code on all platforms
}

_mac.cc:
// Same code on all platforms

_linux.cc:
// Same code on all platforms

_posix.cc:
// Same code on all platforms

Now, when the time comes to resolve the TODO here and add Win10-specific logic,
I'm completely OK with having that logic live in _win.cc and simply invoking it
from here.

+
+std::vector<GURL> ProcessMasterPrefsTabs(const std::vector<GURL>& tabs) {
+  std::vector<GURL> processed_tabs;
+  if (IsChromeFirstRun()) {
+    for (GURL tab : tabs) {
+      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