Convert //net and //chromecast to std::unordered_*

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 <unordered_set>
 
 #include "base/base64.h"
-#include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #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 "build/build_config.h"
 #include "net/base/mime_util.h"
@@ skipping 434 matching lines @@
   { "image/", kStandardImageTypes, arraysize(kStandardImageTypes) },
   { "audio/", kStandardAudioTypes, arraysize(kStandardAudioTypes) },
   { "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) {
+    std::unordered_set<base::FilePath::StringType>* extensions) {
   for (size_t i = 0; i < mappings_len; ++i) {
     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)
         extensions->insert(base::UTF8ToUTF16(this_extension));
 #else
         extensions->insert(this_extension.as_string());
 #endif
       }
     }
   }
 }
 
 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) {
+    std::unordered_set<base::FilePath::StringType>* extensions) {
   for (size_t i = 0; i < standard_types_len; ++i) {
     g_mime_util.Get().GetPlatformExtensionsForMimeType(standard_types[i],
                                                        extensions);
   }
 
   // Also look up the extensions from hard-coded mappings in case that some
   // supported extensions are not registered in the system registry, like ogg.
   GetExtensionsFromHardCodedMappings(kPrimaryMappings,
                                      arraysize(kPrimaryMappings),
                                      leading_mime_type, extensions);
 
   GetExtensionsFromHardCodedMappings(kSecondaryMappings,
                                      arraysize(kSecondaryMappings),
                                      leading_mime_type, extensions);
 }
 
 // Note that the elements in the source set will be appended to the target
 // vector.
-template<class T>
-void HashSetToVector(base::hash_set<T>* source, std::vector<T>* target) {
+template <class T>
+void UnorderedSetToVector(std::unordered_set<T>* source,
+                          std::vector<T>* target) {
   size_t old_target_size = target->size();
   target->resize(old_target_size + source->size());
   size_t i = 0;
-  for (typename base::hash_set<T>::iterator iter = source->begin();
+  for (typename std::unordered_set<T>::iterator iter = source->begin();
        iter != source->end(); ++iter, ++i)
     (*target)[old_target_size + i] = *iter;
 }
 
 // Characters to be used for mime multipart boundary.
 //
 // TODO(rsleevi): crbug.com/575779: Follow the spec or fix the spec.
 // The RFC 2046 spec says the alphanumeric characters plus the
 // following characters are legal for boundaries:  '()+_,-./:=?
 // However the following characters, though legal, cause some sites
 // to fail: (),./:=+
 const char kMimeBoundaryCharacters[] =
     "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
 // Size of mime multipart boundary.
 const size_t kMimeBoundarySize = 69;
 
 }  // namespace
 
 void GetExtensionsForMimeType(
     const std::string& unsafe_mime_type,
     std::vector<base::FilePath::StringType>* extensions) {
   if (unsafe_mime_type == "*/*" || unsafe_mime_type == "*")
     return;
 
   const std::string mime_type = base::ToLowerASCII(unsafe_mime_type);
-  base::hash_set<base::FilePath::StringType> unique_extensions;
+  std::unordered_set<base::FilePath::StringType> unique_extensions;
 
   if (base::EndsWith(mime_type, "/*", base::CompareCase::INSENSITIVE_ASCII)) {
     std::string leading_mime_type = mime_type.substr(0, mime_type.length() - 1);
 
     // Find the matching StandardType from within kStandardTypes, or fall
     // through to the last (default) StandardType.
     const StandardType* type = NULL;
     for (size_t i = 0; i < arraysize(kStandardTypes); ++i) {
       type = &(kStandardTypes[i]);
       if (type->leading_mime_type &&
@@ skipping 13 matching lines @@
     // supported extensions are not registered in the system registry, like ogg.
     GetExtensionsFromHardCodedMappings(kPrimaryMappings,
                                        arraysize(kPrimaryMappings), mime_type,
                                        &unique_extensions);
 
     GetExtensionsFromHardCodedMappings(kSecondaryMappings,
                                        arraysize(kSecondaryMappings), mime_type,
                                        &unique_extensions);
   }
 
-  HashSetToVector(&unique_extensions, extensions);
+  UnorderedSetToVector(&unique_extensions, extensions);
 }
 
 NET_EXPORT std::string GenerateMimeMultipartBoundary() {
   // Based on RFC 1341, section "7.2.1 Multipart: The common syntax":
   //   Because encapsulation boundaries must not appear in the body parts being
   //   encapsulated, a user agent must exercise care to choose a unique
   //   boundary. The boundary in the example above could have been the result of
   //   an algorithm designed to produce boundaries with a very low probability
   //   of already existing in the data to be encapsulated without having to
   //   prescan the data.
@@ skipping 44 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