Add fallback behavior if the last used profile cannot initialize

base/test/test_file_util_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 "base/test/test_file_util.h"
 
-#include <windows.h>
 #include <aclapi.h>
 #include <shlwapi.h>
 #include <stddef.h>
+#include <wchar.h>
+#include <windows.h>
 
+#include <memory>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_split.h"
 #include "base/threading/platform_thread.h"
 #include "base/win/scoped_handle.h"
 
 namespace base {
 
 namespace {
 
 struct PermissionInfo {
   PSECURITY_DESCRIPTOR security_descriptor;
   ACL dacl;
 };
 
-// Deny |permission| on the file |path|, for the current user.
-bool DenyFilePermission(const FilePath& path, DWORD permission) {
-  PACL old_dacl;
-  PSECURITY_DESCRIPTOR security_descriptor;
-  if (GetNamedSecurityInfo(const_cast<wchar_t*>(path.value().c_str()),
-                           SE_FILE_OBJECT,
-                           DACL_SECURITY_INFORMATION, NULL, NULL, &old_dacl,
-                           NULL, &security_descriptor) != ERROR_SUCCESS) {
-    return false;
-  }
-
-  EXPLICIT_ACCESS change;
-  change.grfAccessPermissions = permission;
-  change.grfAccessMode = DENY_ACCESS;
-  change.grfInheritance = 0;
-  change.Trustee.pMultipleTrustee = NULL;
-  change.Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
-  change.Trustee.TrusteeForm = TRUSTEE_IS_NAME;
-  change.Trustee.TrusteeType = TRUSTEE_IS_USER;
-  change.Trustee.ptstrName = const_cast<wchar_t*>(L"CURRENT_USER");
-
-  PACL new_dacl;
-  if (SetEntriesInAcl(1, &change, old_dacl, &new_dacl) != ERROR_SUCCESS) {
-    LocalFree(security_descriptor);
-    return false;
-  }
-
-  DWORD rc = SetNamedSecurityInfo(const_cast<wchar_t*>(path.value().c_str()),
-                                  SE_FILE_OBJECT, DACL_SECURITY_INFORMATION,
-                                  NULL, NULL, new_dacl, NULL);
-  LocalFree(security_descriptor);
-  LocalFree(new_dacl);
-
-  return rc == ERROR_SUCCESS;
-}
-
 // Gets a blob indicating the permission information for |path|.
 // |length| is the length of the blob.  Zero on failure.
 // Returns the blob pointer, or NULL on failure.
 void* GetPermissionInfo(const FilePath& path, size_t* length) {
   DCHECK(length != NULL);
   *length = 0;
   PACL dacl = NULL;
   PSECURITY_DESCRIPTOR security_descriptor;
   if (GetNamedSecurityInfo(const_cast<wchar_t*>(path.value().c_str()),
                            SE_FILE_OBJECT,
@@ skipping 26 matching lines @@
                                   SE_FILE_OBJECT, DACL_SECURITY_INFORMATION,
                                   NULL, NULL, &perm->dacl, NULL);
   LocalFree(perm->security_descriptor);
 
   char* char_array = reinterpret_cast<char*>(info);
   delete [] char_array;
 
   return rc == ERROR_SUCCESS;
 }
 
+template <class T>
+std::unique_ptr<T[]> ToCStr(const std::basic_string<T>& str) {

[Peter Kasting, 2016/07/28 20:09:49]

Don't templatize this.  Use "std::wstring" directly.

The templatization is a lie anyway; wcsncpy() requires that its arguments be
wchar_t*, so |str| has to be a wstring.  And it always is, since this file is
only built on Windows, and FilePath::value() returns a wstring there.

[WC Leung, 2016/08/01 18:03:06]

Done.

+  size_t size = str.size() + 1;
+  std::unique_ptr<T[]> ptr = base::MakeUnique<T[]>(size);
+  wcsncpy(ptr.get(), str.c_str(), size);
+  return ptr;
+}
+
 }  // namespace
 
 bool DieFileDie(const FilePath& file, bool recurse) {
   // It turns out that to not induce flakiness a long timeout is needed.
   const int kIterations = 25;
   const TimeDelta kTimeout = TimeDelta::FromSeconds(10) / kIterations;
 
   if (!PathExists(file))
     return true;
 
@@ skipping 20 matching lines @@
   // local experimentation validates this simplified and *much* faster approach:
   // [1] Sysinternals RamMap no longer lists these files as cached afterwards.
   // [2] Telemetry performance test startup.cold.blank_page reports sane values.
   BY_HANDLE_FILE_INFORMATION bhi = {0};
   CHECK(::GetFileInformationByHandle(file_handle.Get(), &bhi));
   CHECK(::SetFileTime(file_handle.Get(), &bhi.ftCreationTime,
                       &bhi.ftLastAccessTime, &bhi.ftLastWriteTime));
   return true;
 }
 
+// Deny |permission| on the file |path|, for the current user.
+bool DenyFilePermission(const FilePath& path, DWORD permission) {
+  PACL old_dacl;
+  PSECURITY_DESCRIPTOR security_descriptor;
+
+  std::unique_ptr<TCHAR[]> path_ptr = ToCStr(path.value());
+  if (GetNamedSecurityInfo(path_ptr.get(), SE_FILE_OBJECT,
+                           DACL_SECURITY_INFORMATION, nullptr, nullptr,
+                           &old_dacl, nullptr,
+                           &security_descriptor) != ERROR_SUCCESS) {
+    return false;
+  }
+
+  std::unique_ptr<TCHAR[]> current_user = ToCStr(std::wstring(L"CURRENT_USER"));
+  EXPLICIT_ACCESS new_access = {
+      permission,
+      DENY_ACCESS,
+      0,
+      {nullptr, NO_MULTIPLE_TRUSTEE, TRUSTEE_IS_NAME, TRUSTEE_IS_USER,
+       current_user.get()}};
+
+  PACL new_dacl;
+  if (SetEntriesInAcl(1, &new_access, old_dacl, &new_dacl) != ERROR_SUCCESS) {
+    LocalFree(security_descriptor);
+    return false;
+  }
+
+  DWORD rc = SetNamedSecurityInfo(path_ptr.get(), SE_FILE_OBJECT,
+                                  DACL_SECURITY_INFORMATION, nullptr, nullptr,
+                                  new_dacl, nullptr);
+  LocalFree(security_descriptor);
+  LocalFree(new_dacl);
+
+  return rc == ERROR_SUCCESS;
+}
+
 // Checks if the volume supports Alternate Data Streams. This is required for
 // the Zone Identifier implementation.
 bool VolumeSupportsADS(const FilePath& path) {
   wchar_t drive[MAX_PATH] = {0};
   wcscpy_s(drive, MAX_PATH, path.value().c_str());
 
   if (!PathStripToRootW(drive))
     return false;
 
   DWORD fs_flags = 0;
@@ skipping 44 matching lines @@
   DCHECK(info_ != NULL);
   DCHECK_NE(0u, length_);
 }
 
 FilePermissionRestorer::~FilePermissionRestorer() {
   if (!RestorePermissionInfo(path_, info_, length_))
     NOTREACHED();
 }
 
 }  // namespace base