Added few methods and a testcase to test Chrome Frame installation.

Review URL: http://codereview.chromium.org/389015

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@32095 0039d316-1c4b-4281-b951-d872f2087c98

8 files changed, 258 insertions, 91 deletions

diff --git a/chrome/test/mini_installer_test/chrome_mini_installer.cc b/chrome/test/mini_installer_test/chrome_mini_installer.cc
index 26dacd4..f6bac58 100644
--- a/chrome/test/mini_installer_test/chrome_mini_installer.cc
+++ b/chrome/test/mini_installer_test/chrome_mini_installer.cc
@@ -17,8 +17,9 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 // Constructor.
-ChromeMiniInstaller::ChromeMiniInstaller(const std::wstring& install_type) {
-  install_type_ = install_type;
+ChromeMiniInstaller::ChromeMiniInstaller(const std::wstring& install_type,
+    bool is_chrome_frame) : is_chrome_frame_(is_chrome_frame),
+                            install_type_(install_type) {
   installer_name_ = StringPrintf(L"%ls (%ls)",
       mini_installer_constants::kChromeBuildType, install_type_.c_str());
 
@@ -39,18 +40,25 @@ void ChromeMiniInstaller::SetBuildUnderTest(const std::wstring& build) {
   else
     build_prefix = build.c_str();
 
+  std::wstring full_installer_pattern;
+  if (is_chrome_frame_)
+    full_installer_pattern =
+        mini_installer_constants::kChromeFrameFullInstallerPattern;
+  else
+    full_installer_pattern = mini_installer_constants::kFullInstallerPattern;
+
   // Do not fail here if cannot find the installer. Set the bool and allow
   // to fail in the particular test.
   has_full_installer_ = MiniInstallerTestUtil::GetInstaller(
-      mini_installer_constants::kFullInstallerPattern,
-      &full_installer_, build_prefix);
+      full_installer_pattern.c_str(),
+      &full_installer_, build_prefix, is_chrome_frame_);
   has_diff_installer_ = MiniInstallerTestUtil::GetInstaller(
       mini_installer_constants::kDiffInstallerPattern,
-      &diff_installer_, build_prefix);
+      &diff_installer_, build_prefix, is_chrome_frame_);
 
   if (has_diff_installer_) {
     has_prev_installer_ = MiniInstallerTestUtil::GetPreviousFullInstaller(
-        diff_installer_, &prev_installer_);
+        diff_installer_, &prev_installer_, is_chrome_frame_);
   }
 
   // Find the version names. The folder two-levels up from the installer
@@ -133,13 +141,7 @@ void ChromeMiniInstaller::InstallMiniInstaller(bool over_install,
   LaunchInstaller(path, exe_name.c_str());
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   ASSERT_TRUE(CheckRegistryKey(dist->GetVersionKey()));
-  printf("\nInstall Checks:\n\n");
-  if ((install_type_ == mini_installer_constants::kUserInstall) &&
-      (!over_install))
-    CloseFirstRunUIDialog(over_install);
-  PlatformThread::Sleep(800);
-  FindChromeShortcut();
-  LaunchAndCloseChrome(over_install);
+  VerifyInstall(over_install);
 }
 
 // This method tests the standalone installer by verifying the steps listed at:
