Statically allocate extension download lookups.

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 <algorithm>
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 132 matching lines @@
 const char kDangerUrl[] = "url";
 const char kEndTimeKey[] = "endTime";
 const char kEndedAfterKey[] = "endedAfter";
 const char kEndedBeforeKey[] = "endedBefore";
 const char kErrorKey[] = "error";
 const char kEstimatedEndTimeKey[] = "estimatedEndTime";
 const char kExistsKey[] = "exists";
 const char kFileSizeKey[] = "fileSize";
 const char kFilenameKey[] = "filename";
 const char kFilenameRegexKey[] = "filenameRegex";
+const char kFinalUrlKey[] = "finalUrl";
+const char kFinalUrlRegexKey[] = "finalUrlRegex";
 const char kIdKey[] = "id";
 const char kIncognitoKey[] = "incognito";
 const char kMimeKey[] = "mime";
 const char kPausedKey[] = "paused";
 const char kQueryKey[] = "query";
 const char kReferrerUrlKey[] = "referrer";
 const char kStartTimeKey[] = "startTime";
 const char kStartedAfterKey[] = "startedAfter";
 const char kStartedBeforeKey[] = "startedBefore";
 const char kStateComplete[] = "complete";
 const char kStateInProgress[] = "in_progress";
 const char kStateInterrupted[] = "interrupted";
 const char kStateKey[] = "state";
 const char kTotalBytesGreaterKey[] = "totalBytesGreater";
 const char kTotalBytesKey[] = "totalBytes";
 const char kTotalBytesLessKey[] = "totalBytesLess";
 const char kUrlKey[] = "url";
 const char kUrlRegexKey[] = "urlRegex";
-const char kFinalUrlKey[] = "finalUrl";
-const char kFinalUrlRegexKey[] = "finalUrlRegex";
+
+// This list must be in order as determined by strcmp. The test
+// DownloadsApiInternalUnitTest.FilterTypeSorted will verify this.
+constexpr DownloadQueryFilterTypePair kFilterTypes[] = {
+    {kBytesReceivedKey, DownloadQuery::FILTER_BYTES_RECEIVED},
+    {kEndTimeKey, DownloadQuery::FILTER_END_TIME},
+    {kEndedAfterKey, DownloadQuery::FILTER_ENDED_AFTER},
+    {kEndedBeforeKey, DownloadQuery::FILTER_ENDED_BEFORE},
+    {kExistsKey, DownloadQuery::FILTER_EXISTS},
+    {kFilenameKey, DownloadQuery::FILTER_FILENAME},
+    {kFilenameRegexKey, DownloadQuery::FILTER_FILENAME_REGEX},
+    {kFinalUrlKey, DownloadQuery::FILTER_URL},
+    {kFinalUrlRegexKey, DownloadQuery::FILTER_URL_REGEX},
+    {kMimeKey, DownloadQuery::FILTER_MIME},
+    {kPausedKey, DownloadQuery::FILTER_PAUSED},
+    {kQueryKey, DownloadQuery::FILTER_QUERY},
+    {kStartTimeKey, DownloadQuery::FILTER_START_TIME},
+    {kStartedAfterKey, DownloadQuery::FILTER_STARTED_AFTER},
+    {kStartedBeforeKey, DownloadQuery::FILTER_STARTED_BEFORE},
+    {kTotalBytesKey, DownloadQuery::FILTER_TOTAL_BYTES},
+    {kTotalBytesGreaterKey, DownloadQuery::FILTER_TOTAL_BYTES_GREATER},
+    {kTotalBytesLessKey, DownloadQuery::FILTER_TOTAL_BYTES_LESS},
+    {kUrlKey, DownloadQuery::FILTER_ORIGINAL_URL},
+    {kUrlRegexKey, DownloadQuery::FILTER_ORIGINAL_URL_REGEX},
+};
+
+// This list must be in order as determined by strcmp. The test
+// DownloadsApiInternalUnitTest.SortTypeSorted will verify this.
+constexpr DownloadQuerySortTypePair kSortTypes[] = {
+    {kBytesReceivedKey, DownloadQuery::SORT_BYTES_RECEIVED},
+    {kDangerKey, DownloadQuery::SORT_DANGER},
+    {kEndTimeKey, DownloadQuery::SORT_END_TIME},
+    {kExistsKey, DownloadQuery::SORT_EXISTS},
+    {kFilenameKey, DownloadQuery::SORT_FILENAME},
+    {kFinalUrlKey, DownloadQuery::SORT_URL},
+    {kMimeKey, DownloadQuery::SORT_MIME},
+    {kPausedKey, DownloadQuery::SORT_PAUSED},
+    {kStartTimeKey, DownloadQuery::SORT_START_TIME},
+    {kStateKey, DownloadQuery::SORT_STATE},
+    {kTotalBytesKey, DownloadQuery::SORT_TOTAL_BYTES},
+    {kUrlKey, DownloadQuery::SORT_ORIGINAL_URL},
+};
 
 // Note: Any change to the danger type strings, should be accompanied by a
 // corresponding change to downloads.json.
 const char* const kDangerStrings[] = {
   kDangerSafe,
   kDangerFile,
   kDangerUrl,
   kDangerContent,
   kDangerSafe,
   kDangerUncommon,
@@ skipping 164 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;
-
-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;
-}
-
-typedef base::hash_map<std::string, DownloadQuery::SortType> SortTypeMap;
-
-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;
-}
-
 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,
                  bool include_incognito,
