Deleted OS_WIN and all Windows specific files from base.

base/files/file_path.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 "base/files/file_path.h"
 
 #include <string.h>
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/pickle.h"
 
 // These includes are just for the *Hack functions, and should be removed
 // when those functions are removed.
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_cftyperef.h"
 #include "base/third_party/icu/icu_utf.h"
 #endif
 
-#if defined(OS_WIN)
-#include <windows.h>
-#elif defined(OS_MACOSX)
+#if defined(OS_MACOSX)
 #include <CoreFoundation/CoreFoundation.h>
 #endif
 
 namespace base {
 
 typedef FilePath::StringType StringType;
 
 namespace {
 
 const char* const kCommonDoubleExtensionSuffixes[] = { "gz", "z", "bz2", "bz" };
@@ skipping 375 matching lines @@
   StringType ext = Extension();
   StringType ret = RemoveExtension().value();
   ret.append(suffix);
   ret.append(ext);
   return FilePath(ret);
 }
 
 FilePath FilePath::InsertBeforeExtensionASCII(const StringPiece& suffix)
     const {
   DCHECK(IsStringASCII(suffix));
-#if defined(OS_WIN)
-  return InsertBeforeExtension(ASCIIToUTF16(suffix.as_string()));
-#elif defined(OS_POSIX)
   return InsertBeforeExtension(suffix.as_string());
-#endif
 }
 
 FilePath FilePath::AddExtension(const StringType& extension) const {
   if (IsEmptyOrSpecialCase(BaseName().value()))
     return FilePath();
 
   // If the new extension is "" or ".", then just return the current FilePath.
   if (extension.empty() || extension == StringType(1, kExtensionSeparator))
     return *this;
 
@@ skipping 76 matching lines @@
   new_path.path_.append(*appended);
   return new_path;
 }
 
 FilePath FilePath::Append(const FilePath& component) const {
   return Append(component.value());
 }
 
 FilePath FilePath::AppendASCII(const StringPiece& component) const {
   DCHECK(base::IsStringASCII(component));
-#if defined(OS_WIN)
-  return Append(ASCIIToUTF16(component.as_string()));
-#elif defined(OS_POSIX)
   return Append(component.as_string());
-#endif
 }
 
 bool FilePath::IsAbsolute() const {
   return IsPathAbsolute(path_);
 }
 
 bool FilePath::EndsWithSeparator() const {
   if (empty())
     return false;
   return IsSeparator(path_[path_.size() - 1]);
@@ skipping 79 matching lines @@
 
 // static
 FilePath FilePath::FromUTF16Unsafe(const string16& utf16) {
 #if defined(SYSTEM_NATIVE_UTF8)
   return FilePath(UTF16ToUTF8(utf16));
 #else
   return FilePath(SysWideToNativeMB(UTF16ToWide(utf16)));
 #endif
 }
 
-#elif defined(OS_WIN)
-string16 FilePath::LossyDisplayName() const {
-  return path_;
-}
-
-std::string FilePath::MaybeAsASCII() const {
-  if (base::IsStringASCII(path_))
-    return UTF16ToASCII(path_);
-  return std::string();
-}
-
-std::string FilePath::AsUTF8Unsafe() const {
-  return WideToUTF8(value());
-}
-
-string16 FilePath::AsUTF16Unsafe() const {
-  return value();
-}
-
-// static
-FilePath FilePath::FromUTF8Unsafe(const std::string& utf8) {
-  return FilePath(UTF8ToWide(utf8));
-}
-
-// static
-FilePath FilePath::FromUTF16Unsafe(const string16& utf16) {
-  return FilePath(utf16);
-}
 #endif
 
 void FilePath::WriteToPickle(Pickle* pickle) const {
-#if defined(OS_WIN)
-  pickle->WriteString16(path_);
-#else
   pickle->WriteString(path_);
-#endif
 }
 
 bool FilePath::ReadFromPickle(PickleIterator* iter) {
-#if defined(OS_WIN)
-  if (!iter->ReadString16(&path_))
-    return false;
-#else
   if (!iter->ReadString(&path_))
     return false;
-#endif
 
   if (path_.find(kStringTerminator) != StringType::npos)
     return false;
 
   return true;
 }
 
-#if defined(OS_WIN)
-// Windows specific implementation of file string comparisons
-
-int FilePath::CompareIgnoreCase(const StringType& string1,
-                                const StringType& string2) {
-  // Perform character-wise upper case comparison rather than using the
-  // fully Unicode-aware CompareString(). For details see:
-  // http://blogs.msdn.com/michkap/archive/2005/10/17/481600.aspx
-  StringType::const_iterator i1 = string1.begin();
-  StringType::const_iterator i2 = string2.begin();
-  StringType::const_iterator string1end = string1.end();
-  StringType::const_iterator string2end = string2.end();
-  for ( ; i1 != string1end && i2 != string2end; ++i1, ++i2) {
-    wchar_t c1 =
-        (wchar_t)LOWORD(::CharUpperW((LPWSTR)(DWORD_PTR)MAKELONG(*i1, 0)));
-    wchar_t c2 =
-        (wchar_t)LOWORD(::CharUpperW((LPWSTR)(DWORD_PTR)MAKELONG(*i2, 0)));
-    if (c1 < c2)
-      return -1;
-    if (c1 > c2)
-      return 1;
-  }
-  if (i1 != string1end)
-    return 1;
-  if (i2 != string2end)
-    return -1;
-  return 0;
-}
-
-#elif defined(OS_MACOSX)
+#if defined(OS_MACOSX)
 // Mac OS X specific implementation of file string comparisons
 
 // cf. http://developer.apple.com/mac/library/technotes/tn/tn1150.html#UnicodeSubtleties
 //
 // "When using CreateTextEncoding to create a text encoding, you should set
 // the TextEncodingBase to kTextEncodingUnicodeV2_0, set the
 // TextEncodingVariant to kUnicodeCanonicalDecompVariant, and set the
 // TextEncodingFormat to kUnicode16BitFormat. Using these values ensures that
 // the Unicode will be in the same form as on an HFS Plus volume, even as the
 // Unicode standard evolves."
@@ skipping 589 matching lines @@
 #endif
 }
 
 #if defined(OS_ANDROID)
 bool FilePath::IsContentUri() const {
   return StartsWithASCII(path_, "content://", false /*case_sensitive*/);
 }
 #endif
 
 }  // namespace base