Match whole path components in DevicePathToDriveLetterPath(). Add tests.

base/file_util_unittest.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #include <shlobj.h>
 #include <tchar.h>
 #include <winioctl.h>
 #endif
 
 #include <algorithm>
 #include <fstream>
 #include <set>
 
 #include "base/base_paths.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/scoped_temp_dir.h"
 #include "base/threading/platform_thread.h"
 #include "base/utf_string_conversions.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_handle.h"
+#include "base/win/win_api_interface.h"
 #endif
 
 // This macro helps avoid wrapped lines in the test structs.
 #define FPL(x) FILE_PATH_LITERAL(x)
 
+using ::testing::_;
+using ::testing::DoAll;
+using ::testing::Invoke;
+using ::testing::Return;
+using ::testing::SetArrayArgument;
+using ::testing::StrictMock;
+
 namespace {
 
 // To test that file_util::Normalize FilePath() deals with NTFS reparse points
 // correctly, we need functions to create and delete reparse points.
 #if defined(OS_WIN)
 typedef struct _REPARSE_DATA_BUFFER {
   ULONG  ReparseTag;
   USHORT  ReparseDataLength;
   USHORT  Reserved;
   union {
@@ skipping 546 matching lines @@
                    FILE_FLAG_BACKUP_SEMANTICS,  // Needed to open a directory.
                    NULL));
   ASSERT_TRUE(dir.IsValid());
   base::PlatformFileInfo info;
   EXPECT_TRUE(base::GetPlatformFileInfo(dir.Get(), &info));
   EXPECT_TRUE(info.is_directory);
   EXPECT_FALSE(info.is_symbolic_link);
   EXPECT_EQ(0, info.size);
 }
 
+namespace {
+
+#if defined(OS_WIN)
+class MockWindowsApi : public base::win::WinApiInterface {
+ public:
+  MOCK_METHOD3(QueryDosDevice, DWORD (LPCTSTR lpDeviceName,
+                                      LPTSTR lpTargetPath,
+                                      DWORD ucchMax));
+  MOCK_METHOD2(GetLogicalDriveStrings, DWORD (DWORD nBufferLength,
+                                              LPTSTR lpBuffer));
+};
+#endif  // defined(OS_WIN)
+
+}  // namespace
+
+TEST_F(FileUtilTest, DevicePathToDriveLetter) {
+  FilePath drive_letter_path;
+  const FilePath kDevicePath(FPL("\\Device\\HardDiskVolume12\\foo\\bar"));
+
+  const TCHAR kEmptyDriveMapping[] = _TEXT("\0\0");
+  const int kEmptyDriveMappingLength = arraysize(kEmptyDriveMapping);
+  const TCHAR kSampleDriveMapping[] = _TEXT("G:\\\0H:\\\0I:\\\0\0");
+  const int kSampleDriveMappingLength = arraysize(kSampleDriveMapping);
+
+  const TCHAR kDeviceNoMatch[] = _TEXT("\\Device\\no_match");
+  const int kDeviceNoMatchLength = arraysize(kDeviceNoMatch);
+
+  const TCHAR kDeviceSubstring[] = _TEXT("\\Device\\HardDiskVolume1");
+  const int kDeviceSubstringLength = arraysize(kDeviceSubstring);
+
+  const TCHAR kDeviceShouldMatch[] = _TEXT("\\Device\\HardDiskVolume12");
+  const int kDeviceShouldMatchLength = arraysize(kDeviceShouldMatch);
+
+  {
+    // Fake failure of GetLogicalDriveStrings().
+    StrictMock<MockWindowsApi> mock_win_api;
+    EXPECT_CALL(mock_win_api, GetLogicalDriveStrings(_, _)).WillOnce(DoAll(
+        SetArrayArgument<1>(kEmptyDriveMapping,
+                            kEmptyDriveMapping + kEmptyDriveMappingLength),
+        Return(0)));
+
+    ASSERT_FALSE(file_util::DevicePathToDriveLetterPath(mock_win_api,
+                                                        kDevicePath,
+                                                        &drive_letter_path));
+  }
+  {
+    // Fake an empty set of mapped drives.
+    StrictMock<MockWindowsApi> mock_win_api;
+    EXPECT_CALL(mock_win_api, GetLogicalDriveStrings(_, _)).WillOnce(DoAll(
+        SetArrayArgument<1>(kEmptyDriveMapping,
+                            kEmptyDriveMapping + kEmptyDriveMappingLength),
+        Return(1)));
+
+    ASSERT_FALSE(file_util::DevicePathToDriveLetterPath(mock_win_api,
+                                                        kDevicePath,
+                                                        &drive_letter_path));
+  }
+  {
+    // QueryDosDevice always fails.
+    StrictMock<MockWindowsApi> mock_win_api;
+    EXPECT_CALL(mock_win_api, GetLogicalDriveStrings(_, _)).WillOnce(DoAll(
+        SetArrayArgument<1>(kSampleDriveMapping,
+                            kSampleDriveMapping + kSampleDriveMappingLength),
+        Return(1)));
+
+    EXPECT_CALL(mock_win_api, QueryDosDevice(_, _, _)).Times(3)
+        .WillRepeatedly(Return(0));
+
+    ASSERT_FALSE(file_util::DevicePathToDriveLetterPath(mock_win_api,
+                                                        kDevicePath,
+                                                        &drive_letter_path));
+  }
+  {
+    // QueryDosDevice succeeds, but no DOS device matches the NT path.
+    StrictMock<MockWindowsApi> mock_win_api;
+
+    EXPECT_CALL(mock_win_api, GetLogicalDriveStrings(_, _)).WillOnce(DoAll(
+        SetArrayArgument<1>(kSampleDriveMapping,
+                            kSampleDriveMapping + kSampleDriveMappingLength),
+        Return(1)));
+
+    EXPECT_CALL(mock_win_api, QueryDosDevice(_, _, _)).Times(3)
+        .WillRepeatedly(DoAll(
+            SetArrayArgument<1>(kDeviceNoMatch,
+                                kDeviceNoMatch + kDeviceNoMatchLength),
+            Return(1)));
+
+    ASSERT_FALSE(file_util::DevicePathToDriveLetterPath(mock_win_api,
+                                                        kDevicePath,
+                                                        &drive_letter_path));
+  }
+  {
+    // QueryDosDevice matches the third item in the list of devices.
+    StrictMock<MockWindowsApi> mock_win_api;
+
+    EXPECT_CALL(mock_win_api, GetLogicalDriveStrings(_, _)).WillOnce(DoAll(
+        SetArrayArgument<1>(kSampleDriveMapping,
+                            kSampleDriveMapping + kSampleDriveMappingLength),
+        Return(1)));
+
+    EXPECT_CALL(mock_win_api, QueryDosDevice(_, _, _)).Times(3)
+         // First drive letter does not match.
+        .WillOnce(DoAll(
+            SetArrayArgument<1>(kDeviceNoMatch,
+                                kDeviceNoMatch + kDeviceNoMatchLength),
+            Return(1)))
+        // Second drive letter has a path that is a substring of the correct
+        // path.  Should not match.
+        .WillOnce(DoAll(
+            SetArrayArgument<1>(kDeviceSubstring,
+                                kDeviceSubstring + kDeviceSubstringLength),
+            Return(1)))
+        // Third drive letter matches.  Should return this one.
+        .WillOnce(DoAll(
+            SetArrayArgument<1>(kDeviceShouldMatch,
+                                kDeviceShouldMatch + kDeviceShouldMatchLength),
+            Return(1)));
+
+    ASSERT_TRUE(file_util::DevicePathToDriveLetterPath(mock_win_api,
+                                                       kDevicePath,
+                                                       &drive_letter_path));
+    ASSERT_EQ(FPL("I:\\foo\\bar"), drive_letter_path.value());
+  }
+  {
+    // Match a path to a drive letter, with no extra path.
+    StrictMock<MockWindowsApi> mock_win_api;
+
+    EXPECT_CALL(mock_win_api, GetLogicalDriveStrings(_, _)).WillOnce(DoAll(
+        SetArrayArgument<1>(kSampleDriveMapping,
+                            kSampleDriveMapping + kSampleDriveMappingLength),
+        Return(1)));
+
+    EXPECT_CALL(mock_win_api, QueryDosDevice(_, _, _)).Times(2)
+        // First call to QueryDosDevice fails.  Shoudl keep going.
+        .WillOnce(Return(0))
+
+        // Next call matches a drive letter.  Should return this one.
+        .WillOnce(DoAll(
+            SetArrayArgument<1>(kDeviceShouldMatch,
+                                kDeviceShouldMatch + kDeviceShouldMatchLength),
+            Return(1)));
+        // After matching, QueryDosDevice should not be called again.
+
+    const FilePath kNtPathToDriveI(FPL("\\Device\\HardDiskVolume12"));
+    ASSERT_TRUE(file_util::DevicePathToDriveLetterPath(mock_win_api,
+                                                       kNtPathToDriveI,
+                                                       &drive_letter_path));
+    ASSERT_EQ(FPL("H:"), drive_letter_path.value());
+  }
+}
+
 #endif  // defined(OS_WIN)
 
 #if defined(OS_POSIX)
 
 TEST_F(FileUtilTest, CreateAndReadSymlinks) {
   FilePath link_from = temp_dir_.path().Append(FPL("from_file"));
   FilePath link_to = temp_dir_.path().Append(FPL("to_file"));
   CreateTextFile(link_to, bogus_content);
 
   ASSERT_TRUE(file_util::CreateSymbolicLink(link_to, link_from))
@@ skipping 1604 matching lines @@
       file_util::VerifyPathControlledByUser(
           base_dir_, text_file_, uid_, ok_gids_));
   EXPECT_TRUE(
       file_util::VerifyPathControlledByUser(
           sub_dir_, text_file_, uid_, ok_gids_));
 }
 
 #endif  // defined(OS_POSIX)
 
 }  // namespace