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

tools/gn/filesystem_utils_unittest.cc

Index: tools/gn/filesystem_utils_unittest.cc
diff --git a/tools/gn/filesystem_utils_unittest.cc b/tools/gn/filesystem_utils_unittest.cc
index 9f89512cfa29f1260d20488e9a67a6feaed4e448..6c3ebe22a213b5923c5dc371dfed15bb76d3e67e 100644
--- a/tools/gn/filesystem_utils_unittest.cc
+++ b/tools/gn/filesystem_utils_unittest.cc
@@ -204,7 +204,7 @@ TEST(FilesystemUtils, NormalizePath) {
   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);
 
@@ -241,6 +241,53 @@ TEST(FilesystemUtils, NormalizePath) {
   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) {