[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.
+                const size_t len = source_root.ends_with("/")

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

I think we can know whether the source_root ends in a slash. I think we can do a
DCHECK and then hard code this (I think SourceDir where you call this always
expects a path a certain way).

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

Done.

+                                       ? source_root.size() - 1
+                                       : source_root.size();
+                path->insert(0, source_root.data(), len);
+                pathbuf = &(*path)[0];
+
+                // |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;
+                dest_i += len - 2;
+                src_i += 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());
 }