Use base::flat_set<> rather than std::set<> for ResourceType set

components/safe_browsing_db/remote_database_manager.cc

 // Copyright 2015 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 "components/safe_browsing_db/remote_database_manager.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/metrics/histogram_macros.h"
@@ skipping 81 matching lines @@
   // CancelCheck() will delete *this.
   db_manager_->CancelCheck(client_);
 }
 
 //
 // RemoteSafeBrowsingDatabaseManager methods
 //
 
 // TODO(nparker): Add more tests for this class
 RemoteSafeBrowsingDatabaseManager::RemoteSafeBrowsingDatabaseManager() {
+  // Adding one element at a time to a base::flat_set is inefficient. Creating
+  // the list of elements in a vector first avoids extra allocations.
+  std::vector<content::ResourceType> types_to_check;

[Nathan Parker, 2017/04/25 15:23:14]

This seems seems like overkill for 18 elements that are added once at startup. 
Could we simplify the code by adding it directly to the set?  Or sizing the set
a head of time?

[Adam Rice, 2017/04/26 05:18:27]

I've tried adding directly to the set in patch set 2. I don't like adding
overhead during startup, but the simplification is compelling.

By my back-of-the-envelope calculation it roughly doubles the number of
operations needed for a full set with all 18 items. It's still an order of
magnitude cheaper to initialise that the old std::set.

   // Decide which resource types to check. These two are the minimum.
-  resource_types_to_check_.insert(content::RESOURCE_TYPE_MAIN_FRAME);
-  resource_types_to_check_.insert(content::RESOURCE_TYPE_SUB_FRAME);
+  types_to_check.push_back(content::RESOURCE_TYPE_MAIN_FRAME);
+  types_to_check.push_back(content::RESOURCE_TYPE_SUB_FRAME);
 
   // The param is expected to be a comma-separated list of ints
   // corresponding to the enum types.  We're keeping this finch
   // control around so we can add back types if they later become dangerous.
   const std::string ints_str = variations::GetVariationParamValue(
       kAndroidFieldExperiment, kAndroidTypesToCheckParam);
   if (ints_str.empty()) {
     // By default, we check all types except a few.
     static_assert(content::RESOURCE_TYPE_LAST_TYPE ==
                       content::RESOURCE_TYPE_PLUGIN_RESOURCE + 1,
                   "Decide if new resource type should be skipped on mobile.");
     for (int t_int = 0; t_int < content::RESOURCE_TYPE_LAST_TYPE; t_int++) {
       content::ResourceType t = static_cast<content::ResourceType>(t_int);
       switch (t) {
         case content::RESOURCE_TYPE_STYLESHEET:
         case content::RESOURCE_TYPE_IMAGE:
         case content::RESOURCE_TYPE_FONT_RESOURCE:
         case content::RESOURCE_TYPE_FAVICON:
           break;
         default:
-          resource_types_to_check_.insert(t);
+          types_to_check.push_back(t);
       }
     }
   } else {
     // Use the finch param.
     for (const std::string& val_str : base::SplitString(
              ints_str, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
       int i;
       if (base::StringToInt(val_str, &i) && i >= 0 &&
           i < content::RESOURCE_TYPE_LAST_TYPE) {
-        resource_types_to_check_.insert(static_cast<content::ResourceType>(i));
+        types_to_check.push_back(static_cast<content::ResourceType>(i));
       }
     }
   }
+  base::flat_set<content::ResourceType> resource_types_to_check_temporary(
+      std::move(types_to_check), base::KEEP_FIRST_OF_DUPES);
+  resource_types_to_check_.swap(resource_types_to_check_temporary);
 }
 
 RemoteSafeBrowsingDatabaseManager::~RemoteSafeBrowsingDatabaseManager() {
   DCHECK(!enabled_);
 }
 
 void RemoteSafeBrowsingDatabaseManager::CancelCheck(Client* client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(enabled_);
   for (auto itr = current_requests_.begin(); itr != current_requests_.end();
@@ skipping 151 matching lines @@
   for (auto* req : to_callback) {
     DVLOG(1) << "Stopping: Invoking unfinished req for URL " << req->url();
     req->OnRequestDone(SB_THREAT_TYPE_SAFE, ThreatMetadata());
   }
   enabled_ = false;
 
   SafeBrowsingDatabaseManager::StopOnIOThread(shutdown);
 }
 
 }  // namespace safe_browsing