Revert 232657 "GN: toolchain threading cleanup"

trunk/src/tools/gn/toolchain_manager.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/toolchain_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "build/build_config.h"
@@ skipping 60 matching lines @@
   return SourceFile(dir.value() + "BUILD.gn");
 }
 
 }  // namespace
 
 struct ToolchainManager::Info {
   Info(const BuildSettings* build_settings,
        const Label& toolchain_name,
        const std::string& output_subdir_name)
       : state(TOOLCHAIN_NOT_LOADED),
-        settings(build_settings, output_subdir_name),
-        toolchain(new Toolchain(&settings, toolchain_name)),
+        toolchain(toolchain_name),
         toolchain_set(false),
+        settings(build_settings, &toolchain, output_subdir_name),
         toolchain_file_loaded(false),
         item_node(NULL) {
-    settings.set_toolchain_label(toolchain_name);
-  }
-
-  ~Info() {
-    if (!item_node)  // See toolchain definition for more.
-      delete toolchain;
   }
 
   // Makes sure that an ItemNode is created for the toolchain, which lets
   // targets depend on the (potentially future) loading of the toolchain.
   //
   // We can't always do this at the beginning since when doing the default
   // build config, we don't know the toolchain name yet. We also need to go
   // through some effort to avoid doing this inside the toolchain manager's
   // lock (to avoid holding two locks at once).
   void EnsureItemNode() {
     if (!item_node) {
       ItemTree& tree = settings.build_settings()->item_tree();
-      item_node = new ItemNode(toolchain);
+      item_node = new ItemNode(&toolchain);
       tree.AddNodeLocked(item_node);
     }
   }
 
   ToolchainState state;
 
+  Toolchain toolchain;
+  bool toolchain_set;
+  LocationRange toolchain_definition_location;
+
   // The first place in the build that we saw a reference for this toolchain.
   // This allows us to report errors if it can't be loaded and blame some
   // reasonable place of the code. This will be empty for the default toolchain.
   LocationRange specified_from;
 
   // When the state is TOOLCHAIN_SETTINGS_LOADED, the settings should be
   // considered read-only and can be read without locking. Otherwise, they
   // should not be accessed at all except to load them (which can therefore
   // also be done outside of the lock). This works as long as the state flag
   // is only ever read or written inside the lock.
   Settings settings;
 
-  // When we create an item node, this pointer will be owned by that node
-  // so it's lifetime is managed by the dependency graph. Before we've created
-  // the ItemNode, this class has to takre responsibility for this pointer.
-  Toolchain* toolchain;
-  bool toolchain_set;
-  LocationRange toolchain_definition_location;
-
   // Set when the file corresponding to the toolchain definition is loaded.
   // This will normally be set right after "toolchain_set". However, if the
   // toolchain definition is missing, the file might be marked loaded but the
   // toolchain definition could still be unset.
   bool toolchain_file_loaded;
 
   // While state == TOOLCHAIN_SETTINGS_LOADING || TOOLCHAIN_DEFINITION_LOADING,
   // this will collect all scheduled invocations using this toolchain. They'll
   // be issued once the settings file has been interpreted.
   //
@@ skipping 64 matching lines @@
 const Toolchain* ToolchainManager::GetToolchainDefinitionUnlocked(
     const Label& toolchain_name) {
   base::AutoLock lock(GetLock());
   ToolchainMap::iterator found = toolchains_.find(toolchain_name);
   if (found == toolchains_.end() || !found->second->toolchain_set)
     return NULL;
 
   // Since we don't allow defining a toolchain more than once, we know that
   // once it's set it won't be mutated, so we can safely return this pointer
   // for reading outside the lock.
-  return found->second->toolchain;
+  return &found->second->toolchain;
 }
 
 bool ToolchainManager::SetDefaultToolchainUnlocked(
     const Label& default_toolchain,
     const LocationRange& defined_here,
     Err* err) {
   base::AutoLock lock(GetLock());
   if (!default_toolchain_.is_null()) {
     *err = Err(defined_here, "Default toolchain already set.");
     err->AppendSubErr(Err(default_toolchain_defined_here_,
@@ skipping 38 matching lines @@
     info = LoadNewToolchainLocked(defined_from, tc.label(), err);
     if (!info)
       return false;
   } else {
     // It's important to preserve the exact Toolchain object in our tree since
     // it will be in the ItemTree and targets may have dependencies on it.
     info = found->second;
   }
 
   // The labels should match or else we're setting the wrong one!
-  CHECK(info->toolchain->label() == tc.label());
+  CHECK(info->toolchain.label() == tc.label());
 
-  // Save the toolchain. We can just overwrite our definition.
-  *info->toolchain = tc;
+  // Save the toolchain. We can just overwrite our definition, but we need to
+  // be careful to preserve the is_default flag.
+  bool is_default = info->toolchain.is_default();
+  info->toolchain = tc;
+  info->toolchain.set_is_default(is_default);
 
   if (info->toolchain_set) {
     *err = Err(defined_from, "Duplicate toolchain definition.");
     err->AppendSubErr(Err(
         info->toolchain_definition_location,
         "Previously defined here.",
         "A toolchain can only be defined once. One tricky way that this could\n"
         "happen is if your definition is itself in a file that's interpreted\n"
         "under different toolchains, which would result in multiple\n"
         "definitions as the file is loaded multiple times. So be sure your\n"
@@ skipping 135 matching lines @@
   toolchains_[default_toolchain_] = info;
   toolchains_.erase(old_default);
 
   // Toolchain should not have been loaded in the build config file.
   CHECK(!info->toolchain_set);
 
   // We need to set the toolchain label now that we know it. There's no way
   // to set the label, but we can assign the toolchain to a new one. Loading
   // the build config can not change the toolchain, so we won't be overwriting
   // anything useful.
-  *info->toolchain = Toolchain(&info->settings, default_toolchain_);
-  info->settings.set_is_default(true);
-  info->settings.set_toolchain_label(default_toolchain_);
+  info->toolchain = Toolchain(default_toolchain_);
+  info->toolchain.set_is_default(true);
   info->EnsureItemNode();
 
   // The default toolchain is loaded in greedy mode so all targets we
   // encounter are generated. Non-default toolchain settings stay in non-greedy
   // so we only generate the minimally required set.
   info->settings.set_greedy_target_generation(true);
 
   // Schedule a load of the toolchain build file.
   Err err;
   ScheduleInvocationLocked(LocationRange(), default_toolchain_,
@@ skipping 41 matching lines @@
 void ToolchainManager::BackgroundLoadBuildConfig(Info* info,
                                                  bool is_default,
                                                  const ParseNode* root) {
   // Danger: No early returns without decrementing the work count.
   if (root && !g_scheduler->is_failed()) {
     // Nobody should be accessing settings at this point other than us since we
     // haven't marked it loaded, so we can do it outside the lock.
     Scope* base_config = info->settings.base_config();
     base_config->set_source_dir(SourceDir("//"));
 
-    info->settings.build_settings()->build_args().SetupRootScope(
-        base_config, info->toolchain->args());
+    info->settings.build_settings()->build_args().SetupRootScope(base_config,
+        info->settings.toolchain()->args());
 
     base_config->SetProcessingBuildConfig();
     if (is_default)
       base_config->SetProcessingDefaultBuildConfig();
 
     ScopedTrace trace(TraceItem::TRACE_FILE_EXECUTE,
         info->settings.build_settings()->build_config_file().value());
-    trace.SetToolchain(info->settings.toolchain_label());
+    trace.SetToolchain(info->settings.toolchain()->label());
 
     const BlockNode* root_block = root->AsBlock();
     Err err;
     root_block->ExecuteBlockInScope(base_config, &err);
 
     trace.Done();
 
     base_config->ClearProcessingBuildConfig();
     if (is_default)
       base_config->ClearProcessingDefaultBuildConfig();
@@ skipping 24 matching lines @@
   }
   g_scheduler->DecrementWorkCount();
 }
 
 void ToolchainManager::BackgroundInvoke(const Info* info,
                                         const SourceFile& file_name,
                                         const ParseNode* root) {
   if (root && !g_scheduler->is_failed()) {
     if (g_scheduler->verbose_logging()) {
       g_scheduler->Log("Running", file_name.value() + " with toolchain " +
-                       info->toolchain->label().GetUserVisibleName(false));
+                       info->toolchain.label().GetUserVisibleName(false));
     }
 
     Scope our_scope(info->settings.base_config());
     ScopePerFileProvider per_file_provider(&our_scope);
     our_scope.set_source_dir(file_name.GetDir());
 
     ScopedTrace trace(TraceItem::TRACE_FILE_EXECUTE, file_name.value());
-    trace.SetToolchain(info->settings.toolchain_label());
+    trace.SetToolchain(info->settings.toolchain()->label());
 
     Err err;
     root->Execute(&our_scope, &err);
     if (err.has_error())
       g_scheduler->FailWithError(err);
 
     trace.Done();
 
     {
       // Check to see if any build config invocations depend on this file and
@@ skipping 15 matching lines @@
       }
     }
   }
 
   g_scheduler->DecrementWorkCount();
 }
 
 base::Lock& ToolchainManager::GetLock() const {
   return build_settings_->item_tree().lock();
 }