gn: Support build directories outside the source tree.

tools/gn/label_pattern.cc

 // Copyright 2014 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_pattern.h"
 
 #include "tools/gn/err.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/value.h"
 
@@ skipping 43 matching lines @@
     : toolchain_(toolchain_label),
       type_(type),
       dir_(dir) {
   name.CopyToString(&name_);
 }
 
 LabelPattern::~LabelPattern() {
 }
 
 // static
-LabelPattern LabelPattern::GetPattern(const SourceDir& current_dir,
+LabelPattern LabelPattern::GetPattern(const base::FilePath& source_root,
+                                      const SourceDir& current_dir,
                                       const Value& value,
                                       Err* err) {
   if (!value.VerifyTypeIs(Value::STRING, err))
     return LabelPattern();
 
   base::StringPiece str(value.string_value());
   if (str.empty()) {
     *err = Err(value, "Label pattern must not be empty.");
     return LabelPattern();
   }
 
   // If there's no wildcard, this is specifying an exact label, use the
   // label resolution code to get all the implicit name stuff.
   size_t star = str.find('*');
   if (star == std::string::npos) {
-    Label label = Label::Resolve(current_dir, Label(), value, err);
+    Label label = Label::Resolve(current_dir, Label(), value, source_root, err);
     if (err->has_error())
       return LabelPattern();
 
     // Toolchain.
     Label toolchain_label;
     if (!label.toolchain_dir().is_null() || !label.toolchain_name().empty())
       toolchain_label = label.GetToolchainLabel();
 
     return LabelPattern(MATCH, label.dir(), label.name(), toolchain_label);
   }
@@ skipping 12 matching lines @@
     std::string toolchain_string =
         str.substr(open_paren + 1, close_paren - open_paren - 1).as_string();
     if (toolchain_string.find('*') != std::string::npos) {
       *err = Err(value, "Can't have a wildcard in the toolchain.");
       return LabelPattern();
     }
 
     // Parse the inside of the parens as a label for a toolchain.
     Value value_for_toolchain(value.origin(), toolchain_string);
     toolchain_label =
-        Label::Resolve(current_dir, Label(), value_for_toolchain, err);
+        Label::Resolve(current_dir, Label(), value_for_toolchain, source_root,
+                       err);
     if (err->has_error())
       return LabelPattern();
 
     // Trim off the toolchain for the processing below.
     str = str.substr(0, open_paren);
   }
 
   // Extract path and name.
   base::StringPiece path;
   base::StringPiece name;
@@ skipping 35 matching lines @@
   // Resolve the part of the path that's not the wildcard.
   if (!path.empty()) {
     // The non-wildcard stuff better not have a wildcard.
     if (path.find('*') != base::StringPiece::npos) {
       *err = Err(value, "Label patterns only support wildcard suffixes.",
           "The pattern contained a '*' that wasn't at tne end.");
       return LabelPattern();
     }
 
     // Resolve the non-wildcard stuff.
-    dir = current_dir.ResolveRelativeDir(path);
+    dir = current_dir.ResolveRelativeDir(path, source_root);
     if (dir.is_null()) {
       *err = Err(value, "Label pattern didn't resolve to a dir.",
           "The directory name \"" + path.as_string() + "\" didn't\n"
           "resolve to a directory.");
       return LabelPattern();
     }
   }
 
   // Resolve the name. At this point, we're doing wildcard matches so the
   // name should either be empty ("foo/*") or a wildcard ("foo:*");
@@ skipping 58 matching lines @@
       break;
   }
 
   if (!toolchain_.is_null()) {
     result.push_back('(');
     result.append(toolchain_.GetUserVisibleName(false));
     result.push_back(')');
   }
   return result;
 }