Move the windows-specific scoped_* stuff from base to base/win and in the bas...

base/file_util_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 "base/file_util.h"
 
 #include <windows.h>
 #include <propvarutil.h>
 #include <psapi.h>
 #include <shellapi.h>
 #include <shlobj.h>
 #include <time.h>
 #include <string>
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/pe_image.h"
-#include "base/scoped_comptr_win.h"
-#include "base/scoped_handle.h"
+#include "base/win/scoped_handle.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/win_util.h"
+#include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 
 namespace file_util {
 
 namespace {
 
 const DWORD kFileShareAll =
     FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
 
 // Helper for NormalizeFilePath(), defined below.
@@ skipping 285 matching lines @@
 
   FILETIME local_filetime;
   if (!FileTimeToLocalFileTime(&utc_filetime, &local_filetime))
     return false;
 
   return !!FileTimeToSystemTime(&local_filetime, creation_time);
 }
 
 bool GetFileCreationLocalTime(const std::wstring& filename,
                               LPSYSTEMTIME creation_time) {
-  ScopedHandle file_handle(
+  base::win::ScopedHandle file_handle(
       CreateFile(filename.c_str(), GENERIC_READ, kFileShareAll, NULL,
                  OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL));
   return GetFileCreationLocalTimeFromHandle(file_handle.Get(), creation_time);
 }
 
 bool ResolveShortcut(FilePath* path) {
   HRESULT result;
-  ScopedComPtr<IShellLink> i_shell_link;
+  base::win::ScopedComPtr<IShellLink> i_shell_link;
   bool is_resolved = false;
 
   // Get pointer to the IShellLink interface
   result = i_shell_link.CreateInstance(CLSID_ShellLink, NULL,
                                        CLSCTX_INPROC_SERVER);
   if (SUCCEEDED(result)) {
-    ScopedComPtr<IPersistFile> persist;
+    base::win::ScopedComPtr<IPersistFile> persist;
     // Query IShellLink for the IPersistFile interface
     result = persist.QueryFrom(i_shell_link);
     if (SUCCEEDED(result)) {
       WCHAR temp_path[MAX_PATH];
       // Load the shell link
       result = persist->Load(path->value().c_str(), STGM_READ);
       if (SUCCEEDED(result)) {
         // Try to find the target of a shortcut
         result = i_shell_link->Resolve(0, SLR_NO_UI);
         if (SUCCEEDED(result)) {
@@ skipping 10 matching lines @@
 }
 
 bool CreateShortcutLink(const wchar_t *source, const wchar_t *destination,
                         const wchar_t *working_dir, const wchar_t *arguments,
                         const wchar_t *description, const wchar_t *icon,
                         int icon_index, const wchar_t* app_id) {
   // Length of arguments and description must be less than MAX_PATH.
   DCHECK(lstrlen(arguments) < MAX_PATH);
   DCHECK(lstrlen(description) < MAX_PATH);
 
-  ScopedComPtr<IShellLink> i_shell_link;
-  ScopedComPtr<IPersistFile> i_persist_file;
+  base::win::ScopedComPtr<IShellLink> i_shell_link;
+  base::win::ScopedComPtr<IPersistFile> i_persist_file;
 
   // Get pointer to the IShellLink interface
   HRESULT result = i_shell_link.CreateInstance(CLSID_ShellLink, NULL,
                                                CLSCTX_INPROC_SERVER);
   if (FAILED(result))
     return false;
 
   // Query IShellLink for the IPersistFile interface
   result = i_persist_file.QueryFrom(i_shell_link);
   if (FAILED(result))
     return false;
 
   if (FAILED(i_shell_link->SetPath(source)))
     return false;
 
   if (working_dir && FAILED(i_shell_link->SetWorkingDirectory(working_dir)))
     return false;
 
   if (arguments && FAILED(i_shell_link->SetArguments(arguments)))
     return false;
 
   if (description && FAILED(i_shell_link->SetDescription(description)))
     return false;
 
   if (icon && FAILED(i_shell_link->SetIconLocation(icon, icon_index)))
     return false;
 
   if (app_id && (base::win::GetVersion() >= base::win::VERSION_WIN7)) {
-    ScopedComPtr<IPropertyStore> property_store;
+    base::win::ScopedComPtr<IPropertyStore> property_store;
     if (FAILED(property_store.QueryFrom(i_shell_link)))
       return false;
 
     if (!win_util::SetAppIdForPropertyStore(property_store, app_id))
       return false;
   }
 
   result = i_persist_file->Save(destination, TRUE);
   return SUCCEEDED(result);
 }
 
 
 bool UpdateShortcutLink(const wchar_t *source, const wchar_t *destination,
                         const wchar_t *working_dir, const wchar_t *arguments,
                         const wchar_t *description, const wchar_t *icon,
                         int icon_index, const wchar_t* app_id) {
   // Length of arguments and description must be less than MAX_PATH.
   DCHECK(lstrlen(arguments) < MAX_PATH);
   DCHECK(lstrlen(description) < MAX_PATH);
 
   // Get pointer to the IPersistFile interface and load existing link
-  ScopedComPtr<IShellLink> i_shell_link;
+  base::win::ScopedComPtr<IShellLink> i_shell_link;
   if (FAILED(i_shell_link.CreateInstance(CLSID_ShellLink, NULL,
                                          CLSCTX_INPROC_SERVER)))
     return false;
 
-  ScopedComPtr<IPersistFile> i_persist_file;
+  base::win::ScopedComPtr<IPersistFile> i_persist_file;
   if (FAILED(i_persist_file.QueryFrom(i_shell_link)))
     return false;
 
   if (FAILED(i_persist_file->Load(destination, STGM_READWRITE)))
     return false;
 
   if (source && FAILED(i_shell_link->SetPath(source)))
     return false;
 
   if (working_dir && FAILED(i_shell_link->SetWorkingDirectory(working_dir)))
     return false;
 
   if (arguments && FAILED(i_shell_link->SetArguments(arguments)))
     return false;
 
   if (description && FAILED(i_shell_link->SetDescription(description)))
     return false;
 
   if (icon && FAILED(i_shell_link->SetIconLocation(icon, icon_index)))
     return false;
 
   if (app_id && base::win::GetVersion() >= base::win::VERSION_WIN7) {
-    ScopedComPtr<IPropertyStore> property_store;
+    base::win::ScopedComPtr<IPropertyStore> property_store;
     if (FAILED(property_store.QueryFrom(i_shell_link)))
       return false;
 
     if (!win_util::SetAppIdForPropertyStore(property_store, app_id))
       return false;
   }
 
   HRESULT result = i_persist_file->Save(destination, TRUE);
   return SUCCEEDED(result);
 }
@@ skipping 197 matching lines @@
 FILE* OpenFile(const FilePath& filename, const char* mode) {
   std::wstring w_mode = ASCIIToWide(std::string(mode));
   return _wfsopen(filename.value().c_str(), w_mode.c_str(), _SH_DENYNO);
 }
 
 FILE* OpenFile(const std::string& filename, const char* mode) {
   return _fsopen(filename.c_str(), mode, _SH_DENYNO);
 }
 
 int ReadFile(const FilePath& filename, char* data, int size) {
-  ScopedHandle file(CreateFile(filename.value().c_str(),
-                               GENERIC_READ,
-                               FILE_SHARE_READ | FILE_SHARE_WRITE,
-                               NULL,
-                               OPEN_EXISTING,
-                               FILE_FLAG_SEQUENTIAL_SCAN,
-                               NULL));
+  base::win::ScopedHandle file(CreateFile(filename.value().c_str(),
+                                          GENERIC_READ,
+                                          FILE_SHARE_READ | FILE_SHARE_WRITE,
+                                          NULL,
+                                          OPEN_EXISTING,
+                                          FILE_FLAG_SEQUENTIAL_SCAN,
+                                          NULL));
   if (!file)
     return -1;
 
   DWORD read;
   if (::ReadFile(file, data, size, &read, NULL) &&
       static_cast<int>(read) == size)
     return read;
   return -1;
 }
 
 int WriteFile(const FilePath& filename, const char* data, int size) {
-  ScopedHandle file(CreateFile(filename.value().c_str(),
-                               GENERIC_WRITE,
-                               0,
-                               NULL,
-                               CREATE_ALWAYS,
-                               0,
-                               NULL));
+  base::win::ScopedHandle file(CreateFile(filename.value().c_str(),
+                                          GENERIC_WRITE,
+                                          0,
+                                          NULL,
+                                          CREATE_ALWAYS,
+                                          0,
+                                          NULL));
   if (!file) {
     LOG(WARNING) << "CreateFile failed for path " << filename.value() <<
         " error code=" << GetLastError() <<
         " error text=" << win_util::FormatLastWin32Error();
     return -1;
   }
 
   DWORD written;
   BOOL result = ::WriteFile(file, data, size, &written, NULL);
   if (result && static_cast<int>(written) == size)
@@ skipping 241 matching lines @@
   // that we return a path starting with a drive letter.
   return DevicePathToDriveLetterPath(mapped_file, real_path);
 }
 
 bool NormalizeToNativeFilePath(const FilePath& path, FilePath* nt_path) {
   // In Vista, GetFinalPathNameByHandle() would give us the real path
   // from a file handle.  If we ever deprecate XP, consider changing the
   // code below to a call to GetFinalPathNameByHandle().  The method this
   // function uses is explained in the following msdn article:
   // http://msdn.microsoft.com/en-us/library/aa366789(VS.85).aspx
-  ScopedHandle file_handle(
+  base::win::ScopedHandle file_handle(
       ::CreateFile(path.value().c_str(),
                    GENERIC_READ,
                    kFileShareAll,
                    NULL,
                    OPEN_EXISTING,
                    FILE_ATTRIBUTE_NORMAL,
                    NULL));
   if (!file_handle)
     return false;
 
   // Create a file mapping object.  Can't easily use MemoryMappedFile, because
   // we only map the first byte, and need direct access to the handle. You can
   // not map an empty file, this call fails in that case.
-  ScopedHandle file_map_handle(
+  base::win::ScopedHandle file_map_handle(
       ::CreateFileMapping(file_handle.Get(),
                           NULL,
                           PAGE_READONLY,
                           0,
                           1, // Just one byte.  No need to look at the data.
                           NULL));
   if (!file_map_handle)
     return false;
 
   // Use a view of the file to get the path to the file.
@@ skipping 19 matching lines @@
   ::UnmapViewOfFile(file_view);
   return success;
 }
 
 bool PreReadImage(const wchar_t* file_path, size_t size_to_read,
                   size_t step_size) {
   if (base::win::GetVersion() > base::win::VERSION_XP) {
     // Vista+ branch. On these OSes, the forced reads through the DLL actually
     // slows warm starts. The solution is to sequentially read file contents
     // with an optional cap on total amount to read.
-    ScopedHandle file(
+    base::win::ScopedHandle file(
         CreateFile(file_path,
                    GENERIC_READ,
                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                    NULL,
                    OPEN_EXISTING,
                    FILE_FLAG_SEQUENTIAL_SCAN,
                    NULL));
 
     if (!file.IsValid())
       return false;
@@ skipping 39 matching lines @@
       uint8 unused = *(touch + offset);
       offset += step_size;
     }
     FreeLibrary(dll_module);
   }
 
   return true;
 }
 
 }  // namespace file_util