@@ skipping 49 matching lines @@
 void RecordApiFunctions(DownloadsFunctionName function) {
   UMA_HISTOGRAM_ENUMERATION("Download.ApiFunctions",
                             function,
                             DOWNLOADS_FUNCTION_LAST);
 }
 
 void CompileDownloadQueryOrderBy(
     const std::vector<std::string>& order_by_strs,
     std::string* error,
     DownloadQuery* query) {
-  // TODO(benjhayden): Consider switching from LazyInstance to explicit string
-  // comparisons.
-  static base::LazyInstance<SortTypeMap>::DestructorAtExit sorter_types =
-      LAZY_INSTANCE_INITIALIZER;
-  if (sorter_types.Get().empty())
-    InitSortTypeMap(sorter_types.Pointer());
-
   for (std::vector<std::string>::const_iterator iter = order_by_strs.begin();
        iter != order_by_strs.end(); ++iter) {
     std::string term_str = *iter;
     if (term_str.empty())
       continue;
     DownloadQuery::SortDirection direction = DownloadQuery::ASCENDING;
     if (term_str[0] == '-') {
       direction = DownloadQuery::DESCENDING;
       term_str = term_str.substr(1);
     }
-    SortTypeMap::const_iterator sorter_type =
-        sorter_types.Get().find(term_str);
-    if (sorter_type == sorter_types.Get().end()) {
+    const DownloadQuerySortTypePair* found_sort =
+        FindDownloadSortTypeByString(term_str.c_str());
+    if (!found_sort) {
       *error = errors::kInvalidOrderBy;
       return;
     }
-    query->AddSorter(sorter_type->second, direction);
+    query->AddSorter(found_sort->second, direction);
   }
 }
 
 void RunDownloadQuery(
     const downloads::DownloadQuery& query_in,
     DownloadManager* manager,
     DownloadManager* incognito_manager,
     std::string* error,
     DownloadQuery::DownloadVector* results) {
-  // TODO(benjhayden): Consider switching from LazyInstance to explicit string
-  // comparisons.
-  static base::LazyInstance<FilterTypeMap>::DestructorAtExit filter_types =
-      LAZY_INSTANCE_INITIALIZER;
-  if (filter_types.Get().empty())
-    InitFilterTypeMap(filter_types.Pointer());
-
   DownloadQuery query_out;
 
   size_t limit = 1000;
   if (query_in.limit.get()) {
     if (*query_in.limit < 0) {
       *error = errors::kInvalidQueryLimit;
       return;
     }
     limit = *query_in.limit;
   }
@@ skipping 23 matching lines @@
   }
   if (query_in.order_by.get()) {
     CompileDownloadQueryOrderBy(*query_in.order_by, error, &query_out);
     if (!error->empty())
       return;
   }
 
   std::unique_ptr<base::DictionaryValue> query_in_value(query_in.ToValue());
   for (base::DictionaryValue::Iterator query_json_field(*query_in_value);
        !query_json_field.IsAtEnd(); query_json_field.Advance()) {
-    FilterTypeMap::const_iterator filter_type =
-        filter_types.Get().find(query_json_field.key());
-    if (filter_type != filter_types.Get().end()) {
-      if (!query_out.AddFilter(filter_type->second, query_json_field.value())) {
+    const DownloadQueryFilterTypePair* found_filter =
+        FindDownloadFilterTypeByString(query_json_field.key().c_str());
+    if (found_filter) {
+      if (!query_out.AddFilter(found_filter->second,
+                               query_json_field.value())) {
         *error = errors::kInvalidFilter;
         return;
       }
     }
   }
 
   DownloadQuery::DownloadVector all_items;
   if (query_in.id.get()) {
     DownloadItem* download_item = manager->GetDownload(*query_in.id);
     if (!download_item && incognito_manager)
@@ skipping 1384 matching lines @@
   if (!manager)
     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();
 }
 
+const DownloadQueryFilterTypePair* FindDownloadFilterTypeByString(
+    const char* key) {
+  struct FilterTypeKeyLess {
+    bool operator()(const DownloadQueryFilterTypePair& a, const char* b) const {
+      return strcmp(a.first, b) < 0;
+    }
+  };
+
+  const DownloadQueryFilterTypePair* found =
+      std::lower_bound(std::begin(kFilterTypes), std::end(kFilterTypes), key,
+                       FilterTypeKeyLess());
+  if (found == std::end(kFilterTypes) || strcmp(key, found->first) != 0)
+    return nullptr;
+  return found;
+}
+
+const DownloadQuerySortTypePair* FindDownloadSortTypeByString(const char* key) {
+  struct SortTypeKeyLess {
+    bool operator()(const DownloadQuerySortTypePair& a, const char* b) const {
+      return strcmp(a.first, b) < 0;
+    }
+  };
+
+  const DownloadQuerySortTypePair* found = std::lower_bound(
+      std::begin(kSortTypes), std::end(kSortTypes), key, SortTypeKeyLess());
+  if (found == std::end(kSortTypes) || strcmp(key, found->first) != 0)
+    return nullptr;
+  return found;
+}
+
+const DownloadQueryFilterTypePair* DownloadQueryFilterTypeBeginForTest() {
+  return std::begin(kFilterTypes);
+}
+
+const DownloadQueryFilterTypePair* DownloadQueryFilterTypeEndForTest() {
+  return std::end(kFilterTypes);
+}
+
+const DownloadQuerySortTypePair* DownloadQuerySortTypeBeginForTest() {
+  return std::begin(kSortTypes);
+}
+
+const DownloadQuerySortTypePair* DownloadQuerySortTypeEndForTest() {
+  return std::end(kSortTypes);
+}
+
 }  // namespace extensions