gn: Support build directories outside the source tree.

tools/gn/label.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/label.h"
 
 #include "base/logging.h"
 #include "tools/gn/err.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/value.h"
@@ skipping 10 matching lines @@
 }
 
 // Given the separate-out input (everything before the colon) in the dep rule,
 // computes the final build rule. Sets err on failure. On success,
 // |*used_implicit| will be set to whether the implicit current directory was
 // used. The value is used only for generating error messages.
 bool ComputeBuildLocationFromDep(const Value& input_value,
                                  const SourceDir& current_dir,
                                  const base::StringPiece& input,
                                  SourceDir* result,
+                                 const base::FilePath& source_root,
                                  Err* err) {
   // No rule, use the current locaton.
   if (input.empty()) {
     *result = current_dir;
     return true;
   }
 
   // Don't allow directories to start with a single slash. All labels must be
   // in the source root.
   if (input[0] == '/' && (input.size() == 1 || input[1] != '/')) {
     *err = Err(input_value, "Label can't start with a single slash",
         "Labels must be either relative (no slash at the beginning) or be "
         "absolute\ninside the source root (two slashes at the beginning).");
     return false;
   }
 
-  *result = current_dir.ResolveRelativeDir(input);
+  *result = current_dir.ResolveRelativeDir(input, source_root);
   return true;
 }
 
 // Given the separated-out target name (after the colon) computes the final
 // name, using the implicit name from the previously-generated
 // computed_location if necessary. The input_value is used only for generating
 // error messages.
 bool ComputeTargetNameFromDep(const Value& input_value,
                               const SourceDir& computed_location,
                               const base::StringPiece& input,
@@ skipping 34 matching lines @@
 // Returns true on success. On failure, the out* variables might be written to
 // but shouldn't be used.
 bool Resolve(const SourceDir& current_dir,
              const Label& current_toolchain,
              const Value& original_value,
              const base::StringPiece& input,
              SourceDir* out_dir,
              std::string* out_name,
              SourceDir* out_toolchain_dir,
              std::string* out_toolchain_name,
+             const base::FilePath& source_root,
              Err* err) {
   // To workaround the problem that StringPiece operator[] doesn't return a ref.
   const char* input_str = input.data();
 
   size_t path_separator = input.find_first_of(":(");
   base::StringPiece location_piece;
   base::StringPiece name_piece;
   base::StringPiece toolchain_piece;
   if (path_separator == std::string::npos) {
     location_piece = input;
@@ skipping 41 matching lines @@
   //   Absolute:                "//foo:bar" -> /foo:bar
   //   Target in current file:  ":foo"     -> <currentdir>:foo
   //   Path with implicit name: "/foo"     -> /foo:foo
   if (location_piece.empty() && name_piece.empty()) {
     // Can't use both implicit filename and name (":").
     *err = Err(original_value, "This doesn't specify a dependency.");
     return false;
   }
 
   if (!ComputeBuildLocationFromDep(original_value, current_dir, location_piece,
-                                   out_dir, err))
+                                   out_dir, source_root, err))
     return false;
 
   if (!ComputeTargetNameFromDep(original_value, *out_dir, name_piece,
                                 out_name, err))
     return false;
 
   // Last, do the toolchains.
   if (out_toolchain_dir) {
     // Handle empty toolchain strings. We don't allow normal labels to be
     // empty so we can't allow the recursive call of this function to do this
     // check.
     if (toolchain_piece.empty()) {
       *out_toolchain_dir = current_toolchain.dir();
       *out_toolchain_name = current_toolchain.name();
       return true;
     } else {
       return Resolve(current_dir, current_toolchain,
                      original_value, toolchain_piece,
-                     out_toolchain_dir, out_toolchain_name, NULL, NULL, err);
+                     out_toolchain_dir, out_toolchain_name, NULL, NULL,
+                     source_root, err);
     }
   }
   return true;
 }
 
 }  // namespace
 
 Label::Label() {
 }
 
@@ skipping 12 matching lines @@
   name_.assign(name.data(), name.size());
 }
 
 Label::~Label() {
 }
 
 // static
 Label Label::Resolve(const SourceDir& current_dir,
                      const Label& current_toolchain,
                      const Value& input,
+                     const base::FilePath& source_root,
                      Err* err) {
   Label ret;
   if (input.type() != Value::STRING) {
     *err = Err(input, "Dependency is not a string.");
     return ret;
   }
   const std::string& input_string = input.string_value();
   if (input_string.empty()) {
     *err = Err(input, "Dependency string is empty.");
     return ret;
   }
 
   if (!::Resolve(current_dir, current_toolchain, input, input_string,
                  &ret.dir_, &ret.name_,
                  &ret.toolchain_dir_, &ret.toolchain_name_,
-                 err))
+                 source_root, err))
     return Label();
   return ret;
 }
 
 Label Label::GetToolchainLabel() const {
   return Label(toolchain_dir_, toolchain_name_);
 }
 
 Label Label::GetWithNoToolchain() const {
   return Label(dir_, name_);
@@ skipping 21 matching lines @@
   }
   return ret;
 }
 
 std::string Label::GetUserVisibleName(const Label& default_toolchain) const {
   bool include_toolchain =
       default_toolchain.dir() != toolchain_dir_ ||
       default_toolchain.name() != toolchain_name_;
   return GetUserVisibleName(include_toolchain);
 }