gn: Support build directories outside the source tree.

tools/gn/filesystem_utils.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/filesystem_utils.h"
 
 #include <algorithm>
 
 #include "base/files/file_util.h"
 #include "base/logging.h"
@@ skipping 403 matching lines @@
 
     dest->assign("//");  // Result is source root relative.
     dest->append(&path.data()[first_after_slash],
                  path.size() - first_after_slash);
     return true;
   }
   return false;
 #endif
 }
 
-std::string InvertDir(const SourceDir& path) {
-  const std::string value = path.value();
-  if (value.empty())
-    return std::string();
-
-  DCHECK(value[0] == '/');
-  size_t begin_index = 1;
-
-  // If the input begins with two slashes, skip over both (this is a
-  // source-relative dir). These must be forward slashes only.
-  if (value.size() > 1 && value[1] == '/')
-    begin_index = 2;
-
-  std::string ret;
-  for (size_t i = begin_index; i < value.size(); i++) {
-    if (IsSlash(value[i]))
-      ret.append("../");
-  }
-  return ret;
-}
-
 void NormalizePath(std::string* path) {
   char* pathbuf = path->empty() ? NULL : &(*path)[0];
 
   // top_index is the first character we can modify in the path. Anything
   // before this indicates where the path is relative to.
   size_t top_index = 0;
   bool is_relative = true;
   if (!path->empty() && pathbuf[0] == '/') {
     is_relative = false;
 
@@ skipping 77 matching lines @@
 
 void ConvertPathToSystem(std::string* path) {
 #if defined(OS_WIN)
   for (size_t i = 0; i < path->size(); i++) {
     if ((*path)[i] == '/')
       (*path)[i] = '\\';
   }
 #endif
 }
 
-std::string RebaseSourceAbsolutePath(const std::string& input,
-                                     const SourceDir& dest_dir) {
-  CHECK(input.size() >= 2 && input[0] == '/' && input[1] == '/')
-      << "Input to rebase isn't source-absolute: " << input;
-  CHECK(dest_dir.is_source_absolute())
-      << "Dir to rebase to isn't source-absolute: " << dest_dir.value();
-
-  const std::string& dest = dest_dir.value();
+std::string MakeRelativePath(const std::string& input,
+                             const std::string& dest) {
+  std::string ret;
 
   // Skip the common prefixes of the source and dest as long as they end in
   // a [back]slash.
-  size_t common_prefix_len = 2;  // The beginning two "//" are always the same.
+  size_t common_prefix_len = 0;
   size_t max_common_length = std::min(input.size(), dest.size());
   for (size_t i = common_prefix_len; i < max_common_length; i++) {
     if (IsSlash(input[i]) && IsSlash(dest[i]))
       common_prefix_len = i + 1;
     else if (input[i] != dest[i])
       break;
   }
 
   // Invert the dest dir starting from the end of the common prefix.
-  std::string ret;
   for (size_t i = common_prefix_len; i < dest.size(); i++) {
     if (IsSlash(dest[i]))
       ret.append("../");
   }
 
   // Append any remaining unique input.
   ret.append(&input[common_prefix_len], input.size() - common_prefix_len);
 
   // If the result is still empty, the paths are the same.
   if (ret.empty())
     ret.push_back('.');
 
   return ret;
 }
 
+std::string RebaseSourceAbsolutePath(const std::string& input,

[brettw, 2014/11/05 19:59:49]

Wait, doesn't this function handle all types of paths now? Can we just call it
RebasePath?

[zeuthen, 2014/11/07 19:24:12]

That's a good point. I'll rename it.

+                                     const SourceDir& dest_dir,
+                                     const base::StringPiece& source_root) {
+  std::string ret;
+  DCHECK(source_root.empty() || !source_root.ends_with("/"));
+
+  bool input_is_source_path = (input.size() >= 2 &&
+                               input[0] == '/' && input[1] == '/');
+
+  if (!source_root.empty() &&
+      (!input_is_source_path || !dest_dir.is_source_absolute())) {
+    std::string input_full;
+    std::string dest_full;
+    if (input_is_source_path) {
+      source_root.AppendToString(&input_full);
+      input_full.push_back('/');
+      input_full.append(input, 2, std::string::npos);
+    } else {
+      input_full.append(input);
+    }
+    if (dest_dir.is_source_absolute()) {
+      source_root.AppendToString(&dest_full);
+      dest_full.push_back('/');
+      dest_full.append(dest_dir.value(), 2, std::string::npos);
+    } else {
+      dest_full.append(dest_dir.value());
+    }
+    bool remove_slash = false;
+    if (!EndsWithSlash(input_full)) {
+      input_full.push_back('/');
+      remove_slash = true;
+    }
+    ret = MakeRelativePath(input_full, dest_full);
+    if (remove_slash && ret.size() > 1)
+      ret.resize(ret.size() - 1);
+    return ret;
+  }
+
+  ret = MakeRelativePath(input, dest_dir.value());
+  return ret;
+}
+
 std::string DirectoryWithNoLastSlash(const SourceDir& dir) {
   std::string ret;
 
   if (dir.value().empty()) {
     // Just keep input the same.
   } else if (dir.value() == "/") {
     ret.assign("/.");
   } else if (dir.value() == "//") {
     ret.assign("//.");
   } else {
@@ skipping 102 matching lines @@
 OutputFile GetOutputDirForSourceDirAsOutputFile(const Settings* settings,
                                                 const SourceDir& source_dir) {
   OutputFile result = settings->toolchain_output_subdir();
   result.value().append("obj/");
 
   if (source_dir.is_source_absolute()) {
     // The source dir is source-absolute, so we trim off the two leading
     // slashes to append to the toolchain object directory.
     result.value().append(&source_dir.value()[2],
                           source_dir.value().size() - 2);
+  } else {
+    // system-absolute
+    const std::string& build_dir =
+        settings->build_settings()->build_dir().value();
+
+    if (StartsWithASCII(source_dir.value(), build_dir, true)) {
+      size_t build_dir_size = build_dir.size();
+      result.value().append(&source_dir.value()[build_dir_size],
+                            source_dir.value().size() - build_dir_size);
+    }
   }
   return result;
 }
 
 SourceDir GetGenDirForSourceDir(const Settings* settings,
                                 const SourceDir& source_dir) {
   return GetGenDirForSourceDirAsOutputFile(settings, source_dir).AsSourceDir(
       settings->build_settings());
 }
 
@@ skipping 34 matching lines @@
 
 SourceDir GetCurrentOutputDir(const Scope* scope) {
   return GetOutputDirForSourceDirAsOutputFile(
       scope->settings(), scope->GetSourceDir()).AsSourceDir(
           scope->settings()->build_settings());
 }
 
 SourceDir GetCurrentGenDir(const Scope* scope) {
   return GetGenDirForSourceDir(scope->settings(), scope->GetSourceDir());
 }