Add GN output prefix override and allow empty output extensions.

tools/gn/target.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/target.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 194 matching lines @@
   }
 
   return true;
 }
 
 }  // namespace
 
 Target::Target(const Settings* settings, const Label& label)
     : Item(settings, label),
       output_type_(UNKNOWN),
+      output_prefix_override_(false),
+      output_extension_set_(false),
       all_headers_public_(true),
       check_includes_(true),
       complete_static_lib_(false),
       testonly_(false),
       toolchain_(nullptr) {
 }
 
 Target::~Target() {
 }
 
@@ skipping 126 matching lines @@
 DepsIteratorRange Target::GetDeps(DepsIterationType type) const {
   if (type == DEPS_LINKED) {
     return DepsIteratorRange(DepsIterator(
         &public_deps_, &private_deps_, nullptr));
   }
   // All deps.
   return DepsIteratorRange(DepsIterator(
       &public_deps_, &private_deps_, &data_deps_));
 }
 
-std::string Target::GetComputedOutputName(bool include_prefix) const {
+std::string Target::GetComputedOutputName() const {
   DCHECK(toolchain_)
       << "Toolchain must be specified before getting the computed output name.";
 
   const std::string& name = output_name_.empty() ? label().name()
                                                  : output_name_;
 
   std::string result;
-  if (include_prefix) {
-    const Tool* tool = toolchain_->GetToolForTargetFinalOutput(this);
-    if (tool) {
-      // Only add the prefix if the name doesn't already have it.
-      if (!base::StartsWith(name, tool->output_prefix(),
-                            base::CompareCase::SENSITIVE))
-        result = tool->output_prefix();
-    }
+  const Tool* tool = toolchain_->GetToolForTargetFinalOutput(this);
+  if (tool) {
+    // Only add the prefix if the name doesn't already have it and it's not
+    // being overridden.
+    if (!output_prefix_override_ &&
+        !base::StartsWith(name, tool->output_prefix(),
+                          base::CompareCase::SENSITIVE))
+      result = tool->output_prefix();
   }
   result.append(name);
   return result;
 }
 
 bool Target::SetToolchain(const Toolchain* toolchain, Err* err) {
   DCHECK(!toolchain_);
   DCHECK_NE(UNKNOWN, output_type_);
   toolchain_ = toolchain;
 
@@ skipping 142 matching lines @@
     case BUNDLE_DATA:
     case CREATE_BUNDLE:
     case SOURCE_SET:
     case COPY_FILES:
     case ACTION:
     case ACTION_FOREACH: {
       // These don't get linked to and use stamps which should be the first
       // entry in the outputs. These stamps are named
       // "<target_out_dir>/<targetname>.stamp".
       dependency_output_file_ = GetTargetOutputDirAsOutputFile(this);
-      dependency_output_file_.value().append(GetComputedOutputName(true));
+      dependency_output_file_.value().append(GetComputedOutputName());
       dependency_output_file_.value().append(".stamp");
       break;
     }
     case EXECUTABLE:
     case LOADABLE_MODULE:
       // Executables and loadable modules don't get linked to, but the first
       // output is used for dependency management.
       CHECK_GE(tool->outputs().list().size(), 1u);
       check_tool_outputs = true;
       dependency_output_file_ =
@@ skipping 227 matching lines @@
     check_data_deps = g_scheduler->IsFileGeneratedByWriteRuntimeDeps(out_file);
     // Check object files (much slower and very rare) only if the "normal"
     // output check failed.
     consider_object_files = !check_data_deps;
     if (!EnsureFileIsGeneratedByDependency(this, out_file, true,
                                            consider_object_files,
                                            check_data_deps, &seen_targets))
       g_scheduler->AddUnknownGeneratedInput(this, source);
   }
 }