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

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 359 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
 }
 
-void NormalizePath(std::string* path) {
+void NormalizePath(std::string* path, const base::StringPiece& source_root) {
   char* pathbuf = path->empty() ? nullptr : &(*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;
 
     if (path->size() > 1 && pathbuf[1] == '/') {
@@ skipping 35 matching lines @@
                 // one before (otherwise we're at the end of the input).
                 pathbuf[dest_i++] = '.';
                 pathbuf[dest_i++] = '.';
                 if (consumed_len == 3)
                   pathbuf[dest_i++] = '/';
 
                 // This also makes a new "root" that we can't delete by going
                 // up more levels.  Otherwise "../.." would collapse to
                 // nothing.
                 top_index = dest_i;
+              } else if (top_index == 2 && !source_root.empty()) {
+                // |path| was passed in as a source-absolute path. Prepend
+                // |source_root| to make |path| absolute. |source_root| must not
+                // end with a slash unless we are at root.
+                DCHECK(source_root.size() == 1u ||
+                       !IsSlash(source_root[source_root.size() - 1u]));
+                size_t source_root_len = source_root.size();
+
+#if defined(OS_WIN)
+                // On Windows, if the source_root does not start with a slash,
+                // append one here for consistency.
+                if (!IsSlash(source_root[0])) {
+                  path->insert(0, "/" + source_root.as_string());
+                  source_root_len++;
+                } else {
+                  path->insert(0, source_root.data(), source_root_len);
+                }
+
+                // Normalize slashes in source root portion.
+                for (size_t i = 0; i < source_root_len; ++i) {
+                  if ((*path)[i] == '\\')
+                    (*path)[i] = '/';
+                }
+#else
+                path->insert(0, source_root.data(), source_root_len);
+#endif
+
+                // |path| is now absolute, so |top_index| is 1. |dest_i| and
+                // |src_i| should be incremented to keep the same relative
+                // position. Comsume the leading "//" by decrementing |dest_i|.
+                top_index = 1;
+                pathbuf = &(*path)[0];
+                dest_i += source_root_len - 2;
+                src_i += source_root_len;
+
+                // Just find the previous slash or the beginning of input.
+                while (dest_i > 0 && !IsSlash(pathbuf[dest_i - 1]))
+                  dest_i--;
               }
-              // Otherwise we're at the beginning of an absolute path. Don't
-              // allow ".." to go up another level and just eat it.
+              // Otherwise we're at the beginning of a system-absolute path, or
+              // a source-absolute path for which we don't know the absolute
+              // path. Don't allow ".." to go up another level, and just eat it.
             } else {
               // Just find the previous slash or the beginning of input.
               while (dest_i > 0 && !IsSlash(pathbuf[dest_i - 1]))
                 dest_i--;
             }
             src_i += consumed_len;
         }
       } else {
         // Dot not preceeded by a slash, copy it literally.
         pathbuf[dest_i++] = pathbuf[src_i++];
@@ skipping 347 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());
 }