Trying to fix flaky error in CopyTreeWorkItemTest.NewNameAndCopyTest

chrome/installer/util/copy_tree_work_item_unittest.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 <windows.h>
 
 #include <fstream>
 #include <iostream>
 
 #include "base/base_paths.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
+#include "base/platform_thread.h"
 #include "base/process_util.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "chrome/installer/util/work_item.h"
 #include "chrome/installer/util/copy_tree_work_item.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
   class CopyTreeWorkItemTest : public testing::Test {
    protected:
@@ skipping 30 matching lines @@
   // Simple function to dump some text into a new file.
   void CreateTextFile(const std::wstring& filename,
                       const std::wstring& contents) {
     std::ofstream file;
     file.open(filename.c_str());
     ASSERT_TRUE(file.is_open());
     file << contents;
     file.close();
   }
 
+  bool IsFileInUse(std::wstring path) {
+    if (!file_util::PathExists(path))
+      return false;
+
+    HANDLE handle = ::CreateFile(path.c_str(), FILE_ALL_ACCESS,
+                                 NULL, NULL, OPEN_EXISTING, NULL, NULL);
+    if (handle  == INVALID_HANDLE_VALUE)
+      return true;
+
+    CloseHandle(handle);
+    return false;
+  }
+
   // Simple function to read text from a file.
   std::wstring ReadTextFile(const std::wstring& filename) {
     WCHAR contents[64];
     std::wifstream file;
     file.open(filename.c_str());
     EXPECT_TRUE(file.is_open());
     file.getline(contents, 64);
     file.close();
     return std::wstring(contents);
   }
@@ skipping 365 matching lines @@
   TerminateProcess(pi.hProcess, 0);
   // make sure the handle is closed.
   EXPECT_TRUE(WaitForSingleObject(pi.hProcess, 10000) == WAIT_OBJECT_0);
   CloseHandle(pi.hProcess);
   CloseHandle(pi.hThread);
 
   // Now the process has terminated, lets try overwriting the file again
   work_item.reset(WorkItem::CreateCopyTreeWorkItem(
       file_name_from, file_name_to, temp_dir_, WorkItem::NEW_NAME_IF_IN_USE,
       alternate_to));
+  if (IsFileInUse(file_name_to))
+    PlatformThread::Sleep(2000);
+  // If file is still in use, the rest of the test will fail.
+  ASSERT_FALSE(IsFileInUse(file_name_to));
   EXPECT_TRUE(work_item->Do());
 
   EXPECT_TRUE(file_util::PathExists(file_name_from));
   EXPECT_TRUE(file_util::PathExists(file_name_to));
   EXPECT_EQ(0, ReadTextFile(file_name_from).compare(text_content_1));
   EXPECT_TRUE(file_util::ContentsEqual(file_name_from, file_name_to));
   // verify that the backup path does exist
   EXPECT_TRUE(file_util::PathExists(backup_file));
   EXPECT_FALSE(file_util::PathExists(alternate_to));
 
@@ skipping 201 matching lines @@
   LOG(INFO) << "compare " << file_name_from_1 << " and " << file_name_to_1;
   EXPECT_TRUE(file_util::ContentsEqual(file_name_from_1, file_name_to_1));
 
   std::wstring file_name_to_2(dir_name_to);
   file_util::AppendToPath(&file_name_to_2, L"2");
   file_util::AppendToPath(&file_name_to_2, L"File_2.txt");
   EXPECT_TRUE(file_util::PathExists(file_name_to_2));
   LOG(INFO) << "compare " << file_name_from_2 << " and " << file_name_to_2;
   EXPECT_TRUE(file_util::ContentsEqual(file_name_from_2, file_name_to_2));
 }