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