diff --git a/tools/gn/build_settings.cc b/tools/gn/build_settings.cc
index 38b830f..79b8365 100644
--- a/tools/gn/build_settings.cc
+++ b/tools/gn/build_settings.cc
@@ -49,6 +49,11 @@
   return dir.Resolve(root_path_).NormalizePathSeparatorsTo('/');
 }
 
+base::FilePath BuildSettings::GetFullPath(const std::string& path,
+                                          bool as_file) const {
+  return ResolvePath(path, as_file, root_path_).NormalizePathSeparatorsTo('/');
+}
+
 base::FilePath BuildSettings::GetFullPathSecondary(
     const SourceFile& file) const {
   return file.Resolve(secondary_source_path_).NormalizePathSeparatorsTo('/');
@@ -59,6 +64,12 @@
   return dir.Resolve(secondary_source_path_).NormalizePathSeparatorsTo('/');
 }
 
+base::FilePath BuildSettings::GetFullPathSecondary(const std::string& path,
+                                                   bool as_file) const {
+  return ResolvePath(path, as_file, secondary_source_path_)
+      .NormalizePathSeparatorsTo('/');
+}
+
 void BuildSettings::ItemDefined(std::unique_ptr<Item> item) const {
   DCHECK(item);
   if (!item_defined_callback_.is_null())
diff --git a/tools/gn/build_settings.h b/tools/gn/build_settings.h
index 670f996..52f3625 100644
--- a/tools/gn/build_settings.h
+++ b/tools/gn/build_settings.h
@@ -79,12 +79,21 @@
   // root source tree.
   base::FilePath GetFullPath(const SourceFile& file) const;
   base::FilePath GetFullPath(const SourceDir& dir) const;
+  // Works the same way as other GetFullPath.
+  // Parameter as_file defines whether path should be treated as a
+  // SourceFile or SourceDir value.
+  base::FilePath GetFullPath(const std::string& path, bool as_file) const;
 
   // Returns the absolute OS path inside the secondary source path. Will return
   // an empty FilePath if the secondary source path is empty. When loading a
   // buildfile, the GetFullPath should always be consulted first.
   base::FilePath GetFullPathSecondary(const SourceFile& file) const;
   base::FilePath GetFullPathSecondary(const SourceDir& dir) const;
+  // Works the same way as other GetFullPathSecondary.
+  // Parameter as_file defines whether path should be treated as a
+  // SourceFile or SourceDir value.
+  base::FilePath GetFullPathSecondary(const std::string& path,
+                                      bool as_file) const;
 
   // Called when an item is defined from a background thread.
   void ItemDefined(std::unique_ptr<Item> item) const;
diff --git a/tools/gn/filesystem_utils.cc b/tools/gn/filesystem_utils.cc
index 6cce895..f9f6794 100644
--- a/tools/gn/filesystem_utils.cc
+++ b/tools/gn/filesystem_utils.cc
@@ -705,6 +705,109 @@
   return ret;
 }
 
