Cleanup: Deprecate wstring version of file_util::CopyDirectory().

chrome/browser/ui/views/select_file_dialog_win.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 "chrome/browser/ui/select_file_dialog.h"
 
 #include <windows.h>
 #include <commdlg.h>
 #include <shlobj.h>
 
 #include <algorithm>
@@ skipping 10 matching lines @@
 #include "base/win/registry.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 #include "content/public/browser/browser_thread.h"
 #include "grit/generated_resources.h"
 #include "grit/ui_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
 
+namespace {
+
+// Given |extension|, if it's not empty, then remove the leading dot.
+std::wstring GetExtensionWithoutLeadingDot(const std::wstring& extension) {
+  DCHECK(extension.empty() || extension[0] == L'.');
+  return extension.empty() ? extension : extension.substr(1);
+}
+
+}  // namespace
+
 // This function takes the output of a SaveAs dialog: a filename, a filter and
 // the extension originally suggested to the user (shown in the dialog box) and
 // returns back the filename with the appropriate extension tacked on. If the
 // user requests an unknown extension and is not using the 'All files' filter,
 // the suggested extension will be appended, otherwise we will leave the
 // filename unmodified. |filename| should contain the filename selected in the
 // SaveAs dialog box and may include the path, |filter_selected| should be
 // '*.something', for example '*.*' or it can be blank (which is treated as
 // *.*). |suggested_ext| should contain the extension without the dot (.) in
 // front, for example 'jpg'.
 std::wstring AppendExtensionIfNeeded(const std::wstring& filename,
                                      const std::wstring& filter_selected,
                                      const std::wstring& suggested_ext) {
   DCHECK(!filename.empty());
   std::wstring return_value = filename;
 
   // If we wanted a specific extension, but the user's filename deleted it or
   // changed it to something that the system doesn't understand, re-append.
   // Careful: Checking net::GetMimeTypeFromExtension() will only find
   // extensions with a known MIME type, which many "known" extensions on Windows
   // don't have.  So we check directly for the "known extension" registry key.
-  std::wstring file_extension(file_util::GetFileExtensionFromPath(filename));
+  std::wstring file_extension(
+      GetExtensionWithoutLeadingDot(FilePath(filename).Extension()));
   std::wstring key(L"." + file_extension);
   if (!(filter_selected.empty() || filter_selected == L"*.*") &&
       !base::win::RegKey(HKEY_CLASSES_ROOT, key.c_str(), KEY_READ).Valid() &&
       file_extension != suggested_ext) {
     if (return_value[return_value.length() - 1] != L'.')
       return_value.append(L".");
     return_value.append(suggested_ext);
   }
 
   // Strip any trailing dots, which Windows doesn't allow.
@@ skipping 173 matching lines @@
                           const std::wstring& suggested_name,
                           const std::wstring& filter,
                           const std::wstring& def_ext,
                           bool ignore_suggested_ext,
                           unsigned* index,
                           std::wstring* final_name) {
   DCHECK(final_name);
   // Having an empty filter makes for a bad user experience. We should always
   // specify a filter when saving.
   DCHECK(!filter.empty());
-  std::wstring file_part = FilePath(suggested_name).BaseName().value();
+  const FilePath suggested_path(suggested_name);
+  std::wstring file_part = suggested_path.BaseName().value();
   // If the suggested_name is a root directory, file_part will be '\', and the
   // call to GetSaveFileName below will fail.
   if (file_part.size() == 1 && file_part[0] == L'\\')
     file_part.clear();
 
   // The size of the in/out buffer in number of characters we pass to win32
   // GetSaveFileName.  From MSDN "The buffer must be large enough to store the
   // path and file name string or strings, including the terminating NULL
   // character.  ... The buffer should be at least 256 characters long.".
   // _IsValidPathComDlg does a copy expecting at most MAX_PATH, otherwise will
@@ skipping 16 matching lines @@
   save_as.nMaxCustFilter = 0;
   save_as.nFilterIndex = *index;
   save_as.lpstrFile = file_name;
   save_as.nMaxFile = arraysize(file_name);
   save_as.lpstrFileTitle = NULL;
   save_as.nMaxFileTitle = 0;
 
   // Set up the initial directory for the dialog.
   std::wstring directory;
   if (!suggested_name.empty())
-     directory = FilePath(suggested_name).DirName().value();
+     directory = suggested_path.DirName().value();
 
   save_as.lpstrInitialDir = directory.c_str();
   save_as.lpstrTitle = NULL;
   save_as.Flags = OFN_OVERWRITEPROMPT | OFN_EXPLORER | OFN_ENABLESIZING |
                   OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST;
   save_as.lpstrDefExt = &def_ext[0];
   save_as.lCustData = NULL;
 
   if (base::win::GetVersion() < base::win::VERSION_VISTA) {
     // The save as on Windows XP remembers its last position,
@@ skipping 30 matching lines @@
     base::SplitString(filter, '\0', &filters);
   std::wstring filter_selected;
   if (!filters.empty())
     filter_selected = filters[(2 * (save_as.nFilterIndex - 1)) + 1];
 
   // Get the extension that was suggested to the user (when the Save As dialog
   // was opened). For saving web pages, we skip this step since there may be
   // 'extension characters' in the title of the web page.
   std::wstring suggested_ext;
   if (!ignore_suggested_ext)
-    suggested_ext = file_util::GetFileExtensionFromPath(suggested_name);
+    suggested_ext = GetExtensionWithoutLeadingDot(suggested_path.Extension());
 
   // If we can't get the extension from the suggested_name, we use the default
   // extension passed in. This is to cover cases like when saving a web page,
   // where we get passed in a name without an extension and a default extension
   // along with it.
   if (suggested_ext.empty())
     suggested_ext = def_ext;
 
   *final_name =
       AppendExtensionIfNeeded(*final_name, filter_selected, suggested_ext);
@@ skipping 610 matching lines @@
       }
     }
   }
   return success;
 }
 
 // static
 SelectFileDialog* SelectFileDialog::Create(Listener* listener) {
   return new SelectFileDialogImpl(listener);
 }