Truncate the download file name if it exceeds the filesystem limit.

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 <map>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
+#include "base/string_util.h"
+#include "base/sys_info.h"
 #include "chrome/browser/download/download_util.h"
 #include "chrome/common/chrome_paths.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_id.h"
 #include "content/public/browser/download_item.h"
 
 using content::BrowserThread;
 using content::DownloadId;
 using content::DownloadItem;
 
 namespace {
 
 typedef std::map<content::DownloadId, FilePath> ReservationMap;
 
+// The lower bound for file name truncation. If the truncation results in a name
+// shorter than this limit, we give up automatic truncation and prompt the user.
+static const int kTruncatedNameLengthLowerbound = 5;
+
 // Map of download path reservations. Each reserved path is associated with a
 // DownloadId. This object is destroyed in |Revoke()| when there are no more
 // reservations.
 //
 // It is not an error, although undesirable, to have multiple DownloadIds that
 // are mapped to the same path. This can happen if a reservation is created that
 // is supposed to overwrite an existing reservation.
 ReservationMap* g_reservation_map = NULL;
 
 // Observes a DownloadItem for changes to its target path and state. Updates or
@@ skipping 44 matching lines @@
   if (IsPathReserved(path))
     return true;
 
   // If the path exists in the file system, then the path is in use.
   if (file_util::PathExists(path))
     return true;
 
   return false;
 }
 
+// Truncate the given name so that its becomes .size() <= limit. Returns an
+// empty string if it is impossible due to unknown file-name encoding.
+FilePath::StringType TruncateFileName(const FilePath::StringType& name,
+                                      size_t limit) {
+  FilePath::StringType truncated;
+#if defined(OS_CHROMEOS) || defined(OS_MACOSX)
+  TruncateUTF8ToByteSize(name, limit, &truncated);
+#elif defined(OS_WIN)
+  // TODO(kinaba): Implement for Windows, where StringType == string16.
+#else
+  // We cannot generally assume that the file name encoding is in UTF-8 (see
+  // the comment for FilePath::AsUTF8Unsafe), hence no safe way to truncate.
+#endif
+  return truncated;
+}
+
 // Called on the FILE thread to reserve a download path. This method:
 // - Creates directory |default_download_path| if it doesn't exist.
 // - Verifies that the parent directory of |suggested_path| exists and is
 //   writeable.
+// - Truncates the suggested name if it exceeds the filesystem's limit.
 // - Uniquifies |suggested_path| if |should_uniquify_path| is true.
 // - Schedules |callback| on the UI thread with the reserved path and a flag
 //   indicating whether the returned path has been successfully verified.
 void CreateReservation(
     DownloadId download_id,
     const FilePath& suggested_path,
     const FilePath& default_download_path,
     bool should_uniquify,
     const DownloadPathReservationTracker::ReservedPathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
@@ skipping 25 matching lines @@
   // to the user's "My Documents" directory. We'll prompt them in this case.
   FilePath dir = target_path.DirName();
   FilePath filename = target_path.BaseName();
   if (!file_util::PathIsWritable(dir)) {
     DVLOG(1) << "Unable to write to directory \"" << dir.value() << "\"";
     is_path_writeable = false;
     PathService::Get(chrome::DIR_USER_DOCUMENTS, &dir);
     target_path = dir.Append(filename);
   }
 
+  // Check the limit of file name length if it could be obtained. When the
+  // suggested name exceeds the limit, truncate or prompt the user.
+  bool name_too_long = false;
+  if (is_path_writeable) {
+    int max_length = base::SysInfo::GetMaximumPathComponentLength(dir);
+    if (max_length > 0) {
+      // The extension should not be truncated, so we split it first.
+      FilePath::StringType ext = filename.Extension();
+      FilePath::StringType name = filename.RemoveExtension().value();
+
+      // Reserve several characters we may append later.
+      const int kExtraChars = sizeof(" (100).crdownload") - 1;
+      int limit = max_length - ext.size() - kExtraChars;
+      if (static_cast<int>(name.size()) > limit) {
+        name_too_long = true;
+        if (limit >= kTruncatedNameLengthLowerbound) {
+          // Truncate the name to fit in |limit|.
+          FilePath::StringType truncated = TruncateFileName(name, limit);
+          if (!truncated.empty()) {
+            target_path = dir.Append(truncated + ext);
+            name_too_long = false;
+          }
+        }
+      }
+    }
+  }
+
   if (is_path_writeable && should_uniquify && IsPathInUse(target_path)) {
     has_conflicts = true;
     for (int uniquifier = 1;
          uniquifier <= DownloadPathReservationTracker::kMaxUniqueFiles;
          ++uniquifier) {
       FilePath path_to_check(target_path.InsertBeforeExtensionASCII(
           StringPrintf(" (%d)", uniquifier)));
       if (!IsPathInUse(path_to_check)) {
         target_path = path_to_check;
         has_conflicts = false;
         break;
       }
     }
   }
   reservations[download_id] = target_path;
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(callback, target_path, (is_path_writeable && !has_conflicts)));
+  bool verified = (is_path_writeable && !has_conflicts && !name_too_long);
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(callback, target_path, verified));
 }
 
 // Called on the FILE thread to update the path of the reservation associated
 // with |download_id| to |new_path|.
 void UpdateReservation(DownloadId download_id, const FilePath& new_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(g_reservation_map != NULL);
   ReservationMap::iterator iter = g_reservation_map->find(download_id);
   if (iter != g_reservation_map->end()) {
     iter->second = new_path;
@@ skipping 97 matching lines @@
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&CreateReservation, download_item.GetGlobalId(),
                  target_path, default_path, uniquify_path, callback));
 }
 
 // static
 bool DownloadPathReservationTracker::IsPathInUseForTesting(
     const FilePath& path) {
   return IsPathInUse(path);
 }