[GN] Add support to rebase_path to resolve paths above the source root.

tools/gn/filesystem_utils_unittest.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 "base/files/file_path.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "tools/gn/filesystem_utils.h"
@@ skipping 186 matching lines @@
   EXPECT_EQ("//foo", input);
 
   input = "foo/..//bar";
   NormalizePath(&input);
   EXPECT_EQ("bar", input);
 
   input = "foo/../../bar";
   NormalizePath(&input);
   EXPECT_EQ("../bar", input);
 
-  input = "/../foo";  // Don't go aboe the root dir.
+  input = "/../foo";  // Don't go above the root dir.
   NormalizePath(&input);
   EXPECT_EQ("/foo", input);
 
   input = "//../foo";  // Don't go above the root dir.
   NormalizePath(&input);
   EXPECT_EQ("//foo", input);
 
   input = "../foo";
   NormalizePath(&input);
   EXPECT_EQ("../foo", input);
@@ skipping 16 matching lines @@
 
   // Backslash normalization.
   input = "foo\\..\\..\\bar";
   NormalizePath(&input);
   EXPECT_EQ("../bar", input);
 
   // Trailing slashes should get preserved.
   input = "//foo/bar/";
   NormalizePath(&input);
   EXPECT_EQ("//foo/bar/", input);
+
+  // Go above and outside of the source root.
+  input = "//../foo";
+  NormalizePath(&input, "/source/root");
+  EXPECT_EQ("/source/foo", input);
+
+  input = "//../foo";
+  NormalizePath(&input, "/source/root/");
+  EXPECT_EQ("/source/foo", input);
+
+  input = "//../";
+  NormalizePath(&input, "/source/root/");
+  EXPECT_EQ("/source/", input);
+
+  input = "//../foo.txt";
+  NormalizePath(&input, "/source/root");
+  EXPECT_EQ("/source/foo.txt", input);
+
+  input = "//../foo/bar/";
+  NormalizePath(&input, "/source/root");
+  EXPECT_EQ("/source/foo/bar/", input);
+
+  // Go above and back into the source root. This should return a system-
+  // absolute path. We could arguably return this as a source-absolute path,
+  // but that would require additional handling to account for a rare edge
+  // case.
+  input = "//../root/foo";
+  NormalizePath(&input, "/source/root");
+  EXPECT_EQ("/source/root/foo", input);
+
+  input = "//../root/foo/bar/";
+  NormalizePath(&input, "/source/root");
+  EXPECT_EQ("/source/root/foo/bar/", input);
+
+  // Stay inside the source root
+  input = "//foo/bar";
+  NormalizePath(&input, "/source/root");
+  EXPECT_EQ("//foo/bar", input);
+
+  input = "//foo/bar/";
+  NormalizePath(&input, "/source/root");
+  EXPECT_EQ("//foo/bar/", input);
+
+  // The path should not go above the system root.
+  input = "//../../../../../foo/bar";
+  NormalizePath(&input, "/source/root");
+  EXPECT_EQ("/foo/bar", input);
 }

[brettw, 2015/12/01 01:21:22]

Can you add a test to SourceDir that checks this is getting called correctly? It
doesn't have to handle the edge cases, those are tested here, just that the new
code that hooks up the source dir does the right thing.

Here, we should add some tests for source root of "/", and some Windows cases.

I actually think your new code doesn't work on Windows. I think the source_root
comes from BuildSetting.root_path_utf8() which is in the system native format.
You can see the RebasePath implementation has some special handling for this.
The way this is used, you will want to produce output that looks like "/C:/foo"
in this case (GN makes Windows paths start with a slash in SourceDir/SourceFile
for uniformity).

This is weird because NormalizePath previously wasn't aware of any of these
special Windows rules because it can handle both absolute and relative input and
it all kind of worked before. I may have to think about the best way to handle
this, it's possible the root path we pass in should already be GN-formatted.

Note: It looks like NormalizePath doesn't check that ".." doesn't back up over
"C:" and will make things that start looking like Unix paths with no driver
letter at that point. But I think this is OK and you can do the same thing with
the new code.

This is a bit weird. You changed RebasePath tests and it produces paths like
"C:/foo", but that's due to the special case of having an empty "new_base" which
will produce something that looks like a native path with no initial slash. This
is designed so that if the GN script is producing absolute paths to send to an
external program, that they make sense to that program.

[slan, 2015/12/01 22:15:03]

Done.
Done and done. 
The code now accepts "/C:/foo" or "C:/foo" for the source_root, always returning
the former. Comments updated to reflect this.
Right, once it backs up over the root, all bets are off IMO.
Not sure what you mean. The RebasePath tests continue to return absolute paths
in the same manner as before this CL. Would you like that behavior to change?

 
 TEST(FilesystemUtils, RebasePath) {
   base::StringPiece source_root("/source/root");
 
   // Degenerate case.
   EXPECT_EQ(".", RebasePath("//", SourceDir("//"), source_root));
   EXPECT_EQ(".", RebasePath("//foo/bar/", SourceDir("//foo/bar/"),
                             source_root));
 
   // Going up the tree.
@@ skipping 338 matching lines @@
   EXPECT_EQ("gen/", GetToolchainGenDirAsOutputFile(&settings).value());
   EXPECT_EQ("//obj/",
             GetOutputDirForSourceDir(&settings, SourceDir("//")).value());
   EXPECT_EQ("obj/",
             GetOutputDirForSourceDirAsOutputFile(
                 &settings, SourceDir("//")).value());
   EXPECT_EQ("gen/",
             GetGenDirForSourceDirAsOutputFile(
                 &settings, SourceDir("//")).value());
 }