+base::FilePath ResolvePath(const std::string& value,
+                           bool as_file,
+                           const base::FilePath& source_root) {
+  if (value.empty())
+    return base::FilePath();
+
+  std::string converted;
+  if (!IsPathSourceAbsolute(value)) {
+    if (value.size() > 2 && value[2] == ':') {
+      // Windows path, strip the leading slash.
+      converted.assign(&value[1], value.size() - 1);
+    } else {
+      converted.assign(value);
+    }
+    return base::FilePath(UTF8ToFilePath(converted));
+  }
+
+  // String the double-leading slash for source-relative paths.
+  converted.assign(&value[2], value.size() - 2);
+
+  if (as_file && source_root.empty())
+    return UTF8ToFilePath(converted).NormalizePathSeparatorsTo('/');
+
+  return source_root.Append(UTF8ToFilePath(converted))
+      .NormalizePathSeparatorsTo('/');
+}
+
+template <typename StringType>
+std::string ResolveRelative(const StringType& input,
+                            const std::string& value,
+                            bool as_file,
+                            const base::StringPiece& source_root) {
+  std::string result;
+
+  if (input.size() >= 2 && input[0] == '/' && input[1] == '/') {
+    // Source-relative.
+    result.assign(input.data(), input.size());
+    if (!as_file) {
+      if (!EndsWithSlash(result))
+        result.push_back('/');
+    }
+    NormalizePath(&result, source_root);
+    return result;
+  } else if (IsPathAbsolute(input)) {
+    if (source_root.empty() ||
+        !MakeAbsolutePathRelativeIfPossible(source_root, input, &result)) {
+#if defined(OS_WIN)
+      if (input[0] != '/')  // See the file case for why we do this check.
+        result = "/";
+#endif
+      result.append(input.data(), input.size());
+    }
+    NormalizePath(&result);
+    if (!as_file) {
+      if (!EndsWithSlash(result))
+        result.push_back('/');
+    }
+    return result;
+  }
+
+  if (!source_root.empty()) {
+    std::string absolute =
+        FilePathToUTF8(ResolvePath(value, as_file, UTF8ToFilePath(source_root))
+                           .AppendASCII(input)
+                           .value());
+    NormalizePath(&absolute);
+    if (!MakeAbsolutePathRelativeIfPossible(source_root, absolute, &result)) {
+#if defined(OS_WIN)
+      if (absolute[0] != '/')  // See the file case for why we do this check.
+        result = "/";
+#endif
+      result.append(absolute.data(), absolute.size());
+    }
+    if (!as_file && !EndsWithSlash(result))
+      result.push_back('/');
+    return result;
+  }
+
+  // With no source_root, there's nothing we can do about
+  // e.g. input=../../../path/to/file and value=//source and we'll
+  // errornously return //file.
+  result.reserve(value.size() + input.size());
+  result.assign(value);
+  result.append(input.data(), input.size());
+
+  NormalizePath(&result);
+  if (!as_file && !EndsWithSlash(result))
+    result.push_back('/');
+
+  return result;
+}
+
+// Explicit template instantiation
+template std::string ResolveRelative(const base::StringPiece& input,
+                                     const std::string& value,
+                                     bool as_file,
+                                     const base::StringPiece& source_root);
+
+template std::string ResolveRelative(const std::string& input,
+                                     const std::string& value,
+                                     bool as_file,
+                                     const base::StringPiece& source_root);
+
 std::string DirectoryWithNoLastSlash(const SourceDir& dir) {
   std::string ret;
 
diff --git a/tools/gn/filesystem_utils.h b/tools/gn/filesystem_utils.h
index 0396283..1313279 100644
--- a/tools/gn/filesystem_utils.h
+++ b/tools/gn/filesystem_utils.h
@@ -152,6 +152,31 @@
     const SourceDir& dest_dir,
     const base::StringPiece& source_root = base::StringPiece());
 
+// Resolves a file or dir name (parameter input) relative to
+// value directory. Will return an empty SourceDir/File on error
+// and set the give *err pointer (required). Empty input is always an error.
+// Returned value can be used to set value in either SourceFile or SourceDir
+// (based on as_file parameter).
+//
+// Parameter as_file defines whether result path will look like a file path
+// or it should be treated as a directory (contains "/" and the end
+// of the string).
+//
+// If source_root is supplied, these functions will additionally handle the
+// case where the input is a system-absolute but still inside the source
+// tree. This is the case for some external tools.
+template <typename StringType>
+std::string ResolveRelative(const StringType& input,
+                            const std::string& value,
+                            bool as_file,
+                            const base::StringPiece& source_root);
+
+// Resolves source file or directory relative to some given source root. Returns
+// an empty file path on error.
+base::FilePath ResolvePath(const std::string& value,
+                           bool as_file,
+                           const base::FilePath& source_root);
+
 // Returns the given directory with no terminating slash at the end, such that
 // appending a slash and more stuff will produce a valid path.
 //
