Show sync promo at startup

chrome/browser/ui/browser_init.cc

 // Copyright (c) 2011 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/ui/browser_init.h"
 
 #include <algorithm>   // For max().
 
 #include "base/compiler_specific.h"
 #include "base/environment.h"
@@ skipping 40 matching lines @@
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/browser/tab_contents/link_infobar_delegate.h"
 #include "chrome/browser/tab_contents/simple_alert_infobar_delegate.h"
 #include "chrome/browser/tabs/pinned_tab_codec.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/webui/sync_promo_ui.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_result_codes.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/child_process_security_policy.h"
@@ skipping 482 matching lines @@
 }
 
 // static
 bool BrowserInit::InProcessStartup() {
   return in_startup;
 }
 
 bool BrowserInit::LaunchBrowser(const CommandLine& command_line,
                                 Profile* profile,
                                 const FilePath& cur_dir,
-                                bool process_startup,
+                                IsProcessStartup process_startup,
+                                IsFirstRun is_first_run,
                                 int* return_code) {
-  in_startup = process_startup;
+  in_startup = process_startup == IS_PROCESS_STARTUP;
   DCHECK(profile);
 
   // Continue with the incognito profile from here on if Incognito mode
   // is forced.
   if (IncognitoIsForced(command_line, profile->GetPrefs())) {
     profile = profile->GetOffTheRecordProfile();
   } else if (command_line.HasSwitch(switches::kIncognito)) {
     LOG(WARNING) << "Incognito mode disabled by policy, launching a normal "
                  << "browser session.";
   }
 
-  BrowserInit::LaunchWithProfile lwp(cur_dir, command_line, this);
+  BrowserInit::LaunchWithProfile lwp(cur_dir, command_line, this, is_first_run);
   std::vector<GURL> urls_to_launch = BrowserInit::GetURLsFromCommandLine(
       command_line, cur_dir, profile);
   bool launched = lwp.Launch(profile, urls_to_launch, process_startup);
   in_startup = false;
 
   if (!launched) {
     LOG(ERROR) << "launch error";
     if (return_code)
       *return_code = chrome::RESULT_CODE_INVALID_CMDLINE_URL;
     return false;
@@ skipping 49 matching lines @@
 
 BrowserInit::LaunchWithProfile::Tab::Tab() : is_app(false), is_pinned(true) {}
 
 BrowserInit::LaunchWithProfile::Tab::~Tab() {}
 
 
 // BrowserInit::LaunchWithProfile ---------------------------------------------
 
 BrowserInit::LaunchWithProfile::LaunchWithProfile(
     const FilePath& cur_dir,
-    const CommandLine& command_line)
+    const CommandLine& command_line,
+    IsFirstRun is_first_run)
         : cur_dir_(cur_dir),
           command_line_(command_line),
           profile_(NULL),
-          browser_init_(NULL) {
+          browser_init_(NULL),
+          is_first_run_(is_first_run) {
 }
 
 BrowserInit::LaunchWithProfile::LaunchWithProfile(
     const FilePath& cur_dir,
     const CommandLine& command_line,
-    BrowserInit* browser_init)
+    BrowserInit* browser_init,
+    IsFirstRun is_first_run)
         : cur_dir_(cur_dir),
           command_line_(command_line),
           profile_(NULL),
-          browser_init_(browser_init) {
+          browser_init_(browser_init),
+          is_first_run_(is_first_run) {
 }
 
 BrowserInit::LaunchWithProfile::~LaunchWithProfile() {
 }
 
 bool BrowserInit::LaunchWithProfile::Launch(
     Profile* profile,
     const std::vector<GURL>& urls_to_open,
     bool process_startup) {
   DCHECK(profile);
@@ skipping 562 matching lines @@
   }
 #endif
 }
 
 void BrowserInit::LaunchWithProfile::AddStartupURLs(
     std::vector<GURL>* startup_urls) const {
   // If we have urls specified beforehand (i.e. from command line) use them
   // and nothing else.
   if (!startup_urls->empty())
     return;
+
   // If we have urls specified by the first run master preferences use them
   // and nothing else.
   if (browser_init_) {
     if (!browser_init_->first_run_tabs_.empty()) {
       std::vector<GURL>::iterator it = browser_init_->first_run_tabs_.begin();
       while (it != browser_init_->first_run_tabs_.end()) {
         // Replace magic names for the actual urls.
         if (it->host() == "new_tab_page") {
-          startup_urls->push_back(GURL(chrome::kChromeUINewTabURL));
+          if (SyncPromoUI::ShouldShowSyncPromoAtStartup(profile_,
+              is_first_run_ == IS_FIRST_RUN)) {
+            SyncPromoUI::DidShowSyncPromoAtStartup(profile_);
+            startup_urls->push_back(GURL(chrome::kChromeUISyncPromoURL));
+          } else {
+            startup_urls->push_back(GURL(chrome::kChromeUINewTabURL));
+          }
         } else if (it->host() == "welcome_page") {
           startup_urls->push_back(GetWelcomePageURL());
         } else {
           startup_urls->push_back(*it);
         }
         ++it;
       }
       browser_init_->first_run_tabs_.clear();
       return;
     }
   }
 
   // Otherwise open at least the new tab page (and the welcome page, if this
   // is the first time the browser is being started), or the set of URLs
   // specified on the command line.
-  startup_urls->push_back(GURL());  // New tab page.
+  if (SyncPromoUI::ShouldShowSyncPromoAtStartup(profile_,
+      is_first_run_ == IS_FIRST_RUN)) {
+    SyncPromoUI::DidShowSyncPromoAtStartup(profile_);
+    startup_urls->push_back(GURL(chrome::kChromeUISyncPromoURL));
+  } else {
+    startup_urls->push_back(GURL());  // New tab page.
+  }
   PrefService* prefs = g_browser_process->local_state();
   if (prefs->FindPreference(prefs::kShouldShowWelcomePage) &&
       prefs->GetBoolean(prefs::kShouldShowWelcomePage)) {
     // Reset the preference so we don't show the welcome page next time.
+    startup_urls->push_back(GURL());  // New tab page.

[sky, 2011/10/04 20:13:23]

Might 1286 have already added this?

[sail, 2011/10/04 20:56:24]

Ouch, good catch. Don't know how that line got there.
Fixed.

     prefs->ClearPref(prefs::kShouldShowWelcomePage);
     startup_urls->push_back(GetWelcomePageURL());
   }
 }
 
 void BrowserInit::LaunchWithProfile::CheckDefaultBrowser(Profile* profile) {
   // We do not check if we are the default browser if:
   // - the user said "don't ask me again" on the infobar earlier.
   // - this is the first launch after the first run flow.
   // - There is a policy in control of this setting.
   if (!profile->GetPrefs()->GetBoolean(prefs::kCheckDefaultBrowser) ||
-      FirstRun::IsChromeFirstRun()) {
+      is_first_run_ == IS_FIRST_RUN) {
     return;
   }
   if (g_browser_process->local_state()->IsManagedPreference(
       prefs::kDefaultBrowserSettingEnabled)) {
     if (g_browser_process->local_state()->GetBoolean(
         prefs::kDefaultBrowserSettingEnabled)) {
       BrowserThread::PostTask(
           BrowserThread::FILE, FROM_HERE, NewRunnableFunction(
               &ShellIntegration::SetAsDefaultBrowser));
     } else {
@@ skipping 185 matching lines @@
         DLOG(WARNING) << "Invalid touch-device id: " << *iter;
       }
     }
     ui::TouchFactory::GetInstance()->SetTouchDeviceList(device_ids);
   }
 #endif
 
   // If we don't want to launch a new browser window or tab (in the case
   // of an automation request), we are done here.
   if (!silent_launch) {
-    return browser_init->LaunchBrowser(
-        command_line, profile, cur_dir, process_startup, return_code);
+    IsProcessStartup is_process_startup = process_startup ?
+        IS_PROCESS_STARTUP : IS_NOT_PROCESS_STARTUP;
+    IsFirstRun is_first_run = FirstRun::IsChromeFirstRun() ?
+        IS_FIRST_RUN : IS_NOT_FIRST_RUN;
+    return browser_init->LaunchBrowser(command_line, profile, cur_dir,
+        is_process_startup, is_first_run, return_code);
   }
   return true;
 }
 
 template <class AutomationProviderClass>
 bool BrowserInit::CreateAutomationProvider(const std::string& channel_id,
                                            Profile* profile,
                                            size_t expected_tabs) {
   scoped_refptr<AutomationProviderClass> automation =
       new AutomationProviderClass(profile);
 
   if (!automation->InitializeChannel(channel_id))
     return false;
   automation->SetExpectedTabCount(expected_tabs);
 
   AutomationProviderList* list = g_browser_process->GetAutomationProviderList();
   DCHECK(list);
   list->AddProvider(automation);
 
   return true;
 }