Remove uses of base::hash_map from //chrome

chrome/browser/extensions/api/downloads/downloads_api.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 "chrome/browser/extensions/api/downloads/downloads_api.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
+#include "base/containers/flat_map.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 327 matching lines @@
 IconLoader::IconSize IconLoaderSizeFromPixelSize(int pixel_size) {
   switch (pixel_size) {
     case 16: return IconLoader::SMALL;
     case 32: return IconLoader::NORMAL;
     default:
       NOTREACHED();
       return IconLoader::NORMAL;
   }
 }
 
-typedef base::hash_map<std::string, DownloadQuery::FilterType> FilterTypeMap;
+using FilterTypeMap = base::flat_map<std::string, DownloadQuery::FilterType>;
+void AppendFilter(const char* name,
+                  DownloadQuery::FilterType type,
+                  std::vector<FilterTypeMap::value_type>* v) {
+  v->emplace_back(name, type);
+}
 
 void InitFilterTypeMap(FilterTypeMap* filter_types_ptr) {
-  FilterTypeMap& filter_types = *filter_types_ptr;
-  filter_types[kBytesReceivedKey] = DownloadQuery::FILTER_BYTES_RECEIVED;
-  filter_types[kExistsKey] = DownloadQuery::FILTER_EXISTS;
-  filter_types[kFilenameKey] = DownloadQuery::FILTER_FILENAME;
-  filter_types[kFilenameRegexKey] = DownloadQuery::FILTER_FILENAME_REGEX;
-  filter_types[kMimeKey] = DownloadQuery::FILTER_MIME;
-  filter_types[kPausedKey] = DownloadQuery::FILTER_PAUSED;
-  filter_types[kQueryKey] = DownloadQuery::FILTER_QUERY;
-  filter_types[kEndedAfterKey] = DownloadQuery::FILTER_ENDED_AFTER;
-  filter_types[kEndedBeforeKey] = DownloadQuery::FILTER_ENDED_BEFORE;
-  filter_types[kEndTimeKey] = DownloadQuery::FILTER_END_TIME;
-  filter_types[kStartedAfterKey] = DownloadQuery::FILTER_STARTED_AFTER;
-  filter_types[kStartedBeforeKey] = DownloadQuery::FILTER_STARTED_BEFORE;
-  filter_types[kStartTimeKey] = DownloadQuery::FILTER_START_TIME;
-  filter_types[kTotalBytesKey] = DownloadQuery::FILTER_TOTAL_BYTES;
-  filter_types[kTotalBytesGreaterKey] =
-    DownloadQuery::FILTER_TOTAL_BYTES_GREATER;
-  filter_types[kTotalBytesLessKey] = DownloadQuery::FILTER_TOTAL_BYTES_LESS;
-  filter_types[kUrlKey] = DownloadQuery::FILTER_ORIGINAL_URL;
-  filter_types[kUrlRegexKey] = DownloadQuery::FILTER_ORIGINAL_URL_REGEX;
-  filter_types[kFinalUrlKey] = DownloadQuery::FILTER_URL;
-  filter_types[kFinalUrlRegexKey] = DownloadQuery::FILTER_URL_REGEX;
+  // Initialize the map in one shot by storing to a vector and assigning.
+  std::vector<FilterTypeMap::value_type> v;
+
+  AppendFilter(kBytesReceivedKey, DownloadQuery::FILTER_BYTES_RECEIVED, &v);
+
+  AppendFilter(kBytesReceivedKey, DownloadQuery::FILTER_BYTES_RECEIVED, &v);
+  AppendFilter(kExistsKey, DownloadQuery::FILTER_EXISTS, &v);
+  AppendFilter(kFilenameKey, DownloadQuery::FILTER_FILENAME, &v);
+  AppendFilter(kFilenameRegexKey, DownloadQuery::FILTER_FILENAME_REGEX, &v);
+  AppendFilter(kMimeKey, DownloadQuery::FILTER_MIME, &v);
+  AppendFilter(kPausedKey, DownloadQuery::FILTER_PAUSED, &v);
+  AppendFilter(kQueryKey, DownloadQuery::FILTER_QUERY, &v);
+  AppendFilter(kEndedAfterKey, DownloadQuery::FILTER_ENDED_AFTER, &v);
+  AppendFilter(kEndedBeforeKey, DownloadQuery::FILTER_ENDED_BEFORE, &v);
+  AppendFilter(kEndTimeKey, DownloadQuery::FILTER_END_TIME, &v);
+  AppendFilter(kStartedAfterKey, DownloadQuery::FILTER_STARTED_AFTER, &v);
+  AppendFilter(kStartedBeforeKey, DownloadQuery::FILTER_STARTED_BEFORE, &v);
+  AppendFilter(kStartTimeKey, DownloadQuery::FILTER_START_TIME, &v);
+  AppendFilter(kTotalBytesKey, DownloadQuery::FILTER_TOTAL_BYTES, &v);
+  AppendFilter(kTotalBytesGreaterKey, DownloadQuery::FILTER_TOTAL_BYTES_GREATER,
+               &v);
+  AppendFilter(kTotalBytesLessKey, DownloadQuery::FILTER_TOTAL_BYTES_LESS, &v);
+  AppendFilter(kUrlKey, DownloadQuery::FILTER_ORIGINAL_URL, &v);
+  AppendFilter(kUrlRegexKey, DownloadQuery::FILTER_ORIGINAL_URL_REGEX, &v);
+  AppendFilter(kFinalUrlKey, DownloadQuery::FILTER_URL, &v);
+  AppendFilter(kFinalUrlRegexKey, DownloadQuery::FILTER_URL_REGEX, &v);
+
+  *filter_types_ptr = FilterTypeMap(std::move(v), base::KEEP_FIRST_OF_DUPES);
 }
 