diff --git a/tools/gn/function_exec_script.cc b/tools/gn/function_exec_script.cc
index 139b811..0f6397c 100644
--- a/tools/gn/function_exec_script.cc
+++ b/tools/gn/function_exec_script.cc
@@ -137,19 +137,21 @@
     return Value();
 
   // Find the python script to run.
-  SourceFile script_source =
-      cur_dir.ResolveRelativeFile(args[0], err,
-          scope->settings()->build_settings()->root_path_utf8());
+  std::string script_source_path = cur_dir.ResolveRelativeAs(
+      true, args[0], err,
+      scope->settings()->build_settings()->root_path_utf8());
   if (err->has_error())
     return Value();
-  base::FilePath script_path = build_settings->GetFullPath(script_source);
+  base::FilePath script_path =
+      build_settings->GetFullPath(script_source_path, true);
   if (!build_settings->secondary_source_path().empty() &&
       !base::PathExists(script_path)) {
     // Fall back to secondary source root when the file doesn't exist.
-    script_path = build_settings->GetFullPathSecondary(script_source);
+    script_path =
+        build_settings->GetFullPathSecondary(script_source_path, true);
   }
 
-  ScopedTrace trace(TraceItem::TRACE_SCRIPT_EXECUTE, script_source.value());
+  ScopedTrace trace(TraceItem::TRACE_SCRIPT_EXECUTE, script_source_path);
   trace.SetToolchain(settings->toolchain_label());
 
   // Add all dependencies of this script, including the script itself, to the
@@ -163,10 +165,11 @@
     for (const auto& dep : deps_value.list_value()) {
       if (!dep.VerifyTypeIs(Value::STRING, err))
         return Value();
-      g_scheduler->AddGenDependency(
-          build_settings->GetFullPath(cur_dir.ResolveRelativeFile(
-              dep, err,
-              scope->settings()->build_settings()->root_path_utf8())));
+      g_scheduler->AddGenDependency(build_settings->GetFullPath(
+          cur_dir.ResolveRelativeAs(
+              true, dep, err,
+              scope->settings()->build_settings()->root_path_utf8()),
+          true));
       if (err->has_error())
         return Value();
     }
@@ -236,10 +239,12 @@
     }
   }
   if (g_scheduler->verbose_logging()) {
-    g_scheduler->Log("Pythoning", script_source.value() + " took " +
-        base::Int64ToString(
-            (base::TimeTicks::Now() - begin_exec).InMilliseconds()) +
-        "ms");
+    g_scheduler->Log(
+        "Pythoning",
+        script_source_path + " took " +
+            base::Int64ToString(
+                (base::TimeTicks::Now() - begin_exec).InMilliseconds()) +
+            "ms");
   }
 
   if (exit_code != 0) {
diff --git a/tools/gn/function_get_path_info.cc b/tools/gn/function_get_path_info.cc
index 1c542aa..e08eca1 100644
--- a/tools/gn/function_get_path_info.cc
+++ b/tools/gn/function_get_path_info.cc
@@ -41,7 +41,7 @@
         settings->build_settings()->root_path_utf8());
   }
 
-  // Input is a directory.
+  // Input is a file.
   return current_dir.ResolveRelativeFile(input, err,
       settings->build_settings()->root_path_utf8()).GetDir();
 }
@@ -100,14 +100,12 @@
           BuildDirType::OBJ));
     }
     case WHAT_ABSPATH: {
-      if (!input_string.empty() &&
-          input_string[input_string.size() - 1] == '/') {
-        return current_dir.ResolveRelativeDir(input, err,
-            settings->build_settings()->root_path_utf8()).value();
-      } else {
-        return current_dir.ResolveRelativeFile(input, err,
-            settings->build_settings()->root_path_utf8()).value();
-      }
+      bool as_dir =
+          !input_string.empty() && input_string[input_string.size() - 1] == '/';
+
+      return current_dir.ResolveRelativeAs(
+          !as_dir, input, err, settings->build_settings()->root_path_utf8(),
+          &input_string);
     }
     default:
       NOTREACHED();
