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 402 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,
+                                     const SourceDir& dest_dir,
+                                     const base::FilePath& source_root) {
+  std::string ret;
+  bool input_is_source_path = (input.size() >= 2 &&
+                               input[0] == '/' && input[1] == '/');
+
+  if (!input_is_source_path || !dest_dir.is_source_absolute()) {
+    std::string input_full;
+    std::string dest_full;
+    if (input_is_source_path)
+      input_full = source_root.Append(input.substr(2)).value();

[brettw, 2014/10/07 23:55:05]

I tracked the performance regression to this function, which is called a lot (I
locally substitutied the old implementation). I notice there are kind of a lot
of string allocations and copies (just this line is three). MakeRelativePath at
the bottom is also kind of slow. We should optimize this.

Also, this won't work at all on Windows. The FilePath temporary will make
backslashes which I think will confuse things. And you can't append the
wchar_t's and chars the way you're doing on this line.

I think it might be better to keep the source root either a StringPiece or an
absolute SourceDir.

[zeuthen, 2014/10/08 15:21:06]

Fair enough, I'll try to make this go faster / fewer copies etc. (Just wrapping
my head around the code and getting it to do the right thing was a lot of
work... so I didn't pay much attention to performance.)

[zeuthen, 2014/11/04 19:49:16]

Upcoming CL makes this part more efficient.

+    else
+      input_full = input;
+    if (dest_dir.is_source_absolute())
+      dest_full = source_root.Append(dest_dir.value().substr(2)).value();
+    else
+      dest_full = dest_dir.value();
+    bool remove_slash = false;
+    if (!EndsWithSlash(input_full)) {
+      input_full.push_back('/');
+      remove_slash = true;
+    }
+    if (!EndsWithSlash(dest_full))
+      dest_full.push_back('/');
+
+    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());
 }