Clean up first run:

chrome/browser/first_run/first_run_win.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 <shlobj.h>
 #include <windows.h>
 
 #include <set>
@@ skipping 323 matching lines @@
   }
 
   HWND owner_window_;
   base::ProcessHandle import_process_;
   WorkerThreadTicker ticker_;
   DISALLOW_COPY_AND_ASSIGN(HungImporterMonitor);
 };
 
 std::string EncodeImportParams(int importer_type,
                                int options,
-                               int skip_first_run_ui,
-                               HWND window) {
-  return base::StringPrintf(
-      "%d@%d@%d@%d", importer_type, options, skip_first_run_ui, window);
+                               bool skip_first_run_ui) {
+  return base::StringPrintf("%d@%d@%d", importer_type, options,
+                            skip_first_run_ui ? 1 : 0);
 }
 
 bool DecodeImportParams(const std::string& encoded,
                         int* importer_type,
                         int* options,
-                        int* skip_first_run_ui,
-                        HWND* window) {
+                        bool* skip_first_run_ui) {
   std::vector<std::string> parts;
   base::SplitString(encoded, '@', &parts);
-  if (parts.size() != 4)
+  int skip_first_run_ui_int;
+  if ((parts.size() != 3) || !base::StringToInt(parts[0], importer_type) ||
+      !base::StringToInt(parts[1], options) ||
+      !base::StringToInt(parts[2], &skip_first_run_ui_int))
     return false;
-
-  if (!base::StringToInt(parts[0], importer_type))
-    return false;
-
-  if (!base::StringToInt(parts[1], options))
-    return false;
-
-  if (!base::StringToInt(parts[2], skip_first_run_ui))
-    return false;
-
-  int64 window_int;
-  base::StringToInt64(parts[3], &window_int);
-  *window = reinterpret_cast<HWND>(window_int);
+  *skip_first_run_ui = !!skip_first_run_ui_int;
   return true;
 }
 
 #if !defined(USE_AURA)
 // Imports browser items in this process. The browser and the items to
 // import are encoded in the command line.
 int ImportFromBrowser(Profile* profile,
                       const CommandLine& cmdline) {
   std::string import_info = cmdline.GetSwitchValueASCII(switches::kImport);
   if (import_info.empty()) {
     NOTREACHED();
     return false;
   }
   int importer_type = 0;
   int items_to_import = 0;
-  int skip_first_run_ui = 0;
-  HWND parent_window = NULL;
+  bool skip_first_run_ui = false;
   if (!DecodeImportParams(import_info, &importer_type, &items_to_import,
-                          &skip_first_run_ui, &parent_window)) {
+                          &skip_first_run_ui)) {
     NOTREACHED();
     return false;
   }
   scoped_refptr<ImporterHost> importer_host(new ImporterHost);
   FirstRunImportObserver importer_observer;
 
   scoped_refptr<ImporterList> importer_list(new ImporterList(NULL));
   importer_list->DetectSourceProfilesHack();
 
   // If |skip_first_run_ui|, we run in headless mode.  This means that if
   // there is user action required the import is automatically canceled.
-  if (skip_first_run_ui > 0)
+  if (skip_first_run_ui)
     importer_host->set_headless();
 
-  importer::ShowImportProgressDialog(
-      parent_window,
-      static_cast<uint16>(items_to_import),
-      importer_host,
-      &importer_observer,
-      importer_list->GetSourceProfileForImporterType(importer_type),
-      profile,
+  importer::ShowImportProgressDialog(static_cast<uint16>(items_to_import),
+      importer_host, &importer_observer,
+      importer_list->GetSourceProfileForImporterType(importer_type), profile,
       true);
   importer_observer.RunLoop();
   return importer_observer.import_result();
 }
 #endif  // !defined(USE_AURA)
 
 bool ImportSettingsWin(Profile* profile,
                        int importer_type,
                        int items_to_import,
                        const FilePath& import_bookmarks_path,
                        bool skip_first_run_ui) {
   const CommandLine& cmdline = *CommandLine::ForCurrentProcess();
   CommandLine import_cmd(cmdline.GetProgram());
 
   const char* kSwitchNames[] = {
     switches::kUserDataDir,
     switches::kChromeFrame,
     switches::kCountry,
   };
   import_cmd.CopySwitchesFrom(cmdline, kSwitchNames, arraysize(kSwitchNames));
 
   // Since ImportSettings is called before the local state is stored on disk
   // we pass the language as an argument.  GetApplicationLocale checks the
   // current command line as fallback.
   import_cmd.AppendSwitchASCII(switches::kLang,
                                g_browser_process->GetApplicationLocale());
 
   if (items_to_import) {
-    import_cmd.CommandLine::AppendSwitchASCII(switches::kImport,
-        EncodeImportParams(importer_type, items_to_import,
-                           skip_first_run_ui ? 1 : 0, NULL));
+    import_cmd.AppendSwitchASCII(switches::kImport,
+        EncodeImportParams(importer_type, items_to_import, skip_first_run_ui));
   }
 
   if (!import_bookmarks_path.empty()) {
-    import_cmd.CommandLine::AppendSwitchPath(
-        switches::kImportFromFile, import_bookmarks_path);
+    import_cmd.AppendSwitchPath(switches::kImportFromFile,
+                                import_bookmarks_path);
   }
 
+  // The importer doesn't need to do any background networking tasks so disable
+  // them.
+  import_cmd.CommandLine::AppendSwitch(switches::kDisableBackgroundNetworking);
+
   // Time to launch the process that is going to do the import.
   base::ProcessHandle import_process;
   if (!base::LaunchProcess(import_cmd, base::LaunchOptions(), &import_process))
     return false;
 
   // We block inside the import_runner ctor, pumping messages until the
   // importer process ends. This can happen either by completing the import
   // or by hang_monitor killing it.
   ImportProcessRunner import_runner(import_process);
 
@@ skipping 63 matching lines @@
   }
 
   if (out_prefs->do_import_items || !import_bookmarks_path.empty()) {
     // There is something to import from the default browser. This launches
     // the importer process and blocks until done or until it fails.
     scoped_refptr<ImporterList> importer_list(new ImporterList(NULL));
     importer_list->DetectSourceProfilesHack();
     if (!ImportSettingsWin(NULL,
           importer_list->GetSourceProfileAt(0).importer_type,
           out_prefs->do_import_items,
-          FilePath::FromWStringHack(UTF8ToWide(import_bookmarks_path)),
-          true)) {
+          FilePath::FromWStringHack(UTF8ToWide(import_bookmarks_path)), true)) {
       LOG(WARNING) << "silent import failed";
     }
   }
 }
 
 }  // namespace internal
 }  // namespace first_run
 
 namespace first_run {
 
@@ skipping 77 matching lines @@
     return false;
 
   internal::SetShowWelcomePagePrefIfNeeded(install_prefs.get());
   internal::SetImportPreferencesAndLaunchImport(out_prefs, install_prefs.get());
   internal::SetDefaultBrowser(install_prefs.get());
 
   return false;
 }
 
 }  // namespace first_run