diff --git a/tools/gn/source_dir.cc b/tools/gn/source_dir.cc
index e8fdff0..17eeb61 100644
--- a/tools/gn/source_dir.cc
+++ b/tools/gn/source_dir.cc
@@ -23,6 +23,38 @@
   }
 }
 
+// Validates input value (input_value) and sets proper error message.
+// Note: Parameter blame_input is used only for generating error message.
+template <typename StringType>
+bool ValidateResolveInput(bool as_file,
+                          const Value& blame_input_value,
+                          const StringType& input_value,
+                          Err* err) {
+  if (as_file) {
+    // It's an error to resolve an empty string or one that is a directory
+    // (indicated by a trailing slash) because this is the function that expects
+    // to return a file.
+    if (input_value.empty()) {
+      *err = Err(blame_input_value, "Empty file path.",
+                 "You can't use empty strings as file paths.");
+      return false;
+    } else if (input_value[input_value.size() - 1] == '/') {
+      std::string help = "You specified the path\n  ";
+      help.append(std::string(input_value));
+      help.append(
+          "\nand it ends in a slash, indicating you think it's a directory."
+          "\nBut here you're supposed to be listing a file.");
+      *err = Err(blame_input_value, "File path ends in a slash.", help);
+      return false;
+    }
+  } else if (input_value.empty()) {
+    *err = Err(blame_input_value, "Empty directory path.",
+               "You can't use empty strings as directories.");
+    return false;
+  }
+  return true;
+}
+
 }  // namespace
 
 SourceDir::SourceDir() = default;
@@ -43,176 +75,85 @@
 
 SourceDir::~SourceDir() = default;
 
