New new versions of Starts/EndsWith and SplitString in net

net/ftp/ftp_directory_listing_parser_vms.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 "net/ftp/ftp_directory_listing_parser_vms.h"
 
 #include <vector>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "net/ftp/ftp_directory_listing_parser.h"
 #include "net/ftp/ftp_util.h"
 
 namespace net {
 
 namespace {
 
 // Converts the filename component in listing to the filename we can display.
 // Returns true on success.
 bool ParseVmsFilename(const base::string16& raw_filename,
                       base::string16* parsed_filename,
                       FtpDirectoryListingEntry::Type* type) {
   // On VMS, the files and directories are versioned. The version number is
   // separated from the file name by a semicolon. Example: ANNOUNCE.TXT;2.
-  std::vector<base::string16> listing_parts;
-  base::SplitString(raw_filename, ';', &listing_parts);
+  std::vector<base::string16> listing_parts =
+      base::SplitString(raw_filename, base::ASCIIToUTF16(";"),
+                        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (listing_parts.size() != 2)
     return false;
   int version_number;
   if (!base::StringToInt(listing_parts[1], &version_number))
     return false;
   if (version_number < 0)
     return false;
 
   // Even directories have extensions in the listings. Don't display extensions
   // for directories; it's awkward for non-VMS users. Also, VMS is
   // case-insensitive, but generally uses uppercase characters. This may look
   // awkward, so we convert them to lower case.
-  std::vector<base::string16> filename_parts;
-  base::SplitString(listing_parts[0], '.', &filename_parts);
+  std::vector<base::string16> filename_parts =
+      base::SplitString(listing_parts[0], base::ASCIIToUTF16("."),
+                        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (filename_parts.size() != 2)
     return false;
   if (base::EqualsASCII(filename_parts[1], "DIR")) {
     *parsed_filename = base::StringToLowerASCII(filename_parts[0]);
     *type = FtpDirectoryListingEntry::DIRECTORY;
   } else {
     *parsed_filename = base::StringToLowerASCII(listing_parts[0]);
     *type = FtpDirectoryListingEntry::FILE;
   }
   return true;
@@ skipping 11 matching lines @@
   // best information we have.
   const int kBlockSize = 512;
 
   if (base::StringToInt64(input, size)) {
     if (*size < 0)
       return false;
     *size *= kBlockSize;
     return true;
   }
 
-  std::vector<base::string16> parts;
-  base::SplitString(input, '/', &parts);
+  std::vector<base::StringPiece16> parts =
+      base::SplitStringPiece(input, base::ASCIIToUTF16("/"),
+                             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (parts.size() != 2)
     return false;
 
   int64 blocks_used, blocks_allocated;
   if (!base::StringToInt64(parts[0], &blocks_used))
     return false;
   if (!base::StringToInt64(parts[1], &blocks_allocated))
     return false;
   if (blocks_used > blocks_allocated)
     return false;
@@ skipping 21 matching lines @@
 }
 
 bool LooksLikeVmsFileProtectionListing(const base::string16& input) {
   if (input.length() < 2)
     return false;
   if (input[0] != '(' || input[input.length() - 1] != ')')
     return false;
 
   // We expect four parts of the file protection listing: for System, Owner,
   // Group, and World.
-  std::vector<base::string16> parts;
-  base::SplitString(input.substr(1, input.length() - 2), ',', &parts);
+  std::vector<base::string16> parts = base::SplitString(
+      base::StringPiece16(input).substr(1, input.length() - 2),
+      base::ASCIIToUTF16(","), base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (parts.size() != 4)
     return false;
 
   return LooksLikeVmsFileProtectionListingPart(parts[0]) &&
       LooksLikeVmsFileProtectionListingPart(parts[1]) &&
       LooksLikeVmsFileProtectionListingPart(parts[2]) &&
       LooksLikeVmsFileProtectionListingPart(parts[3]);
 }
 
 bool LooksLikeVmsUserIdentificationCode(const base::string16& input) {
@@ skipping 19 matching lines @@
   return false;
 }
 
 bool VmsDateListingToTime(const std::vector<base::string16>& columns,
                           base::Time* time) {
   DCHECK_EQ(4U, columns.size());
 
   base::Time::Exploded time_exploded = { 0 };
 
   // Date should be in format DD-MMM-YYYY.
-  std::vector<base::string16> date_parts;
-  base::SplitString(columns[2], '-', &date_parts);
+  std::vector<base::StringPiece16> date_parts =
+      base::SplitStringPiece(columns[2], base::ASCIIToUTF16("-"),
+                             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (date_parts.size() != 3)
     return false;
   if (!base::StringToInt(date_parts[0], &time_exploded.day_of_month))
     return false;
-  if (!FtpUtil::AbbreviatedMonthToNumber(date_parts[1],
+  if (!FtpUtil::AbbreviatedMonthToNumber(date_parts[1].as_string(),
                                          &time_exploded.month))
     return false;
   if (!base::StringToInt(date_parts[2], &time_exploded.year))
     return false;
 
   // Time can be in format HH:MM, HH:MM:SS, or HH:MM:SS.mm. Try to recognize the
   // last type first. Do not parse the seconds, they will be ignored anyway.
   base::string16 time_column(columns[3]);
   if (time_column.length() == 11 && time_column[8] == '.')
     time_column = time_column.substr(0, 8);
   if (time_column.length() == 8 && time_column[5] == ':')
     time_column = time_column.substr(0, 5);
   if (time_column.length() != 5)
     return false;
-  std::vector<base::string16> time_parts;
-  base::SplitString(time_column, ':', &time_parts);
+  std::vector<base::StringPiece16> time_parts =
+      base::SplitStringPiece(time_column, base::ASCIIToUTF16(":"),
+                             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (time_parts.size() != 2)
     return false;
   if (!base::StringToInt(time_parts[0], &time_exploded.hour))
     return false;
   if (!base::StringToInt(time_parts[1], &time_exploded.minute))
     return false;
 
   // We don't know the time zone of the server, so just use local time.
   *time = base::Time::FromLocalExploded(time_exploded);
   return true;
@@ skipping 94 matching lines @@
     entries->push_back(entry);
   }
 
   // The only place where we return true is after receiving the "Total" line,
   // that should be present in every VMS listing. Alternatively, if the listing
   // contains error messages, it's OK not to have the "Total" line.
   return seen_error;
 }
 
 }  // namespace net