@@ -233,41 +235,49 @@ void ChromeMiniInstaller::Repair(
 // Deletes App dir.
 // Closes feedback form.
 void ChromeMiniInstaller::UnInstall() {
-  printf("\n\nVerifying if Chrome is installed...\n\n");
+  std::wstring product_name;
+  if (is_chrome_frame_)
+    product_name = mini_installer_constants::kChromeFrameProductName;
+  else
+    product_name = mini_installer_constants::kChromeProductName;
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   if (!CheckRegistryKey(dist->GetVersionKey())) {
-    printf("Chrome is not installed.\n");
+    printf("%ls is not installed.\n", product_name.c_str());
     return;
   }
-  printf("\n\nUninstalling Chrome...\n");
-  printf("Closing Chrome processes, if any...\n");
+  if (is_chrome_frame_)
+    MiniInstallerTestUtil::CloseProcesses(L"IEXPLORE.EXE");
   MiniInstallerTestUtil::CloseProcesses(installer_util::kChromeExe);
   std::wstring uninstall_path = GetUninstallPath();
   if (uninstall_path == L"") {
-    printf("\n Chrome install is in a weird state. Cleaning the machine...\n");
+    printf("\n %ls install is in a weird state. Cleaning the machine...\n",
+            product_name.c_str());
     CleanChromeInstall();
     return;
   }
   ASSERT_TRUE(file_util::PathExists(FilePath::FromWStringHack(uninstall_path)));
-  std::wstring uninstall_args = L"\"" + uninstall_path +
-                                L"\"" + L" --uninstall --force-uninstall";
+  std::wstring uninstall_args(L"\"");
+  uninstall_args.append(uninstall_path);
+  uninstall_args.append(L"\" --uninstall --force-uninstall");
+  if (is_chrome_frame_)
+    uninstall_args.append(L" --chrome-frame");
   if (install_type_ == mini_installer_constants::kSystemInstall)
     uninstall_args = uninstall_args + L" --system-level";
   base::LaunchApp(uninstall_args, false, false, NULL);
-  printf("Launched setup.exe. Here are the commands passed: %ls\n",
-         uninstall_args.c_str());
-  // ASSERT_TRUE(CloseUninstallWindow());
+  if (is_chrome_frame_)
+    ASSERT_TRUE(CloseUninstallWindow());
   ASSERT_TRUE(MiniInstallerTestUtil::VerifyProcessClose(
       mini_installer_constants::kChromeSetupExecutable));
-  printf("\n\nUninstall Checks:\n\n");
   ASSERT_FALSE(CheckRegistryKeyOnUninstall(dist->GetVersionKey()));
-  printf("Deleting user data folder after uninstall\n");
   DeleteUserDataFolder();
-  FindChromeShortcut();
-  MiniInstallerTestUtil::CloseProcesses(
-      mini_installer_constants::kIEExecutable);
-  ASSERT_EQ(0,
-      base::GetProcessCount(mini_installer_constants::kIEExecutable, NULL));
+  // Close IE survey window that gets launched on uninstall.
+  if (!is_chrome_frame_) {
+    FindChromeShortcut();
+    MiniInstallerTestUtil::CloseProcesses(
+        mini_installer_constants::kIEExecutable);
+    ASSERT_EQ(0,
+        base::GetProcessCount(mini_installer_constants::kIEExecutable, NULL));
+  }
 }
 
 // Will clean up the machine if Chrome install is messed up.
@@ -279,9 +289,13 @@ void ChromeMiniInstaller::CleanChromeInstall() {
 bool ChromeMiniInstaller::CloseUninstallWindow() {
   HWND hndl = NULL;
   int timer = 0;
+  std::wstring window_name;
+  if (is_chrome_frame_)
+    window_name = mini_installer_constants::kChromeFrameAppName;
+  else
+    window_name = mini_installer_constants::kChromeUninstallDialogName;
   while (hndl == NULL && timer < 5000) {
-    hndl = FindWindow(NULL,
-        mini_installer_constants::kChromeUninstallDialogName);
+    hndl = FindWindow(NULL, window_name.c_str());
     PlatformThread::Sleep(200);
     timer = timer + 200;
   }
@@ -389,17 +403,27 @@ void ChromeMiniInstaller::DeleteFolder(const wchar_t* folder_name) {
 
 // Will delete user data profile.
 void ChromeMiniInstaller::DeleteUserDataFolder() {
+  std::wstring path = GetUserDataDirPath();
+  if (file_util::PathExists(FilePath::FromWStringHack(path.c_str())))
+    ASSERT_TRUE(file_util::Delete(path.c_str(), true));
+}
+
+// Gets user data directory path
+std::wstring ChromeMiniInstaller::GetUserDataDirPath() {
   FilePath path;
   PathService::Get(base::DIR_LOCAL_APP_DATA, &path);
   std::wstring profile_path = path.ToWStringHack();
-  file_util::AppendToPath(&profile_path,
-                          mini_installer_constants::kChromeAppDir);
+  if (is_chrome_frame_) {
+    file_util::AppendToPath(&profile_path,
+        mini_installer_constants::kChromeFrameAppDir);
+  } else {
+    file_util::AppendToPath(&profile_path,
+        mini_installer_constants::kChromeAppDir);
+  }
   file_util::UpOneDirectory(&profile_path);
   file_util::AppendToPath(&profile_path,
                           mini_installer_constants::kChromeUserDataDir);
-  printf("\nDeleting this path after uninstall%ls\n", profile_path.c_str());
-  if (file_util::PathExists(FilePath::FromWStringHack(profile_path)))
-    ASSERT_TRUE(file_util::Delete(profile_path.c_str(), true));
+  return profile_path;
 }
 
 // Deletes pv key from Clients.
@@ -468,7 +492,11 @@ std::wstring ChromeMiniInstaller::GetUninstallPath() {
   if (!GetChromeVersionFromRegistry(&reg_key_value))
     return L"";
   path = GetChromeInstallDirectoryLocation();
-  file_util::AppendToPath(&path, mini_installer_constants::kChromeAppDir);
+  if (is_chrome_frame_)
+    file_util::AppendToPath(&path,
+        mini_installer_constants::kChromeFrameAppDir);
+  else
+    file_util::AppendToPath(&path, mini_installer_constants::kChromeAppDir);
   file_util::AppendToPath(&path, reg_key_value);
   file_util::AppendToPath(&path, installer_util::kInstallerDir);
   file_util::AppendToPath(&path,
@@ -484,7 +512,7 @@ std::wstring ChromeMiniInstaller::GetUninstallPath() {
 
 // Returns Chrome pv registry key value
 bool ChromeMiniInstaller::GetChromeVersionFromRegistry(
-    std::wstring* build_key_value ) {
+    std::wstring* build_key_value) {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   RegKey key(GetRootRegistryKey(), dist->GetVersionKey().c_str());
   if (!key.ReadValue(L"pv", build_key_value)) {
@@ -508,7 +536,13 @@ void ChromeMiniInstaller::LaunchInstaller(const std::wstring& path,
                                           const wchar_t* process_name) {
   ASSERT_TRUE(file_util::PathExists(FilePath::FromWStringHack(path)));
   if (install_type_ == mini_installer_constants::kSystemInstall) {
-    std::wstring launch_args = L" -system-level";
+    std::wstring launch_args;
+    if (is_chrome_frame_) {
+      launch_args.append(L" --do-not-create-shortcuts");
+      launch_args.append(L" --do-not-register-for-update-launch");
+      launch_args.append(L" --chrome-frame");
+    }
+    launch_args.append(L" --system-level");
     base::LaunchApp(L"\"" + path + L"\"" + launch_args, false, false, NULL);
   } else {
     base::LaunchApp(L"\"" + path + L"\"", false, false, NULL);
@@ -541,10 +575,60 @@ void ChromeMiniInstaller::LaunchAndCloseChrome(bool over_install) {
 void ChromeMiniInstaller::VerifyChromeLaunch(bool expected_status) {
   std::wstring launch_path;
   GetChromeLaunchPath(&launch_path);
-  base::LaunchApp(L"\"" + launch_path + L"\"", false, false, NULL);
+  LaunchBrowser(launch_path, L"", installer_util::kChromeExe, expected_status);
+}
+
+// Verifies Chrome/Chrome Frame install.
+void ChromeMiniInstaller::VerifyInstall(bool over_install) {
+  if (is_chrome_frame_) {
+    VerifyChromeFrameInstall();
+  } else {
+    if ((install_type_ == mini_installer_constants::kUserInstall) &&
+        (!over_install))
+      CloseFirstRunUIDialog(over_install);
+    PlatformThread::Sleep(800);
+    FindChromeShortcut();
+    LaunchAndCloseChrome(over_install);
+  }
+}
+
+// This method will verify if ChromeFrame installed successfully. It will
+// launch IE with cf:about:version, then check if
+// chrome.exe process got spawned.
+void ChromeMiniInstaller::VerifyChromeFrameInstall() {
+  std::wstring browser_path = GetChromeInstallDirectoryLocation();
+  if (is_chrome_frame_) {
+    file_util::AppendToPath(&browser_path,
+                            mini_installer_constants::kIELocation);
+    file_util::AppendToPath(&browser_path,
+                            mini_installer_constants::kIEProcessName);
+  }
+
+  // Launch IE
+  LaunchBrowser(browser_path, L"cf:about:version",
+                mini_installer_constants::kIEProcessName,
+                true);
+
+  // Check if Chrome process got spawned.
+  MiniInstallerTestUtil::VerifyProcessLaunch(installer_util::kChromeExe, true);
+  PlatformThread::Sleep(1500);
+
+  // Verify if IExplore folder got created
+  std::wstring path = GetUserDataDirPath();
+  file_util::AppendToPath(&path, L"IEXPLORE");
+  ASSERT_TRUE(file_util::PathExists(FilePath::FromWStringHack(path.c_str())));
+}
+
+// This method will launch any requested browser.
+void ChromeMiniInstaller::LaunchBrowser(const std::wstring& launch_path,
+                                        const std::wstring& launch_args,
+                                        const std::wstring& process_name,
+                                        bool expected_status) {
+  base::LaunchApp(L"\"" + launch_path + L"\"" + L" " + launch_args,
+      false, false, NULL);
   PlatformThread::Sleep(1000);
-  MiniInstallerTestUtil::VerifyProcessLaunch(
-      installer_util::kChromeExe, expected_status);
+  MiniInstallerTestUtil::VerifyProcessLaunch(process_name.c_str(),
+                                             expected_status);
 }
 
 // This method compares the registry keys after overinstall.
diff --git a/chrome/test/mini_installer_test/chrome_mini_installer.h b/chrome/test/mini_installer_test/chrome_mini_installer.h
index 0a0c956..a5c1a9c 100644
--- a/chrome/test/mini_installer_test/chrome_mini_installer.h
+++ b/chrome/test/mini_installer_test/chrome_mini_installer.h
@@ -14,7 +14,8 @@
 // This class has methods to install and uninstall Chrome mini installer.
 class ChromeMiniInstaller {
  public:
-  explicit ChromeMiniInstaller(const std::wstring& install_type);
+  explicit ChromeMiniInstaller(const std::wstring& install_type,
+                               bool is_chrome_frame);
 
   ~ChromeMiniInstaller() {}
 
@@ -65,6 +66,8 @@ class ChromeMiniInstaller {
 
   bool standalone_installer;
 
+  bool is_chrome_frame_;
+
   // Name of the browser (Chrome or Chromium) and install type (sys or user)
   std::wstring installer_name_;
 
@@ -121,12 +124,22 @@ class ChromeMiniInstaller {
   // Get path for uninstall.
   std::wstring GetUninstallPath();
 
+  // Get user data directory path.
+  std::wstring GetUserDataDirPath();
+
   // Gets the path to launch Chrome.
   bool GetChromeLaunchPath(std::wstring* launch_path);
 
   // This method will get Chrome.exe path and launch it.
   void VerifyChromeLaunch(bool expected_status);
 
+  // This method verifies if Chrome/Chrome Frame installed correctly.
+  void VerifyInstall(bool over_install);
+
+  // This method will verify if ChromeFrame got successfully installed
+  // on the machine.
+  void VerifyChromeFrameInstall();
+
   // Launches the chrome installer and waits for it to end.
   void LaunchInstaller(const std::wstring& install_path,
                        const wchar_t* process_name);
@@ -134,6 +147,12 @@ class ChromeMiniInstaller {
   // Verifies if Chrome launches after install.
   void LaunchAndCloseChrome(bool over_install);
 
+  // Launches any requested browser.
+  void LaunchBrowser(const std::wstring& launch_path,
+                     const std::wstring& launch_arg,
+                     const std::wstring& process_name,
+                     bool expected_status);
+
   // Compares the registry key values after overinstall.
   bool VerifyOverInstall(const std::wstring& reg_key_value_before_overinstall,
                          const std::wstring& reg_key_value_after_overinstall);
diff --git a/chrome/test/mini_installer_test/mini_installer_test_constants.cc b/chrome/test/mini_installer_test/mini_installer_test_constants.cc
index c26b990..ed4a289 100644
--- a/chrome/test/mini_installer_test/mini_installer_test_constants.cc
+++ b/chrome/test/mini_installer_test/mini_installer_test_constants.cc
@@ -23,19 +23,24 @@ const wchar_t kChromeUninstallDialogName[] = L"Uninstall Chromium";
 #endif
 const wchar_t kBrowserAppName[] = L"Google - Google Chrome";
 const wchar_t kBrowserTabName[] = L"New Tab - Google Chrome";
+const wchar_t kChromeFrameAppDir[] = L"Google\\Chrome Frame\\Application\\";
+const wchar_t kChromeFrameAppName[] = L"Google Chrome Frame";
+const wchar_t kChromeFrameFullInstallerPattern[] = L"_chromeframe_installer";
+const wchar_t kChromeFrameProductName[] = L"Chrome Frame";
 const wchar_t kChromeMiniInstallerExecutable[] = L"mini_installer.exe";
 const wchar_t kChromeMetaInstallerExecutable[] = L"chrome_installer.exe";
+const wchar_t kChromeProductName[] = L"Chrome";
 const wchar_t kChromeSetupExecutable[] = L"setup.exe";
-const wchar_t kChromeUserDataDir[] = L"User Data";
 const wchar_t kChromeUserDataBackupDir[] = L"User Data Copy";
+const wchar_t kChromeUserDataDir[] = L"User Data";
 const wchar_t kDiffInstall[] = L"Diff";
 const wchar_t kDiffInstallerPattern[] = L"_from_";
 const wchar_t kFullInstallerPattern[] = L"_chrome_installer";
 const wchar_t kGoogleUpdateExecutable[] = L"GoogleUpdate.exe";
 const wchar_t kIEExecutable[] = L"iexplore.exe";
 const wchar_t kInstallerWindow[] = L"Chrome Installer";
-const wchar_t kSystemInstall[] = L"system";
 const wchar_t kStandaloneInstaller[] = L"ChromeSetupTest.exe";
+const wchar_t kSystemInstall[] = L"system";
 const wchar_t kUserInstall[] = L"user";
 const wchar_t kUntaggedInstallerPattern[] = L"ChromeStandaloneSetup_";
 
@@ -45,6 +50,8 @@ const wchar_t kStableChannelBuild[] = L"2.0.";
 const wchar_t kFullInstall[] = L"Full";
 
 
+const wchar_t kIELocation[] = L"Internet Explorer\\";
+const wchar_t kIEProcessName[] = L"IEXPLORE.EXE";
 
 // Google Chrome meta installer location.
 const wchar_t kChromeMetaInstallerExe[] =
diff --git a/chrome/test/mini_installer_test/mini_installer_test_constants.h b/chrome/test/mini_installer_test/mini_installer_test_constants.h
index 3cab711..87f7df1 100644
--- a/chrome/test/mini_installer_test/mini_installer_test_constants.h
+++ b/chrome/test/mini_installer_test/mini_installer_test_constants.h
@@ -11,16 +11,20 @@ namespace mini_installer_constants {
 
 // Path and process names
 extern const wchar_t kChromeAppDir[];
-extern const wchar_t kChromeSetupExecutable[];
-extern const wchar_t kChromeMiniInstallerExecutable[];
+extern const wchar_t kChromeFrameAppDir[];
+extern const wchar_t kChromeFrameFullInstallerPattern[];
+extern const wchar_t kChromeFrameProductName[];
 extern const wchar_t kChromeMetaInstallerExecutable[];
-extern const wchar_t kGoogleUpdateExecutable[];
-extern const wchar_t kChromeUserDataDir[];
+extern const wchar_t kChromeMiniInstallerExecutable[];
+extern const wchar_t kChromeProductName[];
+extern const wchar_t kChromeSetupExecutable[];
 extern const wchar_t kChromeUserDataBackupDir[];
+extern const wchar_t kChromeUserDataDir[];
 extern const wchar_t kDiffInstall[];
 extern const wchar_t kDiffInstallerPattern[];
-extern const wchar_t kFullInstallerPattern[];
 extern const wchar_t kFullInstall[];
+extern const wchar_t kFullInstallerPattern[];
+extern const wchar_t kGoogleUpdateExecutable[];
 extern const wchar_t kIEExecutable[];
 extern const wchar_t kSystemInstall[];
 extern const wchar_t kUserInstall[];
@@ -29,6 +33,7 @@ extern const wchar_t kUserInstall[];
 extern const wchar_t kBrowserAppName[];
 extern const wchar_t kBrowserTabName[];
 extern const wchar_t kChromeBuildType[];
+extern const wchar_t kChromeFrameAppName[];
 extern const wchar_t kChromeFirstRunUI[];
 extern const wchar_t kChromeUninstallDialogName[];
 extern const wchar_t kInstallerWindow[];
@@ -45,6 +50,9 @@ extern const wchar_t kUntaggedInstallerPattern[];
 extern const wchar_t kDevChannelBuild[];
 extern const wchar_t kStableChannelBuild[];
 
+extern const wchar_t kIELocation[];
+extern const wchar_t kIEProcessName[];
+
 // Google Chrome meta installer location.
 extern const wchar_t kChromeApplyTagExe[];
 extern const wchar_t kChromeApplyTagParameters[];
diff --git a/chrome/test/mini_installer_test/mini_installer_test_util.cc b/chrome/test/mini_installer_test/mini_installer_test_util.cc
index 922892b..6b78d36 100644
--- a/chrome/test/mini_installer_test/mini_installer_test_util.cc
+++ b/chrome/test/mini_installer_test/mini_installer_test_util.cc
@@ -96,7 +96,7 @@ std::wstring MiniInstallerTestUtil::GetFilePath(const wchar_t* exe_name) {
 // builds, sorted on creation time. Then goes through each build folder
 // until it finds the installer file that matches the pattern argument.
 bool MiniInstallerTestUtil::GetInstaller(const wchar_t* pattern,
-    std::wstring *path, const wchar_t* channel_type) {
+    std::wstring *path, const wchar_t* channel_type, bool chrome_frame) {
   FileInfoList builds_list;
   FileInfoList exe_list;
   std::wstring chrome_diff_installer(
@@ -111,7 +111,10 @@ bool MiniInstallerTestUtil::GetInstaller(const wchar_t* pattern,
   while (builds_list_size != builds_list.rend()) {
     path->assign(mini_installer_constants::kChromeDiffInstallerLocation);
     file_util::AppendToPath(path, builds_list_size->name_);
-    file_util::AppendToPath(path, L"win");
+    if (chrome_frame)
+      file_util::AppendToPath(path, L"win_cf");
+    else
+      file_util::AppendToPath(path, L"win");
     std::wstring installer_path(path->c_str());
     file_util::AppendToPath(&installer_path, L"*.exe");
     if (!GetLatestFile(installer_path.c_str(), pattern, &exe_list)) {
@@ -198,7 +201,7 @@ bool MiniInstallerTestUtil::GetPreviousBuildNumber(const std::wstring& path,
 // build information from the filename, then computes the
 // path for previous full installer.
 bool MiniInstallerTestUtil::GetPreviousFullInstaller(
-    const std::wstring& diff_path, std::wstring *previous) {
+    const std::wstring& diff_path, std::wstring *previous, bool chrome_frame) {
   std::wstring build_no;
 
   if (!GetPreviousBuildNumber(diff_path, &build_no))
@@ -212,7 +215,10 @@ bool MiniInstallerTestUtil::GetPreviousFullInstaller(
   // Create the full installer path.
   FilePath installer = FilePath(
       mini_installer_constants::kChromeDiffInstallerLocation);
-  installer = installer.Append(build_no).Append(L"win").Append(name);
+  if (chrome_frame)
+    installer = installer.Append(build_no).Append(L"win_cf").Append(name);
+  else
+    installer = installer.Append(build_no).Append(L"win").Append(name);
   previous->assign(installer.value());
 
   return file_util::PathExists(installer);
diff --git a/chrome/test/mini_installer_test/mini_installer_test_util.h b/chrome/test/mini_installer_test/mini_installer_test_util.h
index dd205ab..f0181d1 100644
--- a/chrome/test/mini_installer_test/mini_installer_test_util.h
+++ b/chrome/test/mini_installer_test/mini_installer_test_util.h
@@ -52,7 +52,7 @@ class MiniInstallerTestUtil {
   // installer is full or differential. The 'channel_type' parameter decides if
   // the build is stable/dev/beta.
   static bool GetInstaller(const wchar_t* pattern, std::wstring *name,
-                           const wchar_t* channel_type);
+                           const wchar_t* channel_type, bool chrome_frame);
 
   // This method will create a command line to run apply tag.
   static bool GetCommandForTagging(std::wstring *return_command);
@@ -77,7 +77,7 @@ class MiniInstallerTestUtil {
   // parameter decides if the build is stable/dev/beta. The 'diff_file'
   // parameter will hold the latest diff installer name.
   static bool GetPreviousFullInstaller(const std::wstring& diff_file,
-      std::wstring *previous);
+      std::wstring *previous, bool chrome_frame);
 
   // This method will return standalone installer file name.
   static bool GetStandaloneInstallerFileName(FileInfoList *file_name);
diff --git a/chrome/test/mini_installer_test/run_all_unittests.cc b/chrome/test/mini_installer_test/run_all_unittests.cc
index e6ef00f..cbcdf78 100644
--- a/chrome/test/mini_installer_test/run_all_unittests.cc
+++ b/chrome/test/mini_installer_test/run_all_unittests.cc
@@ -5,17 +5,19 @@
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/test/test_suite.h"
+#include "chrome/installer/util/util_constants.h"
 #include "chrome/test/mini_installer_test/mini_installer_test_constants.h"
 #include "chrome_mini_installer.h"
 
 
-void BackUpProfile() {
+void BackUpProfile(bool chrome_frame) {
   if (base::GetProcessCount(L"chrome.exe", NULL) > 0) {
     printf("Chrome is currently running and cannot backup the profile."
            "Please close Chrome and run the tests again.\n");
     exit(1);
   }
-  ChromeMiniInstaller installer(mini_installer_constants::kUserInstall);
+  ChromeMiniInstaller installer(mini_installer_constants::kUserInstall,
+                                chrome_frame);
   FilePath path =
       FilePath::FromWStringHack(installer.GetChromeInstallDirectoryLocation());
   path = path.Append(mini_installer_constants::kChromeAppDir).DirName();
@@ -23,7 +25,8 @@ void BackUpProfile() {
   // Will hold User Data path that needs to be backed-up.
   path = path.Append(mini_installer_constants::kChromeUserDataDir);
   // Will hold new backup path to save the profile.
-  backup_path = path.Append(mini_installer_constants::kChromeUserDataBackupDir);
+  backup_path = backup_path.Append(
+      mini_installer_constants::kChromeUserDataBackupDir);
   // Will check if User Data profile is available.
   if (file_util::PathExists(path)) {
     // Will check if User Data is already backed up.
@@ -41,11 +44,13 @@ int main(int argc, char** argv) {
   // with cleaning the system or make a backup before continuing.
   CommandLine::Init(argc, argv);
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  TestSuite test_suite = TestSuite(argc, argv);
   if (command_line.HasSwitch("clean")) {
     printf("Current version of Chrome will be uninstalled "
            "from all levels before proceeding with tests.\n");
   } else if (command_line.HasSwitch("backup")) {
-    BackUpProfile();
+    BackUpProfile(command_line.HasSwitch(
+        installer_util::switches::kChromeFrame));
   } else {
     printf("This test needs command line arguments.\n");
     printf("Usage: %ls -{clean|backup} [-build <version>] [-force] \n",
@@ -63,5 +68,5 @@ int main(int argc, char** argv) {
     return 1;
   }
 
-  return TestSuite(argc, argv).Run();
+  return test_suite.Run();
 }
diff --git a/chrome/test/mini_installer_test/test.cc b/chrome/test/mini_installer_test/test.cc
index 2392414..032d9a5 100644
--- a/chrome/test/mini_installer_test/test.cc
+++ b/chrome/test/mini_installer_test/test.cc
@@ -6,6 +6,7 @@
 #include "base/scoped_ptr.h"
 #include "base/win_util.h"
 #include "chrome/installer/util/install_util.h"
+#include "chrome/installer/util/util_constants.h"
 #include "chrome/test/mini_installer_test/mini_installer_test_constants.h"
 #include "chrome/test/mini_installer_test/mini_installer_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -23,15 +24,28 @@ class MiniInstallTest : public testing::Test {
     // Whether these tests should be run regardless of our running platform.
     bool force_tests_;
 
+    // Decided if ChromeFrame tests should be run.
+    bool chrome_frame_;
+
     // Installers created in test fixture setup for convenience.
     scoped_ptr<ChromeMiniInstaller> user_inst_, sys_inst_;
 
    public:
+
     static void CleanTheSystem() {
-      ChromeMiniInstaller userinstall(kUserInstall);
-      userinstall.UnInstall();
-      ChromeMiniInstaller systeminstall(kSystemInstall);
-      systeminstall.UnInstall();
+      const CommandLine* cmd = CommandLine::ForCurrentProcess();
+      if (cmd->HasSwitch(installer_util::switches::kChromeFrame)) {
+        ChromeMiniInstaller systeminstall(kSystemInstall,
+            cmd->HasSwitch(installer_util::switches::kChromeFrame));
+        systeminstall.UnInstall();
+      } else {
+        ChromeMiniInstaller userinstall(kUserInstall,
+            cmd->HasSwitch(installer_util::switches::kChromeFrame));
+        userinstall.UnInstall();
+        ChromeMiniInstaller systeminstall(kSystemInstall,
+            cmd->HasSwitch(installer_util::switches::kChromeFrame));
+        systeminstall.UnInstall();
+      }
     }
 
     virtual void SetUp() {
@@ -40,22 +54,28 @@ class MiniInstallTest : public testing::Test {
       std::wstring build = cmd->GetSwitchValue(L"build");
       if (build.empty())
         build = L"latest";
-
       force_tests_ = cmd->HasSwitch(L"force");
-
+      chrome_frame_ = cmd->HasSwitch(installer_util::switches::kChromeFrame);
       if (win_util::GetWinVersion() < win_util::WINVERSION_VISTA ||
-          force_tests_) {
+        force_tests_) {
         CleanTheSystem();
         // Separate the test output from cleaning output
         printf("\nBEGIN test----------------------------------------\n");
 
         // Create a few differently configured installers that are used in
         // the tests, for convenience.
-        user_inst_.reset(new ChromeMiniInstaller(kUserInstall));
-        user_inst_->SetBuildUnderTest(build);
-        sys_inst_.reset(new ChromeMiniInstaller(kSystemInstall));
-        sys_inst_->SetBuildUnderTest(build);
-
+        if (chrome_frame_) {
+          sys_inst_.reset(new ChromeMiniInstaller(kSystemInstall,
+                                                  chrome_frame_));
+          sys_inst_->SetBuildUnderTest(build);
+        } else {
+          user_inst_.reset(new ChromeMiniInstaller(kUserInstall,
+                                                   chrome_frame_));
+          user_inst_->SetBuildUnderTest(build);
+          sys_inst_.reset(new ChromeMiniInstaller(kSystemInstall,
+                                                  chrome_frame_));
+          sys_inst_->SetBuildUnderTest(build);
+        }
       } else {
         printf("These tests don't run on this platform.\n");
         exit(0);
@@ -74,65 +94,82 @@ class MiniInstallTest : public testing::Test {
 // these tests will often be run manually, don't want to have obscure test
 // names.
 
-// Install full installer.
-TEST_F(MiniInstallTest, FullInstallerUser) {
-  user_inst_->InstallFullInstaller(false);
-}
+// Install full installer at system level.
 TEST_F(MiniInstallTest, FullInstallerSys) {
   sys_inst_->InstallFullInstaller(false);
 }
 
+// Install full installer at user level.
+TEST_F(MiniInstallTest, FullInstallerUser) {
+  if (!chrome_frame_)
+    user_inst_->InstallFullInstaller(false);
+}
 // Overinstall full installer.
 TEST_F(MiniInstallTest, FullOverPreviousFullUser) {
-  user_inst_->OverInstallOnFullInstaller(kFullInstall);
+  if (!chrome_frame_)
+    user_inst_->OverInstallOnFullInstaller(kFullInstall);
 }
 TEST_F(MiniInstallTest, FullOverPreviousFullSys) {
-  sys_inst_->OverInstallOnFullInstaller(kFullInstall);
+  if (!chrome_frame_)
+    sys_inst_->OverInstallOnFullInstaller(kFullInstall);
 }
 
 // Overinstall diff installer.
 TEST_F(MiniInstallTest, DiffOverPreviousFullUser) {
-  user_inst_->OverInstallOnFullInstaller(kDiffInstall);
+  if (!chrome_frame_)
+    user_inst_->OverInstallOnFullInstaller(kDiffInstall);
 }
+
 TEST_F(MiniInstallTest, DiffOverPreviousFullSys) {
-  sys_inst_->OverInstallOnFullInstaller(kDiffInstall);
+  if (!chrome_frame_)
+    sys_inst_->OverInstallOnFullInstaller(kDiffInstall);
 }
 
 // Repair version folder.
 TEST_F(MiniInstallTest, RepairFolderOnFullUser) {
-  user_inst_->Repair(ChromeMiniInstaller::VERSION_FOLDER);
+  if (!chrome_frame_)
+    user_inst_->Repair(ChromeMiniInstaller::VERSION_FOLDER);
 }
+
 TEST_F(MiniInstallTest, RepairFolderOnFullSys) {
-  sys_inst_->Repair(ChromeMiniInstaller::VERSION_FOLDER);
+  if (!chrome_frame_)
+    sys_inst_->Repair(ChromeMiniInstaller::VERSION_FOLDER);
 }
 
 // Repair registry.
 TEST_F(MiniInstallTest, RepairRegistryOnFullUser) {
-  user_inst_->Repair(ChromeMiniInstaller::REGISTRY);
+  if (!chrome_frame_)
+    user_inst_->Repair(ChromeMiniInstaller::REGISTRY);
 }
 TEST_F(MiniInstallTest, RepairRegistryOnFullSys) {
-  sys_inst_->Repair(ChromeMiniInstaller::REGISTRY);
+  if (!chrome_frame_)
+    sys_inst_->Repair(ChromeMiniInstaller::REGISTRY);
 }
 
 // Install standalone.
 TEST_F(MiniInstallTest, InstallStandaloneUser) {
-  user_inst_->InstallStandaloneInstaller();
+  if (!chrome_frame_)
+    user_inst_->InstallStandaloneInstaller();
 }
 
 // This test doesn't make sense. Disabling for now.
 TEST_F(MiniInstallTest, DISABLED_MiniInstallerOverChromeMetaInstallerTest) {
-  user_inst_->OverInstall();
+  if (!chrome_frame_)
+    user_inst_->OverInstall();
 }
 
 // Encountering issue 9593. Disabling temporarily.
 TEST_F(MiniInstallTest,
        DISABLED_InstallLatestStableFullInstallerOverChromeMetaInstaller) {
-  user_inst_->OverInstall();
+  if (!chrome_frame_)
+    user_inst_->OverInstall();
 }
+
 // Encountering issue 9593. Disabling temporarily.
 TEST_F(MiniInstallTest,
        DISABLED_InstallLatestDevFullInstallerOverChromeMetaInstallerTest) {
-  user_inst_->OverInstall();
+  if (!chrome_frame_)
+    user_inst_->OverInstall();
 }
 #endif
 
@@ -141,7 +178,8 @@ TEST_F(MiniInstallTest, InstallMiniInstallerSys) {
 }
 
 TEST_F(MiniInstallTest, InstallMiniInstallerUser) {
-  user_inst_->Install();
+  if (!chrome_frame_)
+    user_inst_->Install();
 }
 
 TEST_F(MiniInstallTest, MiniInstallTestValidWindowsVersion) {