+template <typename StringType>
+std::string SourceDir::ResolveRelativeAs(
+    bool as_file,
+    const Value& blame_input_value,
+    const StringType& input_value,
+    Err* err,
+    const base::StringPiece& source_root) const {
+  if (!ValidateResolveInput<StringType>(as_file, blame_input_value, input_value,
+                                        err)) {
+    return std::string();
+  }
+  return ResolveRelative(input_value, value_, as_file, source_root);
+}
+
 SourceFile SourceDir::ResolveRelativeFile(
     const Value& p,
     Err* err,
     const base::StringPiece& source_root) const {
   SourceFile ret;
+
   if (!p.VerifyTypeIs(Value::STRING, err))
     return ret;
 
-  // It's an error to resolve an empty string or one that is a directory
-  // (indicated by a trailing slash) because this is the function that expects
-  // to return a file.
-  const std::string& str = p.string_value();
-  if (str.empty()) {
-    *err = Err(p, "Empty file path.",
-               "You can't use empty strings as file paths. That's just wrong.");
-    return ret;
-  } else if (str[str.size() - 1] == '/') {
-    *err = Err(p, "File path ends in a slash.",
-               "You specified the path\n  " + str + "\n"
-               "and it ends in a slash, indicating you think it's a directory."
-               "\nBut here you're supposed to be listing a file.");
+  const std::string& input_string = p.string_value();
+  if (!ValidateResolveInput<std::string>(true, p, input_string, err)) {
     return ret;
   }
-
-  if (str.size() >= 2 && str[0] == '/' && str[1] == '/') {
-    // Source-relative.
-    ret.value_.assign(str.data(), str.size());
-    NormalizePath(&ret.value_, source_root);
-    return ret;
-  } else if (IsPathAbsolute(str)) {
-    if (source_root.empty() ||
-        !MakeAbsolutePathRelativeIfPossible(source_root, str, &ret.value_)) {
-#if defined(OS_WIN)
-      // On Windows we'll accept "C:\foo" as an absolute path, which we want
-      // to convert to "/C:..." here.
-      if (str[0] != '/')
-        ret.value_ = "/";
-#endif
-      ret.value_.append(str.data(), str.size());
-    }
-    NormalizePath(&ret.value_);
-    return ret;
-  }
-
-  if (!source_root.empty()) {
-    std::string absolute =
-        FilePathToUTF8(Resolve(UTF8ToFilePath(source_root)).AppendASCII(
-            str).value());
-    NormalizePath(&absolute);
-    if (!MakeAbsolutePathRelativeIfPossible(source_root, absolute,
-                                            &ret.value_)) {
-#if defined(OS_WIN)
-      // On Windows we'll accept "C:\foo" as an absolute path, which we want
-      // to convert to "/C:..." here.
-      if (absolute[0] != '/')
-        ret.value_ = "/";
-#endif
-      ret.value_.append(absolute.data(), absolute.size());
-    }
-    return ret;
-  }
-
-  // With no source_root_, there's nothing we can do about
-  // e.g. p=../../../path/to/file and value_=//source and we'll
-  // errornously return //file.
-  ret.value_.reserve(value_.size() + str.size());
-  ret.value_.assign(value_);
-  ret.value_.append(str.data(), str.size());
-
-  NormalizePath(&ret.value_);
+  ret.value_ = ResolveRelative(input_string, value_, true, source_root);
   return ret;
 }
 
+std::string SourceDir::ResolveRelativeAs(bool as_file,
+                                         const Value& v,
+                                         Err* err,
+                                         const base::StringPiece& source_root,
+                                         const std::string* v_value) const {
+  if (!v.VerifyTypeIs(Value::STRING, err))
+    return std::string();
+
+  if (!v_value) {
+    v_value = &v.string_value();
+  }
+  std::string result =
+      ResolveRelativeAs(as_file, v, *v_value, err, source_root);
+  if (!as_file)
+    AssertValueSourceDirString(result);
+  return result;
+}
+
 SourceDir SourceDir::ResolveRelativeDir(
-    const Value& p,
+    const Value& v,
     Err* err,
     const base::StringPiece& source_root) const {
-  if (!p.VerifyTypeIs(Value::STRING, err))
+  if (!v.VerifyTypeIs(Value::STRING, err))
     return SourceDir();
-  return ResolveRelativeDir(p, p.string_value(), err, source_root);
-}
 
-SourceDir SourceDir::ResolveRelativeDir(
-    const Value& blame_but_dont_use,
-    const base::StringPiece& str,
-    Err* err,
-    const base::StringPiece& source_root) const {
-  SourceDir ret;
-
-  if (str.empty()) {
-    *err = Err(blame_but_dont_use, "Empty directory path.",
-               "You can't use empty strings as directories. "
-               "That's just wrong.");
-    return ret;
-  }
-
-  if (str.size() >= 2 && str[0] == '/' && str[1] == '/') {
-    // Source-relative.
-    ret.value_.assign(str.data(), str.size());
-    if (!EndsWithSlash(ret.value_))
-      ret.value_.push_back('/');
-    NormalizePath(&ret.value_, source_root);
-    return ret;
-  } else if (IsPathAbsolute(str)) {
-    if (source_root.empty() ||
-        !MakeAbsolutePathRelativeIfPossible(source_root, str, &ret.value_)) {
-#if defined(OS_WIN)
-      if (str[0] != '/')  // See the file case for why we do this check.
-        ret.value_ = "/";
-#endif
-      ret.value_.append(str.data(), str.size());
-    }
-    NormalizePath(&ret.value_);
-    if (!EndsWithSlash(ret.value_))
-      ret.value_.push_back('/');
-    return ret;
-  }
-
-  if (!source_root.empty()) {
-    std::string absolute =
-        FilePathToUTF8(Resolve(UTF8ToFilePath(source_root)).AppendASCII(
-            str.as_string()).value());
-    NormalizePath(&absolute);
-    if (!MakeAbsolutePathRelativeIfPossible(source_root, absolute,
-                                            &ret.value_)) {
-#if defined(OS_WIN)
-      if (absolute[0] != '/')  // See the file case for why we do this check.
-        ret.value_ = "/";
-#endif
-      ret.value_.append(absolute.data(), absolute.size());
-    }
-    if (!EndsWithSlash(ret.value_))
-      ret.value_.push_back('/');
-    return ret;
-  }
-
-  ret.value_.reserve(value_.size() + str.size());
-  ret.value_.assign(value_);
-  ret.value_.append(str.data(), str.size());
-
-  NormalizePath(&ret.value_);
-  if (!EndsWithSlash(ret.value_))
-    ret.value_.push_back('/');
-  AssertValueSourceDirString(ret.value_);
-
-  return ret;
+  return ResolveRelativeDir<std::string>(v, v.string_value(), err, source_root);
 }
 
 base::FilePath SourceDir::Resolve(const base::FilePath& source_root) const {
-  if (is_null())
-    return base::FilePath();
-
-  std::string converted;
-  if (is_system_absolute()) {
-    if (value_.size() > 2 && value_[2] == ':') {
-      // Windows path, strip the leading slash.
-      converted.assign(&value_[1], value_.size() - 1);
-    } else {
-      converted.assign(value_);
-    }
-    return base::FilePath(UTF8ToFilePath(converted));
-  }
-
-  // String the double-leading slash for source-relative paths.
-  converted.assign(&value_[2], value_.size() - 2);
-  return source_root.Append(UTF8ToFilePath(converted))
-      .NormalizePathSeparatorsTo('/');
+  return ResolvePath(value_, false, source_root);
 }
 
 void SourceDir::SwapValue(std::string* v) {
   value_.swap(*v);
   AssertValueSourceDirString(value_);
 }
+
+// Explicit template instantiation
+template std::string SourceDir::ResolveRelativeAs(
+    bool as_file,
+    const Value& blame_input_value,
+    const std::string& input_value,
+    Err* err,
+    const base::StringPiece& source_root) const;
+
+template std::string SourceDir::ResolveRelativeAs(
+    bool as_file,
+    const Value& blame_input_value,
+    const base::StringPiece& input_value,
+    Err* err,
+    const base::StringPiece& source_root) const;
diff --git a/tools/gn/source_dir.h b/tools/gn/source_dir.h
index 422fa89..142285c 100644
--- a/tools/gn/source_dir.h
+++ b/tools/gn/source_dir.h
@@ -37,28 +37,57 @@
   SourceDir(SwapIn, std::string* s);
   ~SourceDir();
 
-  // Resolves a file or dir name relative to this source directory. Will return
-  // an empty SourceDir/File on error and set the give *err pointer (required).
-  // Empty input is always an error.
+  // Resolves a file or dir name (based on as_file parameter) relative
+  // to this source directory. Will return an empty string on error
+  // and set the give *err pointer (required). Empty input is always an error.
+  //
+  // Passed non null v_value will be used to resolve path (in cases where
+  // a substring has been extracted from the value, as with label resolution).
+  // In this use case parameter v is used to generate proper error.
   //
   // If source_root is supplied, these functions will additionally handle the
   // case where the input is a system-absolute but still inside the source
   // tree. This is the case for some external tools.
+  std::string ResolveRelativeAs(
+      bool as_file,
+      const Value& v,
+      Err* err,
+      const base::StringPiece& source_root = base::StringPiece(),
+      const std::string* v_value = nullptr) const;
+
+  // Like ResolveRelativeAs above, but allows to produce result
+  // without overhead for string conversion (on input value).
+  template <typename StringType>
+  std::string ResolveRelativeAs(
+      bool as_file,
+      const Value& blame_input_value,
+      const StringType& input_value,
+      Err* err,
+      const base::StringPiece& source_root = base::StringPiece()) const;
+
+  // Wrapper for ResolveRelativeAs.
   SourceFile ResolveRelativeFile(
       const Value& p,
       Err* err,
       const base::StringPiece& source_root = base::StringPiece()) const;
-  SourceDir ResolveRelativeDir(
-      const Value& p,
-      Err* err,
-      const base::StringPiece& source_root = base::StringPiece()) const;
 
-  // Like ResolveRelativeDir but takes a separate value (which gets blamed)
-  // and string to use (in cases where a substring has been extracted from the
-  // value, as with label resolution).
+  // Wrapper for ResolveRelativeAs.
+  template <typename StringType>
   SourceDir ResolveRelativeDir(
-      const Value& blame_but_dont_use,
-      const base::StringPiece& p,
+      const Value& blame_input_value,
+      const StringType& input_value,
+      Err* err,
+      const base::StringPiece& source_root = base::StringPiece()) const {
+    SourceDir ret;
+    ret.value_ = ResolveRelativeAs<StringType>(false, blame_input_value,
+                                               input_value, err, source_root);
+    return ret;
+  }
+
+  // Wrapper for ResolveRelativeDir where input_value equals to
+  // v.string_value().
+  SourceDir ResolveRelativeDir(
+      const Value& v,
       Err* err,
       const base::StringPiece& source_root = base::StringPiece()) const;
 
diff --git a/tools/gn/source_file.cc b/tools/gn/source_file.cc
index b28c3ac..befc5a5 100644
--- a/tools/gn/source_file.cc
+++ b/tools/gn/source_file.cc
@@ -61,23 +61,5 @@
 }
 
 base::FilePath SourceFile::Resolve(const base::FilePath& source_root) const {
-  if (is_null())
-    return base::FilePath();
-
-  std::string converted;
-  if (is_system_absolute()) {
-    if (value_.size() > 2 && value_[2] == ':') {
-      // Windows path, strip the leading slash.
-      converted.assign(&value_[1], value_.size() - 1);
-    } else {
-      converted.assign(value_);
-    }
-    return base::FilePath(UTF8ToFilePath(converted));
-  }
-
-  converted.assign(&value_[2], value_.size() - 2);
-  if (source_root.empty())
-    return UTF8ToFilePath(converted).NormalizePathSeparatorsTo('/');
-  return source_root.Append(UTF8ToFilePath(converted))
-      .NormalizePathSeparatorsTo('/');
+  return ResolvePath(value_, true, source_root);
 }
