GN: Use std::unique_ptr in Loader::ToolchainRecordMap.

tools/gn/loader.cc

 // Copyright (c) 2013 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 "tools/gn/loader.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
-#include "base/stl_util.h"
 #include "tools/gn/build_settings.h"
 #include "tools/gn/err.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/input_file_manager.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/scope_per_file_provider.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/source_dir.h"
 #include "tools/gn/source_file.h"
@@ skipping 78 matching lines @@
 
 // -----------------------------------------------------------------------------
 
 LoaderImpl::LoaderImpl(const BuildSettings* build_settings)
     : main_loop_(base::MessageLoop::current()),
       pending_loads_(0),
       build_settings_(build_settings) {
 }
 
 LoaderImpl::~LoaderImpl() {
-  STLDeleteContainerPairSecondPointers(toolchain_records_.begin(),
-                                       toolchain_records_.end());
 }
 
 void LoaderImpl::Load(const SourceFile& file,
                       const LocationRange& origin,
                       const Label& in_toolchain_name) {
   const Label& toolchain_name = in_toolchain_name.is_null()
       ? default_toolchain_label_ : in_toolchain_name;
   LoadID load_id(file, toolchain_name);
   if (!invocations_.insert(load_id).second)
     return;  // Already in set, so this file was already loaded or schedulerd.
 
   if (toolchain_records_.empty()) {
-    // Nothing loaded, need to load the default build config. The intial load
+    // Nothing loaded, need to load the default build config. The initial load
     // should not specify a toolchain.
     DCHECK(toolchain_name.is_null());
 
-    ToolchainRecord* record =
-        new ToolchainRecord(build_settings_, Label(), Label());
-    toolchain_records_[Label()] = record;
+    std::unique_ptr<ToolchainRecord> new_record(
+        new ToolchainRecord(build_settings_, Label(), Label()));
+    ToolchainRecord* record = new_record.get();
+    toolchain_records_[Label()] = std::move(new_record);
 
     // The default build config is no dependent on the toolchain definition,
     // since we need to load the build config before we know what the default
     // toolchain name is.
     record->is_toolchain_loaded = true;
 
     record->waiting_on_me.push_back(SourceFileAndOrigin(file, origin));
     ScheduleLoadBuildConfig(&record->settings, Scope::KeyValueMap());
+
     return;
   }
 
   ToolchainRecord* record;
   if (toolchain_name.is_null())
-    record = toolchain_records_[default_toolchain_label_];
+    record = toolchain_records_[default_toolchain_label_].get();
   else
-    record = toolchain_records_[toolchain_name];
+    record = toolchain_records_[toolchain_name].get();
 
   if (!record) {
     DCHECK(!default_toolchain_label_.is_null());
 
     // No reference to this toolchain found yet, make one.
-    record = new ToolchainRecord(build_settings_, toolchain_name,
-                                 default_toolchain_label_);
-    toolchain_records_[toolchain_name] = record;
+    std::unique_ptr<ToolchainRecord> new_record(new ToolchainRecord(
+        build_settings_, toolchain_name, default_toolchain_label_));
+    record = new_record.get();
+    toolchain_records_[toolchain_name] = std::move(new_record);
 
     // Schedule a load of the toolchain using the default one.
     Load(BuildFileForLabel(toolchain_name), origin, default_toolchain_label_);
   }
 
   if (record->is_config_loaded)
     ScheduleLoadFile(&record->settings, origin, file);
   else
     record->waiting_on_me.push_back(SourceFileAndOrigin(file, origin));
 }
 
 void LoaderImpl::ToolchainLoaded(const Toolchain* toolchain) {
-  ToolchainRecord* record = toolchain_records_[toolchain->label()];
+  ToolchainRecord* record = toolchain_records_[toolchain->label()].get();
   if (!record) {
     DCHECK(!default_toolchain_label_.is_null());
-    record = new ToolchainRecord(build_settings_, toolchain->label(),
-                                 default_toolchain_label_);
-    toolchain_records_[toolchain->label()] = record;
+    std::unique_ptr<ToolchainRecord> new_record(new ToolchainRecord(
+        build_settings_, toolchain->label(), default_toolchain_label_));
+    record = new_record.get();
+    toolchain_records_[toolchain->label()] = std::move(new_record);
   }
   record->is_toolchain_loaded = true;
 
   // The default build config is loaded first, then its toolchain. Secondary
   // ones are loaded in the opposite order so we can pass toolchain parameters
   // to the build config. So we may or may not have a config at this point.
   if (!record->is_config_loaded) {
     ScheduleLoadBuildConfig(&record->settings, toolchain->args());
   } else {
     // There should be nobody waiting on this if the build config is already
@@ skipping 167 matching lines @@
     // When loading the default build config, we'll insert it into the record
     // map with an empty label since we don't yet know what to call it.
     //
     // In this case, we should have exactly one entry in the map with an empty
     // label. We now need to fix up the naming so it refers to the "real" one.
     CHECK_EQ(1U, toolchain_records_.size());
     ToolchainRecordMap::iterator empty_label = toolchain_records_.find(Label());
     CHECK(empty_label != toolchain_records_.end());
 
     // Fix up the toolchain record.
-    record = empty_label->second;
-    toolchain_records_[label] = record;
+    std::unique_ptr<ToolchainRecord> moved_record =
+        std::move(empty_label->second);
+    record = moved_record.get();
+    toolchain_records_[label] = std::move(moved_record);
     toolchain_records_.erase(empty_label);
 
     // Save the default toolchain label.
     default_toolchain_label_ = label;
     DCHECK(record->settings.default_toolchain_label().is_null());
     record->settings.set_default_toolchain_label(label);
 
     // The settings object should have the toolchain label already set.
     DCHECK(!record->settings.toolchain_label().is_null());
 
     // Update any stored invocations that refer to the empty toolchain label.
     // This will normally only be one, for the root build file, so brute-force
     // is OK.
     LoadIDSet old_loads;
     invocations_.swap(old_loads);
     for (const auto& load : old_loads) {
       if (load.toolchain_name.is_null()) {
         // Fix up toolchain label
         invocations_.insert(LoadID(load.file, label));
       } else {
         // Can keep the old one.
         invocations_.insert(load);
       }
     }
   } else {
-    record = found_toolchain->second;
+    record = found_toolchain->second.get();
   }
 
   DCHECK(!record->is_config_loaded);
   DCHECK(record->is_toolchain_loaded);
   record->is_config_loaded = true;
 
   // Schedule all waiting file loads.
   for (const auto& waiting : record->waiting_on_me)
     ScheduleLoadFile(&record->settings, waiting.origin, waiting.file);
   record->waiting_on_me.clear();
@@ skipping 14 matching lines @@
     const SourceFile& file_name,
     const base::Callback<void(const ParseNode*)>& callback,
     Err* err) {
   if (async_load_file_.is_null()) {
     return g_scheduler->input_file_manager()->AsyncLoadFile(
         origin, build_settings, file_name, callback, err);
   }
   return async_load_file_.Run(
       origin, build_settings, file_name, callback, err);
 }