In system level install case go back to copying files instead of moving them.

chrome/installer/setup/install.cc

 // Copyright (c) 2006-2008 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 <time.h>
 
 #include "base/file_util.h"
 #include "base/registry.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
@@ skipping 80 matching lines @@
                                          L"InstallDate",
                                          buffer, false);
   }
 }
 
 void AddInstallerCopyTasks(const std::wstring& exe_path,
                            const std::wstring& archive_path,
                            const std::wstring& temp_path,
                            const std::wstring& install_path,
                            const std::wstring& new_version,
-                           WorkItemList* install_list) {
+                           WorkItemList* install_list,
+                           bool system_level) {
   std::wstring installer_dir(installer::GetInstallerPathUnderChrome(
       install_path, new_version));
   install_list->AddCreateDirWorkItem(installer_dir);
 
   std::wstring exe_dst(installer_dir);
   std::wstring archive_dst(installer_dir);
   file_util::AppendToPath(&exe_dst,
       file_util::GetFilenameFromPath(exe_path));
   file_util::AppendToPath(&archive_dst,
       file_util::GetFilenameFromPath(archive_path));
 
   install_list->AddCopyTreeWorkItem(exe_path, exe_dst, temp_path,
                                     WorkItem::ALWAYS);
-  install_list->AddMoveTreeWorkItem(archive_path, archive_dst, temp_path);
+  if (system_level) {
+    install_list->AddCopyTreeWorkItem(archive_path, archive_dst, temp_path,
+                                      WorkItem::ALWAYS);
+  } else {
+    install_list->AddMoveTreeWorkItem(archive_path, archive_dst, temp_path);
+  }
 }
 
 // This method tells if we are running on 64 bit platform so that we can copy
 // one extra exe. If the API call to determine 64 bit fails, we play it safe
 // and return true anyway so that the executable can be copied.
 bool Is64bit() {
   typedef BOOL (WINAPI *WOW_FUNC)(HANDLE, PBOOL);
   BOOL is64 = FALSE;
 
   HANDLE handle = GetCurrentProcess();
@@ skipping 17 matching lines @@
                                   const HKEY reg_root,
                                   const Version& new_version) {
   if (reg_root != HKEY_LOCAL_MACHINE && reg_root != HKEY_CURRENT_USER)
     return false;
 
   scoped_ptr<WorkItemList> install_list(WorkItem::CreateWorkItemList());
   // A temp directory that work items need and the actual install directory.
   install_list->AddCreateDirWorkItem(temp_dir);
   install_list->AddCreateDirWorkItem(install_path);
 
-  // Move the version folder
-  install_list->AddMoveTreeWorkItem(
-      AppendPath(src_path, new_version.GetString()),
-      AppendPath(install_path, new_version.GetString()),
-      temp_dir);
+  // If it is system level install copy the version folder (since we want to
+  // take the permissions of %ProgramFiles% folder) otherwise just move it. 
+  if (reg_root == HKEY_LOCAL_MACHINE) {
+    install_list->AddCopyTreeWorkItem(
+        AppendPath(src_path, new_version.GetString()),
+        AppendPath(install_path, new_version.GetString()),
+        temp_dir, WorkItem::ALWAYS);
+  } else {
+    install_list->AddMoveTreeWorkItem(
+        AppendPath(src_path, new_version.GetString()),
+        AppendPath(install_path, new_version.GetString()),
+        temp_dir);
+  }
 
   // Delete any new_chrome.exe if present (we will end up create a new one
   // if required) and then copy chrome.exe
   std::wstring new_chrome_exe = AppendPath(install_path,
                                            installer_util::kChromeNewExe);
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   RegKey chrome_key(reg_root, dist->GetVersionKey().c_str(), KEY_READ);
   std::wstring current_version;
   if (file_util::PathExists(new_chrome_exe))
     chrome_key.ReadValue(google_update::kRegOldVersionField, &current_version);
   if (current_version.empty())
     chrome_key.ReadValue(google_update::kRegVersionField, &current_version);
   chrome_key.Close();
 
   install_list->AddDeleteTreeWorkItem(new_chrome_exe, std::wstring());
   install_list->AddCopyTreeWorkItem(
       AppendPath(src_path, installer_util::kChromeExe),
       AppendPath(install_path, installer_util::kChromeExe),
       temp_dir, WorkItem::NEW_NAME_IF_IN_USE, new_chrome_exe);
 
   // Extra executable for 64 bit systems.
   if (Is64bit()) {
-    install_list->AddMoveTreeWorkItem(
+    install_list->AddCopyTreeWorkItem(
         AppendPath(src_path, installer::kWowHelperExe),
         AppendPath(install_path, installer::kWowHelperExe),
-        temp_dir);
+        temp_dir, WorkItem::ALWAYS);
   }
 
   // Copy the default Dictionaries only if the folder doesnt exist already
   install_list->AddCopyTreeWorkItem(
       AppendPath(src_path, installer::kDictionaries),
       AppendPath(install_path, installer::kDictionaries),
       temp_dir, WorkItem::IF_NOT_PRESENT);
 
   // Copy installer in install directory and
   // add shortcut in Control Panel->Add/Remove Programs.
   AddInstallerCopyTasks(exe_path, archive_path, temp_dir, install_path,
-      new_version.GetString(), install_list.get());
+                        new_version.GetString(), install_list.get(),
+                        (reg_root == HKEY_LOCAL_MACHINE));
   std::wstring product_name = dist->GetApplicationName();
   AddUninstallShortcutWorkItems(reg_root, exe_path, install_path,
       product_name, new_version.GetString(), install_list.get());
 
   // Delete any old_chrome.exe if present.
   install_list->AddDeleteTreeWorkItem(
       AppendPath(install_path, installer_util::kChromeOldExe), std::wstring());
 
   // Create Version key (if not already present) and set the new Chrome
   // version as last step.
@@ skipping 91 matching lines @@
     }
   }
 
   if (!success) {
     LOG(ERROR) << "Install failed, rolling back... ";
     install_list->Rollback();
     LOG(ERROR) << "Rollback complete. ";
   }
   return success;
 }