diff --git a/tools/gn/target_generator.cc b/tools/gn/target_generator.cc
index bbc9793..ab85729 100644
--- a/tools/gn/target_generator.cc
+++ b/tools/gn/target_generator.cc
@@ -222,24 +222,18 @@
     const Value& input = input_list[i];
     if (!input.VerifyTypeIs(Value::STRING, err_))
       return false;
-    const std::string& input_str = input.string_value();
+    const std::string input_str = input.string_value();
 
     // Treat each input as either a file or a directory, depending on the
     // last character.
-    if (!input_str.empty() && input_str[input_str.size() - 1] == '/') {
-      // Resolve as directory.
-      SourceDir resolved =
-          dir.ResolveRelativeDir(input, input_str, err_, root_path);
-      if (err_->has_error())
-        return false;
-      output_list.push_back(resolved.value());
-    } else {
-      // Resolve as file.
-      SourceFile resolved = dir.ResolveRelativeFile(input, err_, root_path);
-      if (err_->has_error())
-        return false;
-      output_list.push_back(resolved.value());
-    }
+    bool as_dir = !input_str.empty() && input_str[input_str.size() - 1] == '/';
+
+    std::string resolved =
+        dir.ResolveRelativeAs(!as_dir, input, err_, root_path, &input_str);
+    if (err_->has_error())
+      return false;
+
+    output_list.push_back(resolved);
   }
   return true;
 }