-typedef base::hash_map<std::string, DownloadQuery::SortType> SortTypeMap;
+using SortTypeMap = base::flat_map<std::string, DownloadQuery::SortType>;
+void AppendFilter(const char* name,
+                  DownloadQuery::SortType type,
+                  std::vector<SortTypeMap::value_type>* v) {
+  v->emplace_back(name, type);
+}
 
 void InitSortTypeMap(SortTypeMap* sorter_types_ptr) {
-  SortTypeMap& sorter_types = *sorter_types_ptr;
-  sorter_types[kBytesReceivedKey] = DownloadQuery::SORT_BYTES_RECEIVED;
-  sorter_types[kDangerKey] = DownloadQuery::SORT_DANGER;
-  sorter_types[kEndTimeKey] = DownloadQuery::SORT_END_TIME;
-  sorter_types[kExistsKey] = DownloadQuery::SORT_EXISTS;
-  sorter_types[kFilenameKey] = DownloadQuery::SORT_FILENAME;
-  sorter_types[kMimeKey] = DownloadQuery::SORT_MIME;
-  sorter_types[kPausedKey] = DownloadQuery::SORT_PAUSED;
-  sorter_types[kStartTimeKey] = DownloadQuery::SORT_START_TIME;
-  sorter_types[kStateKey] = DownloadQuery::SORT_STATE;
-  sorter_types[kTotalBytesKey] = DownloadQuery::SORT_TOTAL_BYTES;
-  sorter_types[kUrlKey] = DownloadQuery::SORT_ORIGINAL_URL;
-  sorter_types[kFinalUrlKey] = DownloadQuery::SORT_URL;
+  // Initialize the map in one shot by storing to a vector and assigning.
+  std::vector<SortTypeMap::value_type> v;
+
+  AppendFilter(kBytesReceivedKey, DownloadQuery::SORT_BYTES_RECEIVED, &v);

[chrisha, 2017/05/23 20:07:59]

AppendSortQuery? AppendSortType?

+  AppendFilter(kDangerKey, DownloadQuery::SORT_DANGER, &v);
+  AppendFilter(kEndTimeKey, DownloadQuery::SORT_END_TIME, &v);
+  AppendFilter(kExistsKey, DownloadQuery::SORT_EXISTS, &v);
+  AppendFilter(kFilenameKey, DownloadQuery::SORT_FILENAME, &v);
+  AppendFilter(kMimeKey, DownloadQuery::SORT_MIME, &v);
+  AppendFilter(kPausedKey, DownloadQuery::SORT_PAUSED, &v);
+  AppendFilter(kStartTimeKey, DownloadQuery::SORT_START_TIME, &v);
+  AppendFilter(kStateKey, DownloadQuery::SORT_STATE, &v);
+  AppendFilter(kTotalBytesKey, DownloadQuery::SORT_TOTAL_BYTES, &v);
+  AppendFilter(kUrlKey, DownloadQuery::SORT_ORIGINAL_URL, &v);
+  AppendFilter(kFinalUrlKey, DownloadQuery::SORT_URL, &v);
+
+  *sorter_types_ptr = SortTypeMap(std::move(v), base::KEEP_FIRST_OF_DUPES);
 }

[chrisha, 2017/05/23 20:07:59]

At a higher level: Should both of the short lists simply be stored statically,
and directly std::binary_search'd or even linear-searched through? We're already
paying the storage cost in the image via the generated code, and then we're
paying it a second time here on the heap. We're also recalculating these maps
with every call to RunDownloadQuery.

[brettw, 2017/06/28 23:58:39]

I did the downloads one in a separate CL:
https://codereview.chromium.org/2956213003/

 
 bool IsNotTemporaryDownloadFilter(const DownloadItem& download_item) {
   return !download_item.IsTemporary();
 }
 
 // Set |manager| to the on-record DownloadManager, and |incognito_manager| to
 // the off-record DownloadManager if one exists and is requested via
 // |include_incognito|. This should work regardless of whether |profile| is
 // original or incognito.
 void GetManagers(content::BrowserContext* context,
@@ skipping 1508 matching lines @@
     return;
   base::Time now(base::Time::Now());
   int delta = now.ToTimeT() - last_checked_removal_.ToTimeT();
   if (delta <= kFileExistenceRateLimitSeconds)
     return;
   last_checked_removal_ = now;
   manager->CheckForHistoryFilesRemoval();
 }
 
 }  // namespace extensions