Add search engine selection dialog for Mac....

chrome/browser/first_run/first_run.cc

 // Copyright (c) 2010 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 "build/build_config.h"
 
 // TODO(port): move more code in back from the first_run_win.cc module.
 
@@ skipping 443 matching lines @@
 void FirstRunImportObserver::RunLoop() {
   loop_running_ = true;
   MessageLoop::current()->Run();
 }
 
 void FirstRunImportObserver::Finish() {
   if (loop_running_)
     MessageLoop::current()->Quit();
 }
 
-// TODO(avi): port the relevant pieces and enable this.
-#if !defined(OS_MACOSX)
 // static
 void FirstRun::AutoImport(
     Profile* profile,
     bool homepage_defined,
     int import_items,
     int dont_import_items,
     bool search_engine_experiment,
     bool randomize_search_engine_experiment,
     bool make_chrome_default,
     ProcessSingleton* process_singleton) {
   // We need to avoid dispatching new tabs when we are importing because
   // that will lead to data corruption or a crash. Because there is no UI for
   // the import process, we pass NULL as the window to bring to the foreground
   // when a CopyData message comes in; this causes the message to be silently
   // discarded, which is the correct behavior during the import process.
   process_singleton->Lock(NULL);
 
   PlatformSetup();
 
   FilePath local_state_path;
   PathService::Get(chrome::FILE_LOCAL_STATE, &local_state_path);
   bool local_state_file_exists = file_util::PathExists(local_state_path);
 
   scoped_refptr<ImporterHost> importer_host;
-  importer_host = new ImporterHost();
+  // TODO(csilv,mirandac): Out-of-process import has only been qualified on
+  // MacOS X, so we will only use it on that platform since it is required.
+  // Remove this conditional logic once oop import is qualified for
+  // Linux/Windows. http://crbug.com/22142
+#if defined(OS_MACOSX)
+  importer_host = new ExternalProcessImporterHost;
+#else
+  importer_host = new ImporterHost;
+#endif
   // Do import if there is an available profile for us to import.
   if (importer_host->GetAvailableProfileCount() > 0) {
     // Don't show the warning dialog if import fails.
     importer_host->set_headless();
     int items = 0;
 
     // History is always imported unless turned off in master_preferences.
     if (!(dont_import_items & importer::HISTORY))
       items = items | importer::HISTORY;
     // Home page is imported in organic builds only unless turned off or
@@ skipping 39 matching lines @@
     ShellIntegration::SetAsDefaultBrowser();
 
   FirstRun::SetShowFirstRunBubblePref(true);
   // Set the first run bubble to minimal.
   FirstRun::SetMinimalFirstRunBubblePref();
   FirstRun::SetShowWelcomePagePref();
 
   process_singleton->Unlock();
   FirstRun::CreateSentinel();
 }
-#endif  // !defined(OS_MACOSX)
+
+#if defined(OS_POSIX)
+namespace {
+
+// This class acts as an observer for the ImporterHost::Observer::ImportEnded
+// callback. When the import process is started, certain errors may cause
+// ImportEnded() to be called synchronously, but the typical case is that
+// ImportEnded() is called asynchronously. Thus we have to handle both cases.
+class ImportEndedObserver : public ImporterHost::Observer {
+ public:
+  ImportEndedObserver() : ended_(false),
+                          should_quit_message_loop_(false) {}
+  virtual ~ImportEndedObserver() {}
+
+  virtual void ImportItemStarted(importer::ImportItem item) {}
+  virtual void ImportItemEnded(importer::ImportItem item) {}
+  virtual void ImportStarted() {}
+  virtual void ImportEnded() {
+    ended_ = true;
+    if (should_quit_message_loop_)
+      MessageLoop::current()->Quit();
+  }
+
+  void set_should_quit_message_loop() {
+    should_quit_message_loop_ = true;
+  }
+
+  bool ended() {
+    return ended_;
+  }
+
+ private:
+  // Set if the import has ended.
+  bool ended_;
+
+  // Set by the client (via set_should_quit_message_loop) if, when the import
+  // ends, this class should quit the message loop.
+  bool should_quit_message_loop_;
+};
+
+}  // namespace
+
+// static
+bool FirstRun::ImportSettings(Profile* profile,
+                              scoped_refptr<ImporterHost> importer_host,
+                              int items_to_import) {
+  const ProfileInfo& source_profile = importer_host->GetSourceProfileInfoAt(0);
+
+  // Ensure that importers aren't requested to import items that they do not
+  // support.
+  items_to_import &= source_profile.services_supported;
+
+  scoped_ptr<ImportEndedObserver> observer(new ImportEndedObserver);
+  importer_host->SetObserver(observer.get());
+  importer_host->StartImportSettings(source_profile,
+                                     profile,
+                                     items_to_import,
+                                     new ProfileWriter(profile),
+                                     true);
+  // If the import process has not errored out, block on it.
+  if (!observer->ended()) {
+    observer->set_should_quit_message_loop();
+    MessageLoop::current()->Run();
+  }
+
+  // Unfortunately there's no success/fail signal in ImporterHost.
+  return true;
+}
+
+#endif  // OS_POSIX