[Downloads] Path collision check should be case insensitive.

chrome/browser/download/download_path_reservation_tracker_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 365 matching lines @@
   EXPECT_TRUE(IsPathInUse(path));
   EXPECT_FALSE(IsPathInUse(uniquified_path));
 
   EXPECT_EQ(path.value(), reserved_path1.value());
   EXPECT_EQ(path.value(), reserved_path3.value());
 
   SetDownloadItemState(item1.get(), DownloadItem::COMPLETE);
   SetDownloadItemState(item3.get(), DownloadItem::COMPLETE);
 }
 
+// Two active downloads shouldn't be able to reserve paths that only differ by
+// case.
+TEST_F(DownloadPathReservationTrackerTest, ConflictingCaseReservations) {
+  std::unique_ptr<MockDownloadItem> item1(CreateDownloadItem(1));
+  std::unique_ptr<MockDownloadItem> item2(CreateDownloadItem(2));
+
+  base::FilePath path_foo =
+      GetPathInDownloadsDirectory(FILE_PATH_LITERAL("foo.txt"));
+  base::FilePath path_Foo =
+      GetPathInDownloadsDirectory(FILE_PATH_LITERAL("Foo.txt"));
+
+  base::FilePath first_reservation;
+  bool verified = false;
+  CallGetReservedPath(item1.get(), path_foo, false,
+                      DownloadPathReservationTracker::UNIQUIFY,
+                      &first_reservation, &verified);
+  EXPECT_TRUE(IsPathInUse(path_foo));
+  EXPECT_TRUE(verified);
+  EXPECT_EQ(path_foo, first_reservation);
+
+  // Foo should also be in use at this point.
+  EXPECT_TRUE(IsPathInUse(path_Foo));
+
+  base::FilePath second_reservation;
+  CallGetReservedPath(item2.get(), path_Foo, false,
+                      DownloadPathReservationTracker::UNIQUIFY,
+                      &second_reservation, &verified);
+  EXPECT_TRUE(verified);
+  EXPECT_EQ(GetPathInDownloadsDirectory(FILE_PATH_LITERAL("Foo (1).txt")),

[svaldez, 2016/07/11 15:40:52]

Should the original path also be checked?

[asanka, 2016/07/11 16:27:50]

That case is covered in ConflictingReservations test above. Let me know if
that's not what you meant.

+            second_reservation);
+  SetDownloadItemState(item1.get(), DownloadItem::COMPLETE);
+  SetDownloadItemState(item2.get(), DownloadItem::COMPLETE);
+}
+
 // If a unique path cannot be determined after trying kMaxUniqueFiles
 // uniquifiers, then the callback should notified that verification failed, and
 // the returned path should be set to the original requested path.
 TEST_F(DownloadPathReservationTrackerTest, UnresolvedConflicts) {
   base::FilePath path(
       GetPathInDownloadsDirectory(FILE_PATH_LITERAL("foo.txt")));
   std::unique_ptr<MockDownloadItem>
       items[DownloadPathReservationTracker::kMaxUniqueFiles + 1];
   DownloadPathReservationTracker::FilenameConflictAction conflict_action =
     DownloadPathReservationTracker::UNIQUIFY;
@@ skipping 272 matching lines @@
       path,
       create_directory,
       conflict_action,
       &reserved_path,
       &verified);
   // We cannot truncate a path with very long extension.
   EXPECT_FALSE(verified);
   SetDownloadItemState(item.get(), DownloadItem::COMPLETE);
 }
 
-#endif
+#endif  // Platforms that support filename truncation.