first_run.cc revision ba5b9a6411cb1792fd21f0a078d7a25cd1ceec16 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/first_run/first_run.h"
6
7#include <algorithm>
8
9#include "base/command_line.h"
10#include "base/compiler_specific.h"
11#include "base/file_util.h"
12#include "base/files/file_path.h"
13#include "base/lazy_instance.h"
14#include "base/memory/ref_counted.h"
15#include "base/message_loop/message_loop.h"
16#include "base/metrics/histogram.h"
17#include "base/path_service.h"
18#include "base/prefs/pref_service.h"
19#include "base/strings/stringprintf.h"
20#include "base/strings/utf_string_conversions.h"
21#include "build/build_config.h"
22#include "chrome/browser/browser_process.h"
23#include "chrome/browser/chrome_notification_types.h"
24#include "chrome/browser/extensions/extension_service.h"
25#include "chrome/browser/extensions/updater/extension_updater.h"
26#include "chrome/browser/first_run/first_run_internal.h"
27#include "chrome/browser/google/google_util.h"
28#include "chrome/browser/importer/external_process_importer_host.h"
29#include "chrome/browser/importer/importer_list.h"
30#include "chrome/browser/importer/importer_progress_observer.h"
31#include "chrome/browser/importer/importer_uma.h"
32#include "chrome/browser/importer/profile_writer.h"
33#include "chrome/browser/profiles/profiles_state.h"
34#include "chrome/browser/search_engines/template_url_service.h"
35#include "chrome/browser/search_engines/template_url_service_factory.h"
36#include "chrome/browser/shell_integration.h"
37#include "chrome/browser/signin/signin_manager.h"
38#include "chrome/browser/signin/signin_manager_factory.h"
39#include "chrome/browser/signin/signin_promo.h"
40#include "chrome/browser/signin/signin_tracker.h"
41#include "chrome/browser/ui/browser.h"
42#include "chrome/browser/ui/browser_finder.h"
43#include "chrome/browser/ui/global_error/global_error_service.h"
44#include "chrome/browser/ui/global_error/global_error_service_factory.h"
45#include "chrome/browser/ui/tabs/tab_strip_model.h"
46#include "chrome/browser/ui/webui/ntp/new_tab_ui.h"
47#include "chrome/common/chrome_paths.h"
48#include "chrome/common/chrome_switches.h"
49#include "chrome/common/pref_names.h"
50#include "chrome/common/url_constants.h"
51#include "chrome/installer/util/master_preferences.h"
52#include "chrome/installer/util/master_preferences_constants.h"
53#include "chrome/installer/util/util_constants.h"
54#include "components/user_prefs/pref_registry_syncable.h"
55#include "content/public/browser/notification_observer.h"
56#include "content/public/browser/notification_registrar.h"
57#include "content/public/browser/notification_service.h"
58#include "content/public/browser/notification_types.h"
59#include "content/public/browser/user_metrics.h"
60#include "content/public/browser/web_contents.h"
61#include "google_apis/gaia/gaia_auth_util.h"
62#include "url/gurl.h"
63
64using content::UserMetricsAction;
65
66namespace {
67
68// A bitfield formed from values in AutoImportState to record the state of
69// AutoImport. This is used in testing to verify import startup actions that
70// occur before an observer can be registered in the test.
71uint16 g_auto_import_state = first_run::AUTO_IMPORT_NONE;
72
73// Flags for functions of similar name.
74bool g_should_show_welcome_page = false;
75bool g_should_do_autofill_personal_data_manager_first_run = false;
76
77// This class acts as an observer for the ImporterProgressObserver::ImportEnded
78// callback. When the import process is started, certain errors may cause
79// ImportEnded() to be called synchronously, but the typical case is that
80// ImportEnded() is called asynchronously. Thus we have to handle both cases.
81class ImportEndedObserver : public importer::ImporterProgressObserver {
82 public:
83  ImportEndedObserver() : ended_(false),
84                          should_quit_message_loop_(false) {}
85  virtual ~ImportEndedObserver() {}
86
87  // importer::ImporterProgressObserver:
88  virtual void ImportStarted() OVERRIDE {}
89  virtual void ImportItemStarted(importer::ImportItem item) OVERRIDE {}
90  virtual void ImportItemEnded(importer::ImportItem item) OVERRIDE {}
91  virtual void ImportEnded() OVERRIDE {
92    ended_ = true;
93    if (should_quit_message_loop_)
94      base::MessageLoop::current()->Quit();
95  }
96
97  void set_should_quit_message_loop() {
98    should_quit_message_loop_ = true;
99  }
100
101  bool ended() const {
102    return ended_;
103  }
104
105 private:
106  // Set if the import has ended.
107  bool ended_;
108
109  bool should_quit_message_loop_;
110};
111
112// Helper class that performs delayed first-run tasks that need more of the
113// chrome infrastructure to be up and running before they can be attempted.
114class FirstRunDelayedTasks : public content::NotificationObserver {
115 public:
116  enum Tasks {
117    NO_TASK,
118    INSTALL_EXTENSIONS
119  };
120
121  explicit FirstRunDelayedTasks(Tasks task) {
122    if (task == INSTALL_EXTENSIONS) {
123      registrar_.Add(this, chrome::NOTIFICATION_EXTENSIONS_READY,
124                     content::NotificationService::AllSources());
125    }
126    registrar_.Add(this, chrome::NOTIFICATION_BROWSER_CLOSED,
127                   content::NotificationService::AllSources());
128  }
129
130  virtual void Observe(int type,
131                       const content::NotificationSource& source,
132                       const content::NotificationDetails& details) OVERRIDE {
133    // After processing the notification we always delete ourselves.
134    if (type == chrome::NOTIFICATION_EXTENSIONS_READY) {
135      DoExtensionWork(
136          content::Source<Profile>(source).ptr()->GetExtensionService());
137    }
138    delete this;
139  }
140
141 private:
142  // Private ctor forces it to be created only in the heap.
143  virtual ~FirstRunDelayedTasks() {}
144
145  // The extension work is to basically trigger an extension update check.
146  // If the extension specified in the master pref is older than the live
147  // extension it will get updated which is the same as get it installed.
148  void DoExtensionWork(ExtensionService* service) {
149    if (service)
150      service->updater()->CheckNow(extensions::ExtensionUpdater::CheckParams());
151  }
152
153  content::NotificationRegistrar registrar_;
154};
155
156// Installs a task to do an extensions update check once the extensions system
157// is running.
158void DoDelayedInstallExtensions() {
159  new FirstRunDelayedTasks(FirstRunDelayedTasks::INSTALL_EXTENSIONS);
160}
161
162void DoDelayedInstallExtensionsIfNeeded(
163    installer::MasterPreferences* install_prefs) {
164  DictionaryValue* extensions = 0;
165  if (install_prefs->GetExtensionsBlock(&extensions)) {
166    VLOG(1) << "Extensions block found in master preferences";
167    DoDelayedInstallExtensions();
168  }
169}
170
171base::FilePath GetDefaultPrefFilePath(bool create_profile_dir,
172                                      const base::FilePath& user_data_dir) {
173  base::FilePath default_pref_dir =
174      profiles::GetDefaultProfileDir(user_data_dir);
175  if (create_profile_dir) {
176    if (!base::PathExists(default_pref_dir)) {
177      if (!file_util::CreateDirectory(default_pref_dir))
178        return base::FilePath();
179    }
180  }
181  return profiles::GetProfilePrefsPath(default_pref_dir);
182}
183
184// Sets the |items| bitfield according to whether the import data specified by
185// |import_type| should be be auto imported or not.
186void SetImportItem(PrefService* user_prefs,
187                   const char* pref_path,
188                   int import_items,
189                   int dont_import_items,
190                   importer::ImportItem import_type,
191                   int* items) {
192  // Work out whether an item is to be imported according to what is specified
193  // in master preferences.
194  bool should_import = false;
195  bool master_pref_set =
196      ((import_items | dont_import_items) & import_type) != 0;
197  bool master_pref = ((import_items & ~dont_import_items) & import_type) != 0;
198
199  if (import_type == importer::HISTORY ||
200      (import_type != importer::FAVORITES &&
201       first_run::internal::IsOrganicFirstRun())) {
202    // History is always imported unless turned off in master_preferences.
203    // Search engines and home page are imported in organic builds only
204    // unless turned off in master_preferences.
205    should_import = !master_pref_set || master_pref;
206  } else {
207    // Bookmarks are never imported, unless turned on in master_preferences.
208    // Search engine and home page import behaviour is similar in non organic
209    // builds.
210    should_import = master_pref_set && master_pref;
211  }
212
213  // If an import policy is set, import items according to policy. If no master
214  // preference is set, but a corresponding recommended policy is set, import
215  // item according to recommended policy. If both a master preference and a
216  // recommended policy is set, the master preference wins. If neither
217  // recommended nor managed policies are set, import item according to what we
218  // worked out above.
219  if (master_pref_set)
220    user_prefs->SetBoolean(pref_path, should_import);
221
222  if (!user_prefs->FindPreference(pref_path)->IsDefaultValue()) {
223    if (user_prefs->GetBoolean(pref_path))
224      *items |= import_type;
225  } else { // no policy (recommended or managed) is set
226    if (should_import)
227      *items |= import_type;
228  }
229
230  user_prefs->ClearPref(pref_path);
231}
232
233// Launches the import, via |importer_host|, from |source_profile| into
234// |target_profile| for the items specified in the |items_to_import| bitfield.
235// This may be done in a separate process depending on the platform, but it will
236// always block until done.
237void ImportFromSourceProfile(ExternalProcessImporterHost* importer_host,
238                             const importer::SourceProfile& source_profile,
239                             Profile* target_profile,
240                             uint16 items_to_import) {
241  ImportEndedObserver observer;
242  importer_host->set_observer(&observer);
243  importer_host->StartImportSettings(source_profile,
244                                     target_profile,
245                                     items_to_import,
246                                     new ProfileWriter(target_profile));
247  // If the import process has not errored out, block on it.
248  if (!observer.ended()) {
249    observer.set_should_quit_message_loop();
250    base::MessageLoop::current()->Run();
251  }
252}
253
254// Imports bookmarks from an html file whose path is provided by
255// |import_bookmarks_path|.
256void ImportFromFile(Profile* profile,
257                    ExternalProcessImporterHost* file_importer_host,
258                    const std::string& import_bookmarks_path) {
259  importer::SourceProfile source_profile;
260  source_profile.importer_type = importer::TYPE_BOOKMARKS_FILE;
261
262  const base::FilePath::StringType& import_bookmarks_path_str =
263#if defined(OS_WIN)
264      UTF8ToUTF16(import_bookmarks_path);
265#else
266      import_bookmarks_path;
267#endif
268  source_profile.source_path = base::FilePath(import_bookmarks_path_str);
269
270  ImportFromSourceProfile(file_importer_host, source_profile, profile,
271                          importer::FAVORITES);
272  g_auto_import_state |= first_run::AUTO_IMPORT_BOOKMARKS_FILE_IMPORTED;
273}
274
275// Imports settings from the first profile in |importer_list|.
276void ImportSettings(Profile* profile,
277                    ExternalProcessImporterHost* importer_host,
278                    scoped_refptr<ImporterList> importer_list,
279                    int items_to_import) {
280  const importer::SourceProfile& source_profile =
281      importer_list->GetSourceProfileAt(0);
282
283  // Ensure that importers aren't requested to import items that they do not
284  // support. If there is no overlap, skip.
285  items_to_import &= source_profile.services_supported;
286  if (items_to_import == 0)
287    return;
288
289  ImportFromSourceProfile(importer_host, source_profile, profile,
290                          items_to_import);
291  g_auto_import_state |= first_run::AUTO_IMPORT_PROFILE_IMPORTED;
292}
293
294GURL UrlFromString(const std::string& in) {
295  return GURL(in);
296}
297
298void ConvertStringVectorToGURLVector(
299    const std::vector<std::string>& src,
300    std::vector<GURL>* ret) {
301  ret->resize(src.size());
302  std::transform(src.begin(), src.end(), ret->begin(), &UrlFromString);
303}
304
305// Show the first run search engine bubble at the first appropriate opportunity.
306// This bubble may be delayed by other UI, like global errors and sync promos.
307class FirstRunBubbleLauncher : public content::NotificationObserver {
308 public:
309  // Show the bubble at the first appropriate opportunity. This function
310  // instantiates a FirstRunBubbleLauncher, which manages its own lifetime.
311  static void ShowFirstRunBubbleSoon();
312
313 private:
314  FirstRunBubbleLauncher();
315  virtual ~FirstRunBubbleLauncher();
316
317  // content::NotificationObserver:
318  virtual void Observe(int type,
319                       const content::NotificationSource& source,
320                       const content::NotificationDetails& details) OVERRIDE;
321
322  content::NotificationRegistrar registrar_;
323
324  DISALLOW_COPY_AND_ASSIGN(FirstRunBubbleLauncher);
325};
326
327// static
328void FirstRunBubbleLauncher::ShowFirstRunBubbleSoon() {
329  SetShowFirstRunBubblePref(first_run::FIRST_RUN_BUBBLE_SHOW);
330  // This FirstRunBubbleLauncher instance will manage its own lifetime.
331  new FirstRunBubbleLauncher();
332}
333
334FirstRunBubbleLauncher::FirstRunBubbleLauncher() {
335  registrar_.Add(this, content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
336                 content::NotificationService::AllSources());
337
338  // This notification is required to observe the switch between the sync setup
339  // page and the general settings page.
340  registrar_.Add(this, chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED,
341                 content::NotificationService::AllSources());
342}
343
344FirstRunBubbleLauncher::~FirstRunBubbleLauncher() {}
345
346void FirstRunBubbleLauncher::Observe(
347    int type,
348    const content::NotificationSource& source,
349    const content::NotificationDetails& details) {
350  DCHECK(type == content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME ||
351         type == chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED);
352
353  Browser* browser = chrome::FindBrowserWithWebContents(
354      content::Source<content::WebContents>(source).ptr());
355  if (!browser || !browser->is_type_tabbed())
356    return;
357
358  // Check the preference to determine if the bubble should be shown.
359  PrefService* prefs = g_browser_process->local_state();
360  if (!prefs || prefs->GetInteger(prefs::kShowFirstRunBubbleOption) !=
361      first_run::FIRST_RUN_BUBBLE_SHOW) {
362    delete this;
363    return;
364  }
365
366  content::WebContents* contents =
367      browser->tab_strip_model()->GetActiveWebContents();
368
369  // Suppress the first run bubble if a Gaia sign in page, the continue
370  // URL for the sign in page or the sync setup page is showing.
371  if (contents &&
372      (gaia::IsGaiaSignonRealm(contents->GetURL().GetOrigin()) ||
373       signin::IsContinueUrlForWebBasedSigninFlow(contents->GetURL()) ||
374       contents->GetURL() == GURL(std::string(chrome::kChromeUISettingsURL) +
375                                  chrome::kSyncSetupSubPage))) {
376    return;
377  }
378
379  if (contents && contents->GetURL().SchemeIs(chrome::kChromeUIScheme)) {
380    // Suppress the first run bubble if 'make chrome metro' flow is showing.
381    if (contents->GetURL().host() == chrome::kChromeUIMetroFlowHost)
382      return;
383
384    // Suppress the first run bubble if the NTP sync promo bubble is showing
385    // or if sign in is in progress.
386    if (contents->GetURL().host() == chrome::kChromeUINewTabHost) {
387      Profile* profile =
388          Profile::FromBrowserContext(contents->GetBrowserContext());
389      SigninManagerBase* manager =
390          SigninManagerFactory::GetForProfile(profile);
391      bool signin_in_progress = manager &&
392          (!manager->GetAuthenticatedUsername().empty() &&
393              SigninTracker::GetSigninState(profile, NULL) !=
394                  SigninTracker::SIGNIN_COMPLETE);
395      bool is_promo_bubble_visible =
396          profile->GetPrefs()->GetBoolean(prefs::kSignInPromoShowNTPBubble);
397
398      if (is_promo_bubble_visible || signin_in_progress)
399        return;
400    }
401  }
402
403  // Suppress the first run bubble if a global error bubble is pending.
404  GlobalErrorService* global_error_service =
405      GlobalErrorServiceFactory::GetForProfile(browser->profile());
406  if (global_error_service->GetFirstGlobalErrorWithBubbleView() != NULL)
407    return;
408
409  // Reset the preference and notifications to avoid showing the bubble again.
410  prefs->SetInteger(prefs::kShowFirstRunBubbleOption,
411                    first_run::FIRST_RUN_BUBBLE_DONT_SHOW);
412
413  // Show the bubble now and destroy this bubble launcher.
414  browser->ShowFirstRunBubble();
415  delete this;
416}
417
418}  // namespace
419
420namespace first_run {
421namespace internal {
422
423FirstRunState first_run_ = FIRST_RUN_UNKNOWN;
424
425static base::LazyInstance<base::FilePath> master_prefs_path_for_testing
426    = LAZY_INSTANCE_INITIALIZER;
427
428installer::MasterPreferences*
429    LoadMasterPrefs(base::FilePath* master_prefs_path) {
430  if (!master_prefs_path_for_testing.Get().empty())
431    *master_prefs_path = master_prefs_path_for_testing.Get();
432  else
433    *master_prefs_path = base::FilePath(MasterPrefsPath());
434  if (master_prefs_path->empty())
435    return NULL;
436  installer::MasterPreferences* install_prefs =
437      new installer::MasterPreferences(*master_prefs_path);
438  if (!install_prefs->read_from_file()) {
439    delete install_prefs;
440    return NULL;
441  }
442
443  return install_prefs;
444}
445
446bool CopyPrefFile(const base::FilePath& user_data_dir,
447                  const base::FilePath& master_prefs_path) {
448  base::FilePath user_prefs = GetDefaultPrefFilePath(true, user_data_dir);
449  if (user_prefs.empty())
450    return false;
451
452  // The master prefs are regular prefs so we can just copy the file
453  // to the default place and they just work.
454  return base::CopyFile(master_prefs_path, user_prefs);
455}
456
457void SetupMasterPrefsFromInstallPrefs(
458    const installer::MasterPreferences& install_prefs,
459    MasterPrefs* out_prefs) {
460  ConvertStringVectorToGURLVector(
461      install_prefs.GetFirstRunTabs(), &out_prefs->new_tabs);
462
463  install_prefs.GetInt(installer::master_preferences::kDistroPingDelay,
464                       &out_prefs->ping_delay);
465
466  bool value = false;
467  if (install_prefs.GetBool(
468          installer::master_preferences::kDistroImportSearchPref, &value)) {
469    if (value) {
470      out_prefs->do_import_items |= importer::SEARCH_ENGINES;
471    } else {
472      out_prefs->dont_import_items |= importer::SEARCH_ENGINES;
473    }
474  }
475
476  // If we're suppressing the first-run bubble, set that preference now.
477  // Otherwise, wait until the user has completed first run to set it, so the
478  // user is guaranteed to see the bubble iff he or she has completed the first
479  // run process.
480  if (install_prefs.GetBool(
481          installer::master_preferences::kDistroSuppressFirstRunBubble,
482          &value) && value)
483    SetShowFirstRunBubblePref(FIRST_RUN_BUBBLE_SUPPRESS);
484
485  if (install_prefs.GetBool(
486          installer::master_preferences::kDistroImportHistoryPref,
487          &value)) {
488    if (value) {
489      out_prefs->do_import_items |= importer::HISTORY;
490    } else {
491      out_prefs->dont_import_items |= importer::HISTORY;
492    }
493  }
494
495  std::string not_used;
496  out_prefs->homepage_defined = install_prefs.GetString(
497      prefs::kHomePage, &not_used);
498
499  if (install_prefs.GetBool(
500          installer::master_preferences::kDistroImportHomePagePref,
501          &value)) {
502    if (value) {
503      out_prefs->do_import_items |= importer::HOME_PAGE;
504    } else {
505      out_prefs->dont_import_items |= importer::HOME_PAGE;
506    }
507  }
508
509  // Bookmarks are never imported unless specifically turned on.
510  if (install_prefs.GetBool(
511          installer::master_preferences::kDistroImportBookmarksPref,
512          &value)) {
513    if (value)
514      out_prefs->do_import_items |= importer::FAVORITES;
515    else
516      out_prefs->dont_import_items |= importer::FAVORITES;
517  }
518
519  if (install_prefs.GetBool(
520          installer::master_preferences::kMakeChromeDefaultForUser,
521          &value) && value) {
522    out_prefs->make_chrome_default = true;
523  }
524
525  if (install_prefs.GetBool(
526          installer::master_preferences::kSuppressFirstRunDefaultBrowserPrompt,
527          &value) && value) {
528    out_prefs->suppress_first_run_default_browser_prompt = true;
529  }
530
531  install_prefs.GetString(
532      installer::master_preferences::kDistroImportBookmarksFromFilePref,
533      &out_prefs->import_bookmarks_path);
534
535  out_prefs->variations_seed = install_prefs.GetVariationsSeed();
536
537  install_prefs.GetString(
538      installer::master_preferences::kDistroSuppressDefaultBrowserPromptPref,
539      &out_prefs->suppress_default_browser_prompt_for_version);
540}
541
542void SetDefaultBrowser(installer::MasterPreferences* install_prefs){
543  // Even on the first run we only allow for the user choice to take effect if
544  // no policy has been set by the admin.
545  if (!g_browser_process->local_state()->IsManagedPreference(
546          prefs::kDefaultBrowserSettingEnabled)) {
547    bool value = false;
548    if (install_prefs->GetBool(
549            installer::master_preferences::kMakeChromeDefaultForUser,
550            &value) && value) {
551      ShellIntegration::SetAsDefaultBrowser();
552    }
553  } else {
554    if (g_browser_process->local_state()->GetBoolean(
555            prefs::kDefaultBrowserSettingEnabled)) {
556      ShellIntegration::SetAsDefaultBrowser();
557    }
558  }
559}
560
561bool CreateSentinel() {
562  base::FilePath first_run_sentinel;
563  if (!internal::GetFirstRunSentinelFilePath(&first_run_sentinel))
564    return false;
565  return file_util::WriteFile(first_run_sentinel, "", 0) != -1;
566}
567
568// -- Platform-specific functions --
569
570#if !defined(OS_LINUX) && !defined(OS_BSD)
571bool IsOrganicFirstRun() {
572  std::string brand;
573  google_util::GetBrand(&brand);
574  return google_util::IsOrganicFirstRun(brand);
575}
576#endif
577
578}  // namespace internal
579
580MasterPrefs::MasterPrefs()
581    : ping_delay(0),
582      homepage_defined(false),
583      do_import_items(0),
584      dont_import_items(0),
585      make_chrome_default(false),
586      suppress_first_run_default_browser_prompt(false) {
587}
588
589MasterPrefs::~MasterPrefs() {}
590
591bool IsChromeFirstRun() {
592  if (internal::first_run_ != internal::FIRST_RUN_UNKNOWN)
593    return internal::first_run_ == internal::FIRST_RUN_TRUE;
594
595  internal::first_run_ = internal::FIRST_RUN_FALSE;
596
597  base::FilePath first_run_sentinel;
598  const CommandLine* command_line = CommandLine::ForCurrentProcess();
599  if (command_line->HasSwitch(switches::kForceFirstRun)) {
600    internal::first_run_ = internal::FIRST_RUN_TRUE;
601  } else if (command_line->HasSwitch(switches::kCancelFirstRun)) {
602    internal::first_run_ = internal::FIRST_RUN_CANCEL;
603  } else if (!command_line->HasSwitch(switches::kNoFirstRun) &&
604             internal::GetFirstRunSentinelFilePath(&first_run_sentinel) &&
605             !base::PathExists(first_run_sentinel)) {
606    internal::first_run_ = internal::FIRST_RUN_TRUE;
607  }
608
609  return internal::first_run_ == internal::FIRST_RUN_TRUE;
610}
611
612bool IsFirstRunSuppressed(const CommandLine& command_line) {
613  return command_line.HasSwitch(switches::kCancelFirstRun) ||
614      command_line.HasSwitch(switches::kNoFirstRun);
615}
616
617void CreateSentinelIfNeeded() {
618  if (IsChromeFirstRun() ||
619      internal::first_run_ == internal::FIRST_RUN_CANCEL) {
620    internal::CreateSentinel();
621  }
622}
623
624std::string GetPingDelayPrefName() {
625  return base::StringPrintf("%s.%s",
626                            installer::master_preferences::kDistroDict,
627                            installer::master_preferences::kDistroPingDelay);
628}
629
630void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
631  registry->RegisterIntegerPref(
632      GetPingDelayPrefName().c_str(),
633      0,
634      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
635}
636
637bool RemoveSentinel() {
638  base::FilePath first_run_sentinel;
639  if (!internal::GetFirstRunSentinelFilePath(&first_run_sentinel))
640    return false;
641  return base::DeleteFile(first_run_sentinel, false);
642}
643
644bool SetShowFirstRunBubblePref(FirstRunBubbleOptions show_bubble_option) {
645  PrefService* local_state = g_browser_process->local_state();
646  if (!local_state)
647    return false;
648  if (local_state->GetInteger(
649          prefs::kShowFirstRunBubbleOption) != FIRST_RUN_BUBBLE_SUPPRESS) {
650    // Set the new state as long as the bubble wasn't explicitly suppressed
651    // already.
652    local_state->SetInteger(prefs::kShowFirstRunBubbleOption,
653                            show_bubble_option);
654  }
655  return true;
656}
657
658void SetShouldShowWelcomePage() {
659  g_should_show_welcome_page = true;
660}
661
662bool ShouldShowWelcomePage() {
663  bool retval = g_should_show_welcome_page;
664  g_should_show_welcome_page = false;
665  return retval;
666}
667
668void SetShouldDoPersonalDataManagerFirstRun() {
669  g_should_do_autofill_personal_data_manager_first_run = true;
670}
671
672bool ShouldDoPersonalDataManagerFirstRun() {
673  bool retval = g_should_do_autofill_personal_data_manager_first_run;
674  g_should_do_autofill_personal_data_manager_first_run = false;
675  return retval;
676}
677
678void LogFirstRunMetric(FirstRunBubbleMetric metric) {
679  UMA_HISTOGRAM_ENUMERATION("FirstRun.SearchEngineBubble", metric,
680                            NUM_FIRST_RUN_BUBBLE_METRICS);
681}
682
683void SetMasterPrefsPathForTesting(const base::FilePath& master_prefs) {
684  internal::master_prefs_path_for_testing.Get() = master_prefs;
685}
686
687ProcessMasterPreferencesResult ProcessMasterPreferences(
688    const base::FilePath& user_data_dir,
689    MasterPrefs* out_prefs) {
690  DCHECK(!user_data_dir.empty());
691
692  base::FilePath master_prefs_path;
693  scoped_ptr<installer::MasterPreferences>
694      install_prefs(internal::LoadMasterPrefs(&master_prefs_path));
695
696  // Default value in case master preferences is missing or corrupt, or
697  // ping_delay is missing.
698  out_prefs->ping_delay = 90;
699  if (install_prefs.get()) {
700    if (!internal::ShowPostInstallEULAIfNeeded(install_prefs.get()))
701      return EULA_EXIT_NOW;
702
703    if (!internal::CopyPrefFile(user_data_dir, master_prefs_path))
704      DLOG(ERROR) << "Failed to copy master_preferences to user data dir.";
705
706    DoDelayedInstallExtensionsIfNeeded(install_prefs.get());
707
708    internal::SetupMasterPrefsFromInstallPrefs(*install_prefs, out_prefs);
709
710    internal::SetDefaultBrowser(install_prefs.get());
711  }
712
713  return FIRST_RUN_PROCEED;
714}
715
716void AutoImport(
717    Profile* profile,
718    bool homepage_defined,
719    int import_items,
720    int dont_import_items,
721    const std::string& import_bookmarks_path) {
722  // Deletes itself.
723  ExternalProcessImporterHost* importer_host = new ExternalProcessImporterHost;
724
725  base::FilePath local_state_path;
726  PathService::Get(chrome::FILE_LOCAL_STATE, &local_state_path);
727  bool local_state_file_exists = base::PathExists(local_state_path);
728
729  scoped_refptr<ImporterList> importer_list(new ImporterList());
730  importer_list->DetectSourceProfilesHack(
731      g_browser_process->GetApplicationLocale());
732
733  // Do import if there is an available profile for us to import.
734  if (importer_list->count() > 0) {
735    // Don't show the warning dialog if import fails.
736    importer_host->set_headless();
737    int items = 0;
738
739    if (internal::IsOrganicFirstRun()) {
740      // Home page is imported in organic builds only unless turned off or
741      // defined in master_preferences.
742      if (homepage_defined) {
743        dont_import_items |= importer::HOME_PAGE;
744        if (import_items & importer::HOME_PAGE)
745          import_items &= ~importer::HOME_PAGE;
746      }
747      // Search engines are not imported automatically in organic builds if the
748      // user already has a user preferences directory.
749      if (local_state_file_exists) {
750        dont_import_items |= importer::SEARCH_ENGINES;
751        if (import_items & importer::SEARCH_ENGINES)
752          import_items &= ~importer::SEARCH_ENGINES;
753      }
754    }
755
756    PrefService* user_prefs = profile->GetPrefs();
757
758    SetImportItem(user_prefs,
759                  prefs::kImportHistory,
760                  import_items,
761                  dont_import_items,
762                  importer::HISTORY,
763                  &items);
764    SetImportItem(user_prefs,
765                  prefs::kImportHomepage,
766                  import_items,
767                  dont_import_items,
768                  importer::HOME_PAGE,
769                  &items);
770    SetImportItem(user_prefs,
771                  prefs::kImportSearchEngine,
772                  import_items,
773                  dont_import_items,
774                  importer::SEARCH_ENGINES,
775                  &items);
776    SetImportItem(user_prefs,
777                  prefs::kImportBookmarks,
778                  import_items,
779                  dont_import_items,
780                  importer::FAVORITES,
781                  &items);
782
783    importer::LogImporterUseToMetrics(
784        "AutoImport", importer_list->GetSourceProfileAt(0).importer_type);
785
786    ImportSettings(profile, importer_host, importer_list, items);
787  }
788
789  if (!import_bookmarks_path.empty()) {
790    // Deletes itself.
791    ExternalProcessImporterHost* file_importer_host =
792        new ExternalProcessImporterHost;
793    file_importer_host->set_headless();
794
795    ImportFromFile(profile, file_importer_host, import_bookmarks_path);
796  }
797
798  content::RecordAction(UserMetricsAction("FirstRunDef_Accept"));
799
800  g_auto_import_state |= AUTO_IMPORT_CALLED;
801}
802
803void DoPostImportTasks(Profile* profile, bool make_chrome_default) {
804  if (make_chrome_default &&
805      ShellIntegration::CanSetAsDefaultBrowser() ==
806          ShellIntegration::SET_DEFAULT_UNATTENDED) {
807    ShellIntegration::SetAsDefaultBrowser();
808  }
809
810  // Display the first run bubble if there is a default search provider.
811  TemplateURLService* template_url =
812      TemplateURLServiceFactory::GetForProfile(profile);
813  if (template_url && template_url->GetDefaultSearchProvider())
814    FirstRunBubbleLauncher::ShowFirstRunBubbleSoon();
815  SetShouldShowWelcomePage();
816  SetShouldDoPersonalDataManagerFirstRun();
817
818  internal::DoPostImportPlatformSpecificTasks(profile);
819}
820
821uint16 auto_import_state() {
822  return g_auto_import_state;
823}
824
825}  // namespace first_run
826