[Downloads] Path collision check should be case insensitive.

chrome/browser/download/download_path_reservation_tracker.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 "chrome/browser/download/download_path_reservation_tracker.h"
 
 #include <stddef.h>
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/third_party/icu/icu_utf.h"
 #include "build/build_config.h"
 #include "chrome/common/chrome_paths.h"
@@ skipping 51 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(DownloadItemObserver);
 };
 
 // Returns true if the given path is in use by a path reservation.
 bool IsPathReserved(const base::FilePath& path) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   // No reservation map => no reservations.
   if (g_reservation_map == NULL)
     return false;
-  // Unfortunately path normalization doesn't work reliably for non-existant
-  // files. So given a FilePath, we can't derive a normalized key that we can
-  // use for lookups. We only expect a small number of concurrent downloads at
-  // any given time, so going through all of them shouldn't be too slow.
+
+  // We only expect a small number of concurrent downloads at any given time, so
+  // going through all of them shouldn't be too slow.
   for (ReservationMap::const_iterator iter = g_reservation_map->begin();
        iter != g_reservation_map->end(); ++iter) {
-    if (iter->second == path)
+    if (base::FilePath::CompareEqualIgnoreCase(iter->second.value(),
+                                               path.value()))
       return true;
   }
   return false;
 }
 
 // Returns true if the given path is in use by any path reservation or the
 // file system. Called on the FILE thread.
 bool IsPathInUse(const base::FilePath& path) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   // If there is a reservation, then the path is in use.
@@ skipping 61 matching lines @@
     bool create_directory,
     DownloadPathReservationTracker::FilenameConflictAction conflict_action,
     base::FilePath* reserved_path) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(suggested_path.IsAbsolute());
 
   // Create a reservation map if one doesn't exist. It will be automatically
   // deleted when all the reservations are revoked.
   if (g_reservation_map == NULL)
     g_reservation_map = new ReservationMap;
-  ReservationMap& reservations = *g_reservation_map;
 
   // Erase the reservation if it already exists. This can happen during
   // automatic resumption where a new target determination request may be issued
   // for a DownloadItem without an intervening transition to INTERRUPTED.
   //
   // Revoking and re-acquiring the reservation forces us to re-verify the claims
   // we are making about the path.
-  reservations.erase(key);
+  g_reservation_map->erase(key);
 
   base::FilePath target_path(suggested_path.NormalizePathSeparators());
   base::FilePath target_dir = target_path.DirName();
   base::FilePath filename = target_path.BaseName();
   bool is_path_writeable = true;
   bool has_conflicts = false;
   bool name_too_long = false;
 
   // Create target_dir if necessary and appropriate. target_dir may be the last
   // directory that the user selected in a FilePicker; if that directory has
@@ skipping 55 matching lines @@
           if (!IsPathInUse(path_to_check)) {
             target_path = path_to_check;
             has_conflicts = false;
             break;
           }
         }
       }
     }
   }
 
-  reservations[key] = target_path;
+  (*g_reservation_map)[key] = target_path;
   bool verified = (is_path_writeable && !has_conflicts && !name_too_long);
   *reserved_path = target_path;
   return verified;
 }
 
 // Called on the FILE thread to update the path of the reservation associated
 // with |key| to |new_path|.
 void UpdateReservation(ReservationKey key, const base::FilePath& new_path) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(g_reservation_map != NULL);
@@ skipping 122 matching lines @@
       base::Bind(&RunGetReservedPathCallback,
                  callback,
                  base::Owned(reserved_path)));
 }
 
 // static
 bool DownloadPathReservationTracker::IsPathInUseForTesting(
     const base::FilePath& path) {
   return IsPathInUse(path);
 }