Fix Firefox import lock dialog on Windows....

chrome/browser/first_run/first_run_win.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 <windows.h>
 #include <shellapi.h>
 #include <shlobj.h>
 
@@ skipping 382 matching lines @@
   installer_util::GetDistroStringPreference(prefs.get(),
       installer_util::master_preferences::kDistroImportBookmarksFromFilePref,
       &import_bookmarks_path);
 
   if (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<ImporterHost> importer_host = new ImporterHost();
     if (!FirstRun::ImportSettings(NULL,
           importer_host->GetSourceProfileInfoAt(0).browser_type,
-              import_items, FilePath(import_bookmarks_path), NULL)) {
+              import_items, FilePath(import_bookmarks_path), true, NULL)) {
       LOG(WARNING) << "silent import failed";
     }
   }
 
   return false;
 }
 
 bool Upgrade::IsBrowserAlreadyRunning() {
   static HANDLE handle = NULL;
   std::wstring exe;
@@ skipping 161 matching lines @@
       import_process_ = NULL;
     }
   }
 
   HWND owner_window_;
   base::ProcessHandle import_process_;
   WorkerThreadTicker ticker_;
   DISALLOW_COPY_AND_ASSIGN(HungImporterMonitor);
 };
 
-std::string EncodeImportParams(int browser_type, int options, HWND window) {
-  return StringPrintf("%d@%d@%d", browser_type, options, window);
+std::string EncodeImportParams(int browser_type, int options,
+                               int skip_first_run_ui, HWND window) {
+  return StringPrintf("%d@%d@%d@%d", browser_type, options, skip_first_run_ui,
+                      window);
 }
 
-bool DecodeImportParams(const std::string& encoded,
-                        int* browser_type, int* options, HWND* window) {
+bool DecodeImportParams(const std::string& encoded, int* browser_type,
+                        int* options, int* skip_first_run_ui, HWND* window) {
   std::vector<std::string> parts;
   SplitString(encoded, '@', &parts);
-  if (parts.size() != 3)
+  if (parts.size() != 4)
     return false;
 
   if (!base::StringToInt(parts[0], browser_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[2], &window_int);
+  base::StringToInt64(parts[3], &window_int);
   *window = reinterpret_cast<HWND>(window_int);
   return true;
 }
 
 }  // namespace
 
 void FirstRun::AutoImport(Profile* profile,
     bool homepage_defined,
     int import_items,
     int dont_import_items,
@@ skipping 62 matching lines @@
   // Set the first run bubble to minimal.
   FirstRun::SetMinimalFirstRunBubblePref();
 
   process_singleton->Unlock();
   FirstRun::CreateSentinel();
 }
 
 bool FirstRun::ImportSettings(Profile* profile, int browser_type,
                               int items_to_import,
                               const FilePath& import_bookmarks_path,
+                              bool skip_first_run_ui,
                               HWND parent_window) {
   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(browser_type, items_to_import, parent_window));
+        EncodeImportParams(browser_type, items_to_import,
+                           skip_first_run_ui ? 1 : 0, parent_window));
   }
 
   if (!import_bookmarks_path.empty()) {
     import_cmd.CommandLine::AppendSwitchPath(
         switches::kImportFromFile, import_bookmarks_path);
   }
 
   // Time to launch the process that is going to do the import.
   base::ProcessHandle import_process;
   if (!base::LaunchApp(import_cmd, false, false, &import_process))
@@ skipping 14 matching lines @@
   if (profile)
     profile->GetPrefs()->ReloadPersistentPrefs();
 
   return (import_runner.exit_code() == ResultCodes::NORMAL_EXIT);
 }
 
 bool FirstRun::ImportSettings(Profile* profile, int browser_type,
                               int items_to_import,
                               HWND parent_window) {
   return ImportSettings(profile, browser_type, items_to_import,
-                        FilePath(), parent_window);
+                        FilePath(), false, parent_window);
 }
 
 int FirstRun::ImportFromBrowser(Profile* profile,
                                 const CommandLine& cmdline) {
   std::string import_info = cmdline.GetSwitchValueASCII(switches::kImport);
   if (import_info.empty()) {
     NOTREACHED();
     return false;
   }
   int browser_type = 0;
   int items_to_import = 0;
+  int skip_first_run_ui = 0;
   HWND parent_window = NULL;
   if (!DecodeImportParams(import_info, &browser_type, &items_to_import,
-                          &parent_window)) {
+                          &skip_first_run_ui, &parent_window)) {
     NOTREACHED();
     return false;
   }
   scoped_refptr<ImporterHost> importer_host = new ImporterHost();
   FirstRunImportObserver observer;
 
-  // If there is no parent window, we run in headless mode which amounts
-  // to having the windows hidden and if there is user action required the
-  // import is automatically canceled.
-  if (!parent_window)
+  // 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)
     importer_host->set_headless();
 
   StartImportingWithUI(
       parent_window,
       items_to_import,
       importer_host,
       importer_host->GetSourceProfileInfoForBrowserType(browser_type),
       profile,
       &observer,
       true);
@@ skipping 282 matching lines @@
 
 Upgrade::TryResult Upgrade::ShowTryChromeDialog(size_t version) {
   if (version > 10000) {
     // This is a test value. We want to make sure we exercise
     // returning this early. See EarlyReturnTest test harness.
     return Upgrade::TD_NOT_NOW;
   }
   TryChromeDialog td;
   return td.ShowModal();
 }