New new versions of Starts/EndsWith and SplitString in net

net/base/mime_util.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 <algorithm>
 #include <iterator>
 #include <map>
 #include <string>
 
 #include "base/containers/hash_tables.h"
@@ skipping 262 matching lines @@
       return MatchesMimeTypeParameters(mime_type_pattern, mime_type);
     } else {
       return false;
     }
   }
 
   // Test length to prevent overlap between |left| and |right|.
   if (base_type.length() < base_pattern.length() - 1)
     return false;
 
-  const std::string left(base_pattern.substr(0, star));
-  const std::string right(base_pattern.substr(star + 1));
+  base::StringPiece base_pattern_piece(base_pattern);
+  base::StringPiece left(base_pattern_piece.substr(0, star));
+  base::StringPiece right(base_pattern_piece.substr(star + 1));
 
-  if (!base::StartsWithASCII(base_type, left, false))
+  if (!base::StartsWith(base_type, left, base::CompareCase::INSENSITIVE_ASCII))
     return false;
 
-  if (!right.empty() && !base::EndsWith(base_type, right, false))
+  if (!right.empty() &&
+      !base::EndsWith(base_type, right, base::CompareCase::INSENSITIVE_ASCII))
     return false;
 
   return MatchesMimeTypeParameters(mime_type_pattern, mime_type);
 }
 
 // See http://www.iana.org/assignments/media-types/media-types.xhtml
 static const char* const legal_top_level_types[] = {
   "application",
   "audio",
   "example",
   "image",
   "message",
   "model",
   "multipart",
   "text",
   "video",
 };
 
 bool MimeUtil::ParseMimeTypeWithoutParameter(
     const std::string& type_string,
     std::string* top_level_type,
     std::string* subtype) const {
-  std::vector<std::string> components;
-  base::SplitString(type_string, '/', &components);
+  std::vector<std::string> components = base::SplitString(
+      type_string, "/", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (components.size() != 2 ||
       !HttpUtil::IsToken(components[0]) ||
       !HttpUtil::IsToken(components[1]))
     return false;
 
   if (top_level_type)
     *top_level_type = components[0];
   if (subtype)
     *subtype = components[1];
   return true;
 }
 
 bool MimeUtil::IsValidTopLevelMimeType(const std::string& type_string) const {
   std::string lower_type = base::StringToLowerASCII(type_string);
   for (size_t i = 0; i < arraysize(legal_top_level_types); ++i) {
     if (lower_type.compare(legal_top_level_types[i]) == 0)
       return true;
   }
 
   return type_string.size() > 2 &&
-         base::StartsWithASCII(type_string, "x-", false);
+         base::StartsWith(type_string, "x-",
+                          base::CompareCase::INSENSITIVE_ASCII);
 }
 
 //----------------------------------------------------------------------------
 // Wrappers for the singleton
 //----------------------------------------------------------------------------
 
 bool GetMimeTypeFromExtension(const base::FilePath::StringType& ext,
                               std::string* mime_type) {
   return g_mime_util.Get().GetMimeTypeFromExtension(ext, mime_type);
 }
@@ skipping 106 matching lines @@
   { "video/", kStandardVideoTypes, arraysize(kStandardVideoTypes) },
   { NULL, NULL, 0 }
 };
 
 void GetExtensionsFromHardCodedMappings(
     const MimeInfo* mappings,
     size_t mappings_len,
     const std::string& leading_mime_type,
     base::hash_set<base::FilePath::StringType>* extensions) {
   for (size_t i = 0; i < mappings_len; ++i) {
-    if (base::StartsWithASCII(mappings[i].mime_type, leading_mime_type,
-                              false)) {
-      std::vector<string> this_extensions;
-      base::SplitString(mappings[i].extensions, ',', &this_extensions);
-      for (size_t j = 0; j < this_extensions.size(); ++j) {
+    if (base::StartsWith(mappings[i].mime_type, leading_mime_type,
+                         base::CompareCase::INSENSITIVE_ASCII)) {
+      for (const base::StringPiece& this_extension : base::SplitStringPiece(
+               mappings[i].extensions, ",", base::TRIM_WHITESPACE,
+               base::SPLIT_WANT_ALL)) {
 #if defined(OS_WIN)
-        base::FilePath::StringType extension(
-            base::UTF8ToWide(this_extensions[j]));
+        extensions->insert(base::UTF8ToWide(this_extension));
 #else
-        base::FilePath::StringType extension(this_extensions[j]);
+        extensions->insert(this_extension.as_string());
 #endif

[Ryan Sleevi, 2015/07/06 08:52:01]

OBSERVATION: Functionally, this behaviour if equivalent, but it's at least worth
calling out here that the previous code had the effect of calling an explicit
ctor for FilePath::StringType for these, and here, you're calling an implicit
ctor and hoping it works out.

[brettw, 2015/07/06 16:52:34]

I'm not calling any implicit constructors, I'm supplying the exact type required
for the given platform. Granted, this does make assumptions about what type
FilePath::StringType is on Windows-vs-non-Windows but I don't have a problem
with that.

I am changing UTF8ToWide to UTF8ToUTF16. I want to delete all wstrings.

-        extensions->insert(extension);
       }
     }
   }
 }
 
 void GetExtensionsHelper(
     const char* const* standard_types,
     size_t standard_types_len,
     const std::string& leading_mime_type,
     base::hash_set<base::FilePath::StringType>* extensions) {
@@ skipping 94 matching lines @@
   post_data->append("\r\n" + value + "\r\n");
 }
 
 void AddMultipartFinalDelimiterForUpload(const std::string& mime_boundary,
                                          std::string* post_data) {
   DCHECK(post_data);
   post_data->append("--" + mime_boundary + "--\r\n");
 }
 
 }  // namespace net