Enhance GN diagnostic tools

Unifies the existing desc, refs, and check commands to take an output directory rather than creating a build in out/Default. This matches the other commands.

Separates out the label pattern matching code from the visibility component into a separate object so it can be used in commands to match more than one label. Adds support for toolchains in these patterns (this wasn't so necessary for visibility, but is more useful for these other commands). The old pattern code is now used only for the sources filter. This patch moves the documentation for that directly on the sources assignment filter help.

Enhances "gn check" to take a label or label pattern of targets to check. This is especially necessary now with so many errors, one can focus on one small part of the codebase.

Enhances "gn refs" to work like "gn desc deps" but in reverse. It can print reverse dependency trees, or find all targets that depend on a given target or targets. For example, "find everything that depends on anything in //mojo". It lost the ability to find configs or unresolved dependencies. We could potentially add these back, but they're complicated to implement and less useful.

Adds a "gn ls" command to list targets.

BUG=343726

Review URL: https://codereview.chromium.org/500423003

Cr-Commit-Position: refs/heads/master@{#292658}

22 files changed, 1021 insertions, 459 deletions

diff --git a/tools/gn/BUILD.gn b/tools/gn/BUILD.gn
index 1e9391f..bcea3db 100644
--- a/tools/gn/BUILD.gn
+++ b/tools/gn/BUILD.gn
@@ -27,6 +27,7 @@ static_library("gn_lib") {
     "command_desc.cc",
     "command_gen.cc",
     "command_help.cc",
+    "command_ls.cc",
     "command_refs.cc",
     "commands.cc",
     "commands.h",
@@ -78,6 +79,8 @@ static_library("gn_lib") {
     "item.h",
     "label.cc",
     "label.h",
+    "label_pattern.cc",
+    "label_pattern.h",
     "label_ptr.h",
     "loader.cc",
     "loader.h",
@@ -220,6 +223,7 @@ test("gn_unittests") {
     "functions_unittest.cc",
     "header_checker_unittest.cc",
     "input_conversion_unittest.cc",
+    "label_pattern_unittest.cc",
     "label_unittest.cc",
     "loader_unittest.cc",
     "ninja_action_target_writer_unittest.cc",
diff --git a/tools/gn/command_check.cc b/tools/gn/command_check.cc
index 3546b7c..74ffb42 100644
--- a/tools/gn/command_check.cc
+++ b/tools/gn/command_check.cc
@@ -3,8 +3,10 @@
 // found in the LICENSE file.
 
 #include "tools/gn/commands.h"
+#include "tools/gn/header_checker.h"
 #include "tools/gn/setup.h"
 #include "tools/gn/standard_out.h"
+#include "tools/gn/trace.h"
 
 namespace commands {
 
@@ -12,28 +14,81 @@ const char kCheck[] = "check";
 const char kCheck_HelpShort[] =
     "check: Check header dependencies.";
 const char kCheck_Help[] =
-    "gn check: Check header dependencies.\n"
+    "gn check <out_dir> [<target label>]\n"
     "\n"
     "  \"gn check\" is the same thing as \"gn gen\" with the \"--check\" flag\n"
     "  except that this command does not write out any build files. It's\n"
     "  intended to be an easy way to manually trigger include file checking.\n"
     "\n"
-    "  See \"gn help\" for the common command-line switches.\n";
+    "  The <label_pattern> can take exact labels or patterns that match more\n"
+    "  than one (although not general regular expressions). If specified,\n"
+    "  only those matching targets will be checked.\n"
+    "  See \"gn help label_pattern\" for details.\n"
+    "\n"
+    "  See \"gn help\" for the common command-line switches.\n"
+    "\n"
+    "Examples\n"
+    "\n"
+    "  gn check out/Debug\n"
+    "      Check everything.\n"
+    "\n"
+    "  gn check out/Default //foo:bar\n"
+    "      Check only the files in the //foo:bar target.\n"
+    "\n"
+    "  gn check out/Default \"//foo/*\n"
+    "      Check only the files in targets in the //foo directory tree.\n";
 
 int RunCheck(const std::vector<std::string>& args) {
+  if (args.size() != 1 && args.size() != 2) {
+    Err(Location(), "You're holding it wrong.",
+        "Usage: \"gn check <out_dir> [<target_label>]\"").PrintToStdout();
+    return 1;
+  }
+
   // Deliberately leaked to avoid expensive process teardown.
   Setup* setup = new Setup();
-  // TODO(brettw) bug 343726: Use a temporary directory instead of this
-  // default one to avoid messing up any build that's in there.
-  if (!setup->DoSetup("//out/Default"))
+  if (!setup->DoSetup(args[0]))
     return 1;
-  setup->set_check_public_headers(true);
-
   if (!setup->Run())
     return 1;
 
+  std::vector<const Target*> targets_to_check;
+  if (args.size() == 2) {
+    // Compute the target to check (empty means everything).
+    if (!ResolveTargetsFromCommandLinePattern(setup, args[1], false,
+                                              &targets_to_check))
+      return 1;
+    if (targets_to_check.size() == 0) {
+      OutputString("No matching targets.\n");
+      return 1;
+    }
+  }
+
+  if (!CheckPublicHeaders(&setup->build_settings(),
+                          setup->builder()->GetAllResolvedTargets(),
+                          targets_to_check))
+    return 1;
+
   OutputString("Header dependency check OK\n", DECORATION_GREEN);
   return 0;
 }
 
+bool CheckPublicHeaders(const BuildSettings* build_settings,
+                        const std::vector<const Target*>& all_targets,
+                        const std::vector<const Target*>& to_check) {
+  ScopedTrace trace(TraceItem::TRACE_CHECK_HEADERS, "Check headers");
+
+  scoped_refptr<HeaderChecker> header_checker(
+      new HeaderChecker(build_settings, all_targets));
+
+  std::vector<Err> header_errors;
+  header_checker->Run(to_check, &header_errors);
+  for (size_t i = 0; i < header_errors.size(); i++) {
+    if (i > 0)
+      OutputString("___________________\n", DECORATION_YELLOW);
+    header_errors[i].PrintToStdout();
+  }
+  return header_errors.empty();
+}
+
 }  // namespace commands
diff --git a/tools/gn/command_desc.cc b/tools/gn/command_desc.cc
index f89ea41..f17928a 100644
--- a/tools/gn/command_desc.cc
+++ b/tools/gn/command_desc.cc
@@ -435,8 +435,12 @@ const char kDesc[] = "desc";
 const char kDesc_HelpShort[] =
     "desc: Show lots of insightful information about a target.";
 const char kDesc_Help[] =
-    "gn desc <target label> [<what to show>] [--blame] [--all | --tree]\n"
-    "  Displays information about a given labeled target.\n"
+    "gn desc <out_dir> <target label> [<what to show>]\n"
+    "        [--blame] [--all | --tree]\n"
+    "\n"
+    "  Displays information about a given labeled target for the given build.\n"
+    "  The build parameters will be taken for the build in the given\n"
+    "  <out_dir>.\n"
     "\n"
     "Possibilities for <what to show>:\n"
     "  (If unspecified an overall summary will be displayed.)\n"
@@ -510,14 +514,14 @@ const char kDesc_Help[] =
     "  mean the same thing).\n"
     "\n"
     "Examples:\n"
-    "  gn desc //base:base\n"
+    "  gn desc out/Debug //base:base\n"
     "      Summarizes the given target.\n"
     "\n"
-    "  gn desc :base_unittests deps --tree\n"
+    "  gn desc out/Foo :base_unittests deps --tree\n"
     "      Shows a dependency tree of the \"base_unittests\" project in\n"
     "      the current directory.\n"
     "\n"
-    "  gn desc //base defines --blame\n"
+    "  gn desc out/Debug //base defines --blame\n"
     "      Shows defines set for the //base:base target, annotated by where\n"
     "      each one was set from.\n";
 
@@ -525,22 +529,30 @@ const char kDesc_Help[] =
     OutputRecursiveTargetConfig<type>(target, #name, &ConfigValues::name);
 
 int RunDesc(const std::vector<std::string>& args) {
-  if (args.size() != 1 && args.size() != 2) {
+  if (args.size() != 2 && args.size() != 3) {
     Err(Location(), "You're holding it wrong.",
-        "Usage: \"gn desc <target_name> <what to display>\"").PrintToStdout();
+        "Usage: \"gn desc <out_dir> <target_name> [<what to display>]\"")
+        .PrintToStdout();
     return 1;
   }
 
-  const Target* target = GetTargetForDesc(args);
+  // Deliberately leaked to avoid expensive process teardown.
+  Setup* setup = new Setup;
+  if (!setup->DoSetup(args[0]))
+    return 1;
+  if (!setup->Run())
+    return 1;
+
+  const Target* target = ResolveTargetFromCommandLineString(setup, args[1]);
   if (!target)
     return 1;
 
 #define CONFIG_VALUE_HANDLER(name, type) \
     } else if (what == #name) { OUTPUT_CONFIG_VALUE(name, type)
 
-  if (args.size() == 2) {
+  if (args.size() == 3) {
     // User specified one thing to display.
-    const std::string& what = args[1];
+    const std::string& what = args[2];
     if (what == "configs") {
       PrintConfigs(target, false);
     } else if (what == "direct_dependent_configs") {
diff --git a/tools/gn/command_help.cc b/tools/gn/command_help.cc
index f371cf7..ef5f70b 100644
--- a/tools/gn/command_help.cc
+++ b/tools/gn/command_help.cc
@@ -10,7 +10,7 @@
 #include "tools/gn/err.h"
 #include "tools/gn/functions.h"
 #include "tools/gn/input_conversion.h"
-#include "tools/gn/pattern.h"
+#include "tools/gn/label_pattern.h"
 #include "tools/gn/setup.h"
 #include "tools/gn/standard_out.h"
 #include "tools/gn/substitution_writer.h"
@@ -93,9 +93,9 @@ void PrintToplevelHelp() {
   OutputString("\nOther help topics:\n");
   PrintShortHelp("buildargs: How build arguments work.");
   PrintShortHelp("dotfile: Info about the toplevel .gn file.");
+  PrintShortHelp("label_pattern: Matching more than one label.");
   PrintShortHelp(
       "input_conversion: Processing input from exec_script and read_file.");
-  PrintShortHelp("patterns: How to use patterns.");
   PrintShortHelp("source_expansion: Map sources to outputs for scripts.");
 }
 
@@ -166,8 +166,8 @@ int RunHelp(const std::vector<std::string>& args) {
     PrintLongHelp(kInputConversion_Help);
     return 0;
   }
-  if (args[0] == "patterns") {
-    PrintLongHelp(kPattern_Help);
+  if (args[0] == "label_pattern") {
+    PrintLongHelp(kLabelPattern_Help);
     return 0;
   }
   if (args[0] == "source_expansion") {
diff --git a/tools/gn/command_ls.cc b/tools/gn/command_ls.cc
new file mode 100644
index 0000000..1586f3d
--- /dev/null
+++ b/tools/gn/command_ls.cc
@@ -0,0 +1,121 @@
+// Copyright 2014 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 <algorithm>
+#include <set>
+
+#include "base/command_line.h"
+#include "tools/gn/commands.h"
+#include "tools/gn/label_pattern.h"
+#include "tools/gn/setup.h"
+#include "tools/gn/standard_out.h"
+#include "tools/gn/target.h"
+
+namespace commands {
+
+const char kLs[] = "ls";
+const char kLs_HelpShort[] =
+    "ls: List matching targets.";
+const char kLs_Help[] =
+    "gn ls <build dir> [<label_pattern>] [--out] [--all-toolchains]\n"
+    "\n"
+    "  Lists all targets matching the given pattern for the given builn\n"
+    "  directory. By default, only targets in the default toolchain will\n"
+    "  be matched unless a toolchain is explicitly supplied.\n"
+    "\n"
+    "  If the label pattern is unspecified, list all targets. The label\n"
+    "  pattern is not a general regular expression (see\n"
+    "  \"gn help label_pattern\"). If you need more complex expressions,\n"
+    "  pipe the result through grep.\n"
+    "\n"
+    "  --out\n"
+    "      Lists the results as the files generated by the matching targets.\n"
+    "      These files will be relative to the build directory such that\n"
+    "      they can be specified on Ninja's command line as a file to build.\n"
+    "\n"
+    "  --all-toolchains\n"
+    "      Matches all toolchains. If the label pattern does not specify an\n"
+    "      explicit toolchain, labels from all toolchains will be matched.\n"
+    "\n"
+    "Examples\n"
+    "\n"
+    "  gn ls out/Debug\n"
+    "      Lists all targets in the default toolchain.\n"
+    "\n"
+    "  gn ls out/Debug \"//base/*\"\n"
+    "      Lists all targets in the directory base and all subdirectories.\n"
+    "\n"
+    "  gn ls out/Debug \"//base:*\"\n"
+    "      Lists all targets defined in //base/BUILD.gn.\n"
+    "\n"
+    "  gn ls out/Debug //base --out\n"
+    "      Lists the build output file for //base:base\n"
+    "\n"
+    "  gn ls out/Debug \"//base/*\" --out | xargs ninja -C out/Debug\n"
+    "      Builds all targets in //base and all subdirectories.\n"
+    "\n"
+    "  gn ls out/Debug //base --all-toolchains\n"
+    "      Lists all variants of the target //base:base (it may be referenced\n"
+    "      in multiple toolchains).\n";
+
+int RunLs(const std::vector<std::string>& args) {
+  if (args.size() != 1 && args.size() != 2) {
+    Err(Location(), "You're holding it wrong.",
+        "Usage: \"gn ls <build dir> [<label_pattern>]\"").PrintToStdout();
+    return 1;
+  }
+
+  Setup* setup = new Setup;
+  if (!setup->DoSetup(args[0]) || !setup->Run())
+    return 1;
+
+  const CommandLine* cmdline = CommandLine::ForCurrentProcess();
+  bool all_toolchains = cmdline->HasSwitch("all-toolchains");
+
+  // Find matching targets.
+  std::vector<const Target*> matches;
+  if (args.size() == 2) {
+    // Given a pattern, match it.
+    if (!ResolveTargetsFromCommandLinePattern(setup, args[1], all_toolchains,
+                                              &matches))
+      return 1;
+  } else if (all_toolchains) {
+    // List all resolved targets.
+    matches = setup->builder()->GetAllResolvedTargets();
+  } else {
+    // List all resolved targets in the default toolchain.
+    std::vector<const Target*> all_targets =
+        setup->builder()->GetAllResolvedTargets();
+    for (size_t i = 0; i < all_targets.size(); i++) {
+      if (all_targets[i]->settings()->is_default())
+        matches.push_back(all_targets[i]);
+    }
+  }
+
+  if (cmdline->HasSwitch("out")) {
+    // List results as build files.
+    for (size_t i = 0; i < matches.size(); i++) {
+      OutputString(matches[i]->dependency_output_file().value());
+      OutputString("\n");
+    }
+  } else {
+    // List results as sorted labels.
+    std::vector<Label> sorted_matches;
+    for (size_t i = 0; i < matches.size(); i++)
+      sorted_matches.push_back(matches[i]->label());
+    std::sort(sorted_matches.begin(), sorted_matches.end());
+
+    Label default_tc_label = setup->loader()->default_toolchain_label();
+    for (size_t i = 0; i < sorted_matches.size(); i++) {
+      // Print toolchain only for ones not in the default toolchain.
+      OutputString(sorted_matches[i].GetUserVisibleName(
+          sorted_matches[i].GetToolchainLabel() != default_tc_label));
+      OutputString("\n");
+    }
+  }
+
+  return 0;
+}
+
+}  // namespace commands
diff --git a/tools/gn/command_refs.cc b/tools/gn/command_refs.cc
index e54d1f3..d00149f 100644
--- a/tools/gn/command_refs.cc
+++ b/tools/gn/command_refs.cc
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <map>
 #include <set>
 
 #include "base/command_line.h"
@@ -9,7 +10,6 @@
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/input_file.h"
 #include "tools/gn/item.h"
-#include "tools/gn/pattern.h"
 #include "tools/gn/setup.h"
 #include "tools/gn/standard_out.h"
 #include "tools/gn/target.h"
@@ -18,12 +18,142 @@ namespace commands {
 
 namespace {
 
-// Returns the file path generating this record.
-base::FilePath FilePathForRecord(const BuilderRecord* record) {
-  if (!record->item())
-    return base::FilePath(FILE_PATH_LITERAL("=UNRESOLVED DEPENDENCY="));
-  return record->item()->defined_from()->GetRange().begin().file()
-      ->physical_name();
+typedef std::set<const Target*> TargetSet;
+typedef std::vector<const Target*> TargetVector;
+
+// Maps targets to the list of targets that depend on them.
+typedef std::multimap<const Target*, const Target*> DepMap;
+
+// Populates the reverse dependency map for the targets in the Setup.
+void FillDepMap(Setup* setup, DepMap* dep_map) {
+  std::vector<const Target*> targets =
+      setup->builder()->GetAllResolvedTargets();
+
+  for (size_t target_i = 0; target_i < targets.size(); target_i++) {
+    const Target* target = targets[target_i];
+
+    // Add all deps to the map.
+    const LabelTargetVector& deps = target->deps();
+    for (size_t dep_i = 0; dep_i < deps.size(); dep_i++)
+      dep_map->insert(std::make_pair(deps[dep_i].ptr, target));
+
+    // Include data deps as well.
+    const LabelTargetVector& datadeps = target->datadeps();
+    for (size_t dep_i = 0; dep_i < datadeps.size(); dep_i++)
+      dep_map->insert(std::make_pair(datadeps[dep_i].ptr, target));
+  }
+}
+
+// Returns the file path generating this item.
+base::FilePath FilePathForItem(const Item* item) {
+  return item->defined_from()->GetRange().begin().file()->physical_name();
+}
+
+// Prints the targets which are the result of a query. This list is sorted
+// and, if as_files is set, the unique filenames matching those targets will
+// be used.
+void OutputResultSet(const TargetSet& results, bool as_files) {
+  if (results.empty())
+    return;
+
+  if (as_files) {
+    // Output the set of unique source files.
+    std::set<std::string> unique_files;
+    for (TargetSet::const_iterator iter = results.begin();
+         iter != results.end(); ++iter)
+      unique_files.insert(FilePathToUTF8(FilePathForItem(*iter)));
+
+    for (std::set<std::string>::const_iterator iter = unique_files.begin();
+         iter != unique_files.end(); ++iter) {
+      OutputString(*iter + "\n");
+    }
+  } else {
+    // Output sorted and uniquified list of labels. The set will sort the
+    // labels.
+    std::set<Label> unique_labels;
+    for (TargetSet::const_iterator iter = results.begin();
+         iter != results.end(); ++iter)
+      unique_labels.insert((*iter)->label());
+
+    // Grab the label of the default toolchain from a random target.
+    Label default_tc_label =
+        (*results.begin())->settings()->default_toolchain_label();
+
+    for (std::set<Label>::const_iterator iter = unique_labels.begin();
+         iter != unique_labels.end(); ++iter) {
+      // Print toolchain only for ones not in the default toolchain.
+      OutputString(iter->GetUserVisibleName(
+          iter->GetToolchainLabel() != default_tc_label));
+      OutputString("\n");
+    }
+  }
+}
+
+// Prints refs of the given target (not the target itself). If the set is
+// non-null, new targets encountered will be added to the set, and if a ref is
+// in the set already, it will not be recused into. When the set is null, all
+// refs will be printed.
+void RecursivePrintTree(const DepMap& dep_map,
+                        const Target* target,
+                        TargetSet* seen_targets,
+                        int indent_level) {
+  std::string indent(indent_level * 2, ' ');
+
+  DepMap::const_iterator dep_begin = dep_map.lower_bound(target);
+  DepMap::const_iterator dep_end = dep_map.upper_bound(target);
+  for (DepMap::const_iterator cur_dep = dep_begin;
+       cur_dep != dep_end; cur_dep++) {
+    const Target* cur_target = cur_dep->second;
+
+    // Only print the toolchain for non-default-toolchain targets.
+    OutputString(indent + cur_target->label().GetUserVisibleName(
+        !cur_target->settings()->is_default()));
+
+    bool print_children = true;
+    if (seen_targets) {
+      if (seen_targets->find(cur_target) == seen_targets->end()) {
+        // New target, mark it visited.
+        seen_targets->insert(cur_target);
+      } else {
+        // Already seen.
+        print_children = false;
+        // Only print "..." if something is actually elided, which means that
+        // the current target has children.
+        if (dep_map.lower_bound(cur_target) != dep_map.upper_bound(cur_target))
+          OutputString("...");
+      }
+    }
+
+    OutputString("\n");
+    if (print_children)
+      RecursivePrintTree(dep_map, cur_target, seen_targets, indent_level + 1);
+  }
+}
+
+void RecursiveCollectChildRefs(const DepMap& dep_map,
+                               const Target* target,
+                               TargetSet* results);
+
+// Recursively finds all targets that reference the given one, and additionally
+// adds the current one to the list.
+void RecursiveCollectRefs(const DepMap& dep_map,
+                          const Target* target,
+                          TargetSet* results) {
+  if (results->find(target) != results->end())
+    return;  // Already found this target.
+  results->insert(target);
+  RecursiveCollectChildRefs(dep_map, target, results);
+}
+
+// Recursively finds all targets that reference the given one.
+void RecursiveCollectChildRefs(const DepMap& dep_map,
+                               const Target* target,
+                               TargetSet* results) {
+  DepMap::const_iterator dep_begin = dep_map.lower_bound(target);
+  DepMap::const_iterator dep_end = dep_map.upper_bound(target);
+  for (DepMap::const_iterator cur_dep = dep_begin;
+       cur_dep != dep_end; cur_dep++)
+    RecursiveCollectRefs(dep_map, cur_dep->second, results);
 }
 
 }  // namespace
@@ -32,95 +162,130 @@ const char kRefs[] = "refs";
 const char kRefs_HelpShort[] =
     "refs: Find stuff referencing a target, directory, or config.";
 const char kRefs_Help[] =
-    "gn refs <label_pattern> [--files]\n"
+    "gn refs <build_dir> <label_pattern> [--files] [--tree] [--all]\n"
+    "        [--all-toolchains]\n"
     "\n"
-    "  Finds code referencing a given label. The label can be a\n"
-    "  target or config name. Unlike most other commands, unresolved\n"
-    "  dependencies will be tolerated. This allows you to use this command\n"
-    "  to find references to targets you're in the process of moving.\n"
+    "  Finds which targets reference a given target or targets (reverse\n"
+    "  dependencies).\n"
     "\n"
-    "  By default, the mapping from source item to dest item (where the\n"
-    "  pattern matches the dest item). See \"gn help pattern\" for\n"
-    "  information on pattern-matching rules.\n"
+    "  The <label_pattern> can take exact labels or patterns that match more\n"
+    "  than one (although not general regular expressions).\n"
+    "  See \"gn help label_pattern\" for details.\n"
+    "\n"
+    "  --all\n"
+    "      When used without --tree, will recurse and display all unique\n"
+    "      dependencies of the given targets. When used with --tree, turns\n"
+    "      off eliding to show a complete tree.\n"
+    "\n"
+    "  --all-toolchains\n"
+    "      Make the label pattern matche all toolchains. If the label pattern\n"
+    "      does not specify an explicit toolchain, labels from all toolchains\n"
+    "      will be matched (normally only the default toolchain is matched\n"
+    "      when no toolchain is specified).\n"
     "\n"
-    "Option:\n"
     "  --files\n"
     "      Output unique filenames referencing a matched target or config.\n"
+    "      These will be relative to the source root directory such that they\n"
+    "      are suitable for piping to other commands.\n"
+    "\n"
+    "  --tree\n"
+    "      Outputs a reverse dependency tree from the given target. The label\n"
+    "      pattern must match one target exactly. Duplicates will be elided.\n"
+    "      Combine with --all to see a full dependency tree.\n"
     "\n"
-    "Examples:\n"
-    "  gn refs \"//tools/gn/*\"\n"
-    "      Find all targets depending on any target or config in the\n"
-    "      \"tools/gn\" directory.\n"
+    "Examples\n"
     "\n"
-    "  gn refs //tools/gn:gn\n"
+    "  gn refs out/Debug //tools/gn:gn\n"
     "      Find all targets depending on the given exact target name.\n"
     "\n"
-    "  gn refs \"*gtk*\" --files\n"
-    "      Find all unique buildfiles with a dependency on a target that has\n"
-    "      the substring \"gtk\" in the name.\n";
+    "  gn refs out/Debug //base:i18n --files | xargs gvim\n"
+    "      Edit all files containing references to //base:i18n\n"
+    "\n"
+    "  gn refs out/Debug //base --all\n"
+    "      List all targets depending directly or indirectly on //base:base.\n"
+    "\n"
+    "  gn refs out/Debug \"//base/*\"\n"
+    "      List all targets depending directly on any target in //base or\n"
+    "      its subdirectories.\n"
+    "\n"
+    "  gn refs out/Debug \"//base:*\"\n"
+    "      List all targets depending directly on any target in\n"
+    "      //base/BUILD.gn.\n"
+    "\n"
+    "  gn refs out/Debug //base --tree\n"
+    "      Print a reverse dependency tree of //base:base\n";
 
 int RunRefs(const std::vector<std::string>& args) {
-  if (args.size() != 1 && args.size() != 2) {
+  if (args.size() != 2) {
     Err(Location(), "You're holding it wrong.",
-        "Usage: \"gn refs <label_pattern>\"").PrintToStdout();
+        "Usage: \"gn refs <build_dir> <label_pattern>\"").PrintToStdout();
     return 1;
   }
 
-  Pattern pattern(args[0]);
-  // Check for common errors on input.
-  if (args[0].find('*') == std::string::npos) {
-    // We need to begin with a "//" and have a colon if there's no "*" or it
-    // will be impossible to match anything.
-    if (args[0].size() < 2 ||
-        (args[0][0] != '/' && args[0][1] != '/') ||
-        args[0].find(':') == std::string::npos) {
-      OutputString("Assuming \"*" + args[0] +
-                       "*\". See \"gn help refs\" for more information.\n",
-                   DECORATION_YELLOW);
-      pattern = Pattern("*" + args[0] + "*");
-    }
-  }
+  const CommandLine* cmdline = CommandLine::ForCurrentProcess();
+  bool tree = cmdline->HasSwitch("tree");
+  bool all = cmdline->HasSwitch("all");
+  bool all_toolchains = cmdline->HasSwitch("all-toolchains");
+  bool files = cmdline->HasSwitch("files");
 
   Setup* setup = new Setup;
   setup->set_check_for_bad_items(false);
-  // TODO(brettw) bug 343726: Use a temporary directory instead of this
-  // default one to avoid messing up any build that's in there.
-  if (!setup->DoSetup("//out/Default/") || !setup->Run())
+  if (!setup->DoSetup(args[0]) || !setup->Run())
     return 1;
 
-  std::vector<const BuilderRecord*> records = setup->builder()->GetAllRecords();
+  // Figure out the target or targets that the user is querying.
+  std::vector<const Target*> query;
+  if (!ResolveTargetsFromCommandLinePattern(setup, args[1], all_toolchains,
+                                            &query))
+    return 1;
+  if (query.empty()) {
+    OutputString("\"" + args[1] + "\" matches no targets.\n");
+    return 0;
+  }
 
-  const CommandLine* cmdline = CommandLine::ForCurrentProcess();
+  // Construct the reverse dependency tree.
+  DepMap dep_map;
+  FillDepMap(setup, &dep_map);
 
-  bool file_output = cmdline->HasSwitch("files");
-  std::set<std::string> unique_output;
-
-  for (size_t record_index = 0; record_index < records.size(); record_index++) {
-    const BuilderRecord* record = records[record_index];
-    const BuilderRecord::BuilderRecordSet& deps = record->all_deps();
-    for (BuilderRecord::BuilderRecordSet::const_iterator d = deps.begin();
-         d != deps.end(); ++d) {
-      std::string label = (*d)->label().GetUserVisibleName(false);
-      if (pattern.MatchesString(label)) {
-        // Got a match.
-        if (file_output) {
-          unique_output.insert(FilePathToUTF8(FilePathForRecord(record)));
-          break;  // Found a match for this target's file, don't need more.
-        } else {
-          // We can get dupes when there are differnet toolchains involved,
-          // so we want to send all output through the de-duper.
-          unique_output.insert(
-              record->item()->label().GetUserVisibleName(false) + " -> " +
-              label);
-        }
-      }
+  if (tree) {
+    // Output dependency tree.
+    if (files) {
+      Err(NULL, "--files option can't be used with --tree option.")
+          .PrintToStdout();
+      return 1;
+    }
+    if (query.size() != 1) {
+      Err(NULL, "Query matches more than one target.",
+          "--tree only supports a single target as input.").PrintToStdout();
+      return 1;
     }
+    if (all) {
+      // Recursively print all targets.
+      RecursivePrintTree(dep_map, query[0], NULL, 0);
+    } else {
+      // Recursively print unique targets.
+      TargetSet seen_targets;
+      RecursivePrintTree(dep_map, query[0], &seen_targets, 0);
+    }
+  } else if (all) {
+    // Output recursive dependencies, uniquified and flattened.
+    TargetSet results;
+    for (size_t query_i = 0; query_i < query.size(); query_i++)
+      RecursiveCollectChildRefs(dep_map, query[query_i], &results);
+    OutputResultSet(results, files);
+  } else {
+    // Output direct references of everything in the query.
+    TargetSet results;
+    for (size_t query_i = 0; query_i < query.size(); query_i++) {
+      DepMap::const_iterator dep_begin = dep_map.lower_bound(query[query_i]);
+      DepMap::const_iterator dep_end = dep_map.upper_bound(query[query_i]);
+      for (DepMap::const_iterator cur_dep = dep_begin;
+           cur_dep != dep_end; cur_dep++)
+        results.insert(cur_dep->second);
+    }
+    OutputResultSet(results, files);
   }
 
-  for (std::set<std::string>::iterator i = unique_output.begin();
-       i != unique_output.end(); ++i)
-    OutputString(*i + "\n");
-
   return 0;
 }
 
diff --git a/tools/gn/commands.cc b/tools/gn/commands.cc
index 09ff012..9598d49 100644
--- a/tools/gn/commands.cc
+++ b/tools/gn/commands.cc
@@ -6,6 +6,7 @@
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/item.h"
 #include "tools/gn/label.h"
+#include "tools/gn/label_pattern.h"
 #include "tools/gn/setup.h"
 #include "tools/gn/standard_out.h"
 #include "tools/gn/target.h"
@@ -39,6 +40,7 @@ const CommandInfoMap& GetCommands() {
     INSERT_COMMAND(Desc)
     INSERT_COMMAND(Gen)
     INSERT_COMMAND(Help)
+    INSERT_COMMAND(Ls)
     INSERT_COMMAND(Refs)
 
     #undef INSERT_COMMAND
@@ -46,21 +48,12 @@ const CommandInfoMap& GetCommands() {
   return info_map;
 }
 
-const Target* GetTargetForDesc(const std::vector<std::string>& args) {
-  // Deliberately leaked to avoid expensive process teardown.
-  Setup* setup = new Setup;
-  // TODO(brettw) bug 343726: Use a temporary directory instead of this
-  // default one to avoid messing up any build that's in there.
-  if (!setup->DoSetup("//out/Default/"))
-    return NULL;
-
-  // Do the actual load. This will also write out the target ninja files.
-  if (!setup->Run())
-    return NULL;
-
+const Target* ResolveTargetFromCommandLineString(
+    Setup* setup,
+    const std::string& label_string) {
   // Need to resolve the label after we know the default toolchain.
   Label default_toolchain = setup->loader()->default_toolchain_label();
-  Value arg_value(NULL, args[0]);
+  Value arg_value(NULL, label_string);
   Err err;
   Label label = Label::Resolve(SourceDirForCurrentDirectory(
                                    setup->build_settings().root_path()),
@@ -89,4 +82,41 @@ const Target* GetTargetForDesc(const std::vector<std::string>& args) {
   return target;
 }
 
+bool ResolveTargetsFromCommandLinePattern(
+    Setup* setup,
+    const std::string& label_pattern,
+    bool all_toolchains,
+    std::vector<const Target*>* matches) {
+  Value pattern_value(NULL, label_pattern);
+
+  Err err;
+  LabelPattern pattern = LabelPattern::GetPattern(
+      SourceDirForCurrentDirectory(setup->build_settings().root_path()),
+      pattern_value,
+      &err);
+  if (err.has_error()) {
+    err.PrintToStdout();
+    return false;
+  }
+
+  if (!all_toolchains) {
+    // By default a pattern with an empty toolchain will match all toolchains.
+    // IF the caller wants to default to the main toolchain only, set it
+    // explicitly.
+    if (pattern.toolchain().is_null()) {
+      // No explicit toolchain set.
+      pattern.set_toolchain(setup->loader()->default_toolchain_label());
+    }
+  }
+
+  std::vector<const Target*> all_targets =
+      setup->builder()->GetAllResolvedTargets();
+
+  for (size_t i = 0; i < all_targets.size(); i++) {
+    if (pattern.Matches(all_targets[i]->label()))
+      matches->push_back(all_targets[i]);
+  }
+  return true;
+}
+
 }  // namespace commands
diff --git a/tools/gn/commands.h b/tools/gn/commands.h
index 9b8db88..a753af3 100644
--- a/tools/gn/commands.h
+++ b/tools/gn/commands.h
@@ -11,6 +11,8 @@
 
 #include "base/strings/string_piece.h"
 
+class BuildSettings;
+class Setup;
 class Target;
 
 // Each "Run" command returns the value we should return from main().
@@ -44,6 +46,11 @@ extern const char kHelp_HelpShort[];
 extern const char kHelp_Help[];
 int RunHelp(const std::vector<std::string>& args);
 
+extern const char kLs[];
+extern const char kLs_HelpShort[];
+extern const char kLs_Help[];
+int RunLs(const std::vector<std::string>& args);
+
 extern const char kRefs[];
 extern const char kRefs_HelpShort[];
 extern const char kRefs_Help[];
@@ -68,14 +75,35 @@ const CommandInfoMap& GetCommands();
 
 // Helper functions for some commands ------------------------------------------
 
-// Runs a build for the given command line, returning the target identified by
-// the first non-switch command line parameter.
+// Given a setup that has already been run and some command-line input,
+// resolves that input as a target label and returns the corresponding target.
+// On failure, returns null and prints the error to the standard output.
+const Target* ResolveTargetFromCommandLineString(
+    Setup* setup,
+    const std::string& label_string);
+
+// Like above but the input string can be a pattern that matches multiple
+// targets. If the input does not parse as a pattern, prints and error and
+// returns false. If the pattern is valid, fills the vector (which might be
+// empty if there are no matches) and returns true.
 //
-// Note that a lot of memory is leaked to avoid proper teardown under the
-// assumption that you will only run this once and exit.
+// If all_tolchains is false, a pattern with an unspecified toolchain will
+// match the default toolchain only. If true, all toolchains will be matched.
+bool ResolveTargetsFromCommandLinePattern(
+    Setup* setup,
+    const std::string& label_pattern,
+    bool all_toolchains,
+    std::vector<const Target*>* matches);
+
+// Runs the header checker. All targets in the build should be given in
+// all_targets, and the specific targets to check should be in to_check. If
+// to_check is empty, all targets will be checked.
 //
-// On failure, prints an error message and returns NULL.
-const Target* GetTargetForDesc(const std::vector<std::string>& args);
+// On success, returns true. If the check fails, the error(s) will be printed
+// to stdout and false will be returned.
+bool CheckPublicHeaders(const BuildSettings* build_settings,
+                        const std::vector<const Target*>& all_targets,
+                        const std::vector<const Target*>& to_check);
 
 }  // namespace commands
 
diff --git a/tools/gn/functions.cc b/tools/gn/functions.cc
index 96b985d..faa7437 100644
--- a/tools/gn/functions.cc
+++ b/tools/gn/functions.cc
@@ -489,8 +489,6 @@ const char kSetSourcesAssignmentFilter_Help[] =
     "  example, you may want to filter out all \"*_win.cc\" files on non-\n"
     "  Windows platforms.\n"
     "\n"
-    "  See \"gn help patterns\" for specifics on patterns.\n"
-    "\n"
     "  Typically this will be called once in the master build config script\n"
     "  to set up the filter for the current platform. Subsequent calls will\n"
     "  overwrite the previous values.\n"
@@ -499,9 +497,45 @@ const char kSetSourcesAssignmentFilter_Help[] =
     "  be filtered out, call set_sources_assignment_filter([]) to clear the\n"
     "  list of filters. This will apply until the current scope exits\n"
     "\n"
-    "Example:\n"
+    "How to use patterns\n"
+    "\n"
+    "  File patterns are VERY limited regular expressions. They must match\n"
+    "  the entire input string to be counted as a match. In regular\n"
+    "  expression parlance, there is an implicit \"^...$\" surrounding your\n"
+    "  input. If you want to match a substring, you need to use wildcards at\n"
+    "  the beginning and end.\n"
+    "\n"
+    "  There are only two special tokens understood by the pattern matcher.\n"
+    "  Everything else is a literal.\n"
+    "\n"
+    "   * Matches zero or more of any character. It does not depend on the\n"
+    "     preceding character (in regular expression parlance it is\n"
+    "     equivalent to \".*\").\n"
+    "\n"
+    "  \\b Matches a path boundary. This will match the beginning or end of\n"
+    "     a string, or a slash.\n"
+    "\n"
+    "Pattern examples\n"
+    "\n"
+    "  \"*asdf*\"\n"
+    "      Matches a string containing \"asdf\" anywhere.\n"
+    "\n"
+    "  \"asdf\"\n"
+    "      Matches only the exact string \"asdf\".\n"
+    "\n"
+    "  \"*.cc\"\n"
+    "      Matches strings ending in the literal \".cc\".\n"
+    "\n"
+    "  \"\\bwin/*\"\n"
+    "      Matches \"win/foo\" and \"foo/win/bar.cc\" but not \"iwin/foo\".\n"
+    "\n"
+    "Sources assignment example\n"
+    "\n"
     "  # Filter out all _win files.\n"
-    "  set_sources_assignment_filter([ \"*_win.cc\", \"*_win.h\" ])\n";
+    "  set_sources_assignment_filter([ \"*_win.cc\", \"*_win.h\" ])\n"
+    "  sources = [ \"a.cc\", \"b_win.cc\" ]\n"
+    "  print(sources)\n"
+    "  # Will print [ \"a.cc\" ]. b_win one was filtered out.\n";
 
 Value RunSetSourcesAssignmentFilter(Scope* scope,
                                     const FunctionCallNode* function,
diff --git a/tools/gn/gn.gyp b/tools/gn/gn.gyp
index e3920cb..bc11b5d 100644
--- a/tools/gn/gn.gyp
+++ b/tools/gn/gn.gyp
@@ -31,6 +31,7 @@
         'command_desc.cc',
         'command_gen.cc',
         'command_help.cc',
+        'command_ls.cc',
         'command_refs.cc',
         'commands.cc',
         'commands.h',
@@ -82,6 +83,8 @@
         'item.h',
         'label.cc',
         'label.h',
+        'label_pattern.cc',
+        'label_pattern.h',
         'label_ptr.h',
         'loader.cc',
         'loader.h',
@@ -205,6 +208,7 @@
         'functions_unittest.cc',
         'header_checker_unittest.cc',
         'input_conversion_unittest.cc',
+        'label_pattern_unittest.cc',
         'label_unittest.cc',
         'loader_unittest.cc',
         'ninja_action_target_writer_unittest.cc',
diff --git a/tools/gn/header_checker.cc b/tools/gn/header_checker.cc
index 3fb6bd7..c950fca 100644
--- a/tools/gn/header_checker.cc
+++ b/tools/gn/header_checker.cc
@@ -123,22 +123,39 @@ HeaderChecker::HeaderChecker(const BuildSettings* build_settings,
     : main_loop_(base::MessageLoop::current()),
       build_settings_(build_settings) {
   for (size_t i = 0; i < targets.size(); i++)
-    AddTargetToFileMap(targets[i]);
+    AddTargetToFileMap(targets[i], &file_map_);
 }
 
 HeaderChecker::~HeaderChecker() {
 }
 
-bool HeaderChecker::Run(std::vector<Err>* errors) {
-  ScopedTrace trace(TraceItem::TRACE_CHECK_HEADERS, "Check headers");
+bool HeaderChecker::Run(const std::vector<const Target*>& to_check,
+                        std::vector<Err>* errors) {
+  if (to_check.empty()) {
+    // Check all files.
+    RunCheckOverFiles(file_map_);
+  } else {
+    // Run only over the files in the given targets.
+    FileMap files_to_check;
+    for (size_t i = 0; i < to_check.size(); i++)
+      AddTargetToFileMap(to_check[i], &files_to_check);
+    RunCheckOverFiles(files_to_check);
+  }
 
-  if (file_map_.empty())
+  if (errors_.empty())
     return true;
+  *errors = errors_;
+  return false;
+}
+
+void HeaderChecker::RunCheckOverFiles(const FileMap& files) {
+  if (files.empty())
+    return;
 
   scoped_refptr<base::SequencedWorkerPool> pool(
       new base::SequencedWorkerPool(16, "HeaderChecker"));
-  for (FileMap::const_iterator file_i = file_map_.begin();
-       file_i != file_map_.end(); ++file_i) {
+  for (FileMap::const_iterator file_i = files.begin();
+       file_i != files.end(); ++file_i) {
     const TargetVector& vect = file_i->second;
 
     // Only check C-like source files (RC files also have includes).
@@ -158,11 +175,6 @@ bool HeaderChecker::Run(std::vector<Err>* errors) {
 
   // After this call we're single-threaded again.
   pool->Shutdown();
-
-  if (errors_.empty())
-    return true;
-  *errors = errors_;
-  return false;
 }
 
 void HeaderChecker::DoWork(const Target* target, const SourceFile& file) {
@@ -173,7 +185,8 @@ void HeaderChecker::DoWork(const Target* target, const SourceFile& file) {
   }
 }
 
-void HeaderChecker::AddTargetToFileMap(const Target* target) {
+// static
+void HeaderChecker::AddTargetToFileMap(const Target* target, FileMap* dest) {
   // Files in the sources have this public bit by default.
   bool default_public = target->all_headers_public();
 
@@ -194,7 +207,7 @@ void HeaderChecker::AddTargetToFileMap(const Target* target) {
   // Add the merged list to the master list of all files.
   for (std::map<SourceFile, bool>::const_iterator i = files_to_public.begin();
        i != files_to_public.end(); ++i)
-    file_map_[i->first].push_back(TargetInfo(target, i->second));
+    (*dest)[i->first].push_back(TargetInfo(target, i->second));
 }
 
 bool HeaderChecker::IsFileInOuputDir(const SourceFile& file) const {
diff --git a/tools/gn/header_checker.h b/tools/gn/header_checker.h
index bdfbb55..c90c67a 100644
--- a/tools/gn/header_checker.h
+++ b/tools/gn/header_checker.h
@@ -33,10 +33,14 @@ class HeaderChecker : public base::RefCountedThreadSafe<HeaderChecker> {
   HeaderChecker(const BuildSettings* build_settings,
                 const std::vector<const Target*>& targets);
 
-  // This assumes that the current thread already has a message loop.  On
-  // error, fills the given vector with the errors and returns false.  Returns
+  // Runs the check. The targets in to_check will be checked. If this list is
+  // empty, all targets will be checked.
+  //
+  // This assumes that the current thread already has a message loop. On
+  // error, fills the given vector with the errors and returns false. Returns
   // true on success.
-  bool Run(std::vector<Err>* errors);
+  bool Run(const std::vector<const Target*>& to_check,
+           std::vector<Err>* errors);
 
  private:
   friend class base::RefCountedThreadSafe<HeaderChecker>;
@@ -57,12 +61,16 @@ class HeaderChecker : public base::RefCountedThreadSafe<HeaderChecker> {
   };
 
   typedef std::vector<TargetInfo> TargetVector;
+  typedef std::map<SourceFile, TargetVector> FileMap;
+
+  // Backend for Run() that takes the list of files to check. The errors_ list
+  // will be populate on failure.
+  void RunCheckOverFiles(const FileMap& flies);
 
   void DoWork(const Target* target, const SourceFile& file);
 
-  // Adds the sources and public files from the given target to the file_map_.
-  // Not threadsafe! Called only during init.
-  void AddTargetToFileMap(const Target* target);
+  // Adds the sources and public files from the given target to the given map.
+  static void AddTargetToFileMap(const Target* target, FileMap* dest);
 
   // Returns true if the given file is in the output directory.
   bool IsFileInOuputDir(const SourceFile& file) const;
@@ -133,7 +141,6 @@ class HeaderChecker : public base::RefCountedThreadSafe<HeaderChecker> {
   const BuildSettings* build_settings_;
 
   // Maps source files to targets it appears in (usually just one target).
-  typedef std::map<SourceFile, TargetVector> FileMap;
   FileMap file_map_;
 
   // Locked variables ----------------------------------------------------------
diff --git a/tools/gn/label_pattern.cc b/tools/gn/label_pattern.cc
new file mode 100644
index 0000000..752898f
--- /dev/null
+++ b/tools/gn/label_pattern.cc
@@ -0,0 +1,247 @@
+// Copyright 2014 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/label_pattern.h"
+
+#include "tools/gn/err.h"
+#include "tools/gn/filesystem_utils.h"
+#include "tools/gn/value.h"
+
+const char kLabelPattern_Help[] =
+    "Label patterns\n"
+    "\n"
+    "  A label pattern is a way of expressing one or more labels in a portion\n"
+    "  of the source tree. They are not general regular expressions.\n"
+    "\n"
+    "  They can take the following forms only:\n"
+    "\n"
+    "   - Explicit (no wildcard):\n"
+    "       \"//foo/bar:baz\"\n"
+    "       \":baz\"\n"
+    "\n"
+    "   - Wildcard target names:\n"
+    "       \"//foo/bar:*\" (all targets in the //foo/bar/BUILD.gn file)\n"
+    "       \":*\"  (all targets in the current build file)\n"
+    "\n"
+    "   - Wildcard directory names (\"*\" is only supported at the end)\n"
+    "       \"*\"  (all targets)\n"
+    "       \"//foo/bar/*\"  (all targets in any subdir of //foo/bar)\n"
+    "       \"./*\"  (all targets in the current build file or sub dirs)\n"
+    "\n"
+    "  Any of the above forms can additionally take an explicit toolchain.\n"
+    "  In this case, the toolchain must be fully qualified (no wildcards\n"
+    "  are supported in the toolchain name).\n"
+    "\n"
+    "    \"//foo:bar(//build/toochain:mac)\"\n"
+    "        An explicit target in an explicit toolchain.\n"
+    "\n"
+    "    \":*(//build/toolchain/linux:32bit)\"\n"
+    "        All targets in the current build file using the 32-bit Linux\n"
+    "        toolchain.\n"
+    "\n"
+    "    \"//foo/*(//build/toolchain:win)\"\n"
+    "        All targets in //foo and any subdirectory using the Windows\n"
+    "        toolchain.\n";
+
+LabelPattern::LabelPattern() : type_(MATCH) {
+}
+
+LabelPattern::LabelPattern(Type type,
+                           const SourceDir& dir,
+                           const base::StringPiece& name,
+                           const Label& toolchain_label)
+    : toolchain_(toolchain_label),
+      type_(type),
+      dir_(dir) {
+  name.CopyToString(&name_);
+}
+
+LabelPattern::~LabelPattern() {
+}
+
+// static
+LabelPattern LabelPattern::GetPattern(const SourceDir& current_dir,
+                                      const Value& value,
+                                      Err* err) {
+  if (!value.VerifyTypeIs(Value::STRING, err))
+    return LabelPattern();
+
+  base::StringPiece str(value.string_value());
+  if (str.empty()) {
+    *err = Err(value, "Label pattern must not be empty.");
+    return LabelPattern();
+  }
+
+  // If there's no wildcard, this is specifying an exact label, use the
+  // label resolution code to get all the implicit name stuff.
+  size_t star = str.find('*');
+  if (star == std::string::npos) {
+    Label label = Label::Resolve(current_dir, Label(), value, err);
+    if (err->has_error())
+      return LabelPattern();
+
+    // Toolchain.
+    Label toolchain_label;
+    if (!label.toolchain_dir().is_null() || !label.toolchain_name().empty())
+      toolchain_label = label.GetToolchainLabel();
+
+    return LabelPattern(MATCH, label.dir(), label.name(), toolchain_label);
+  }
+
+  // Wildcard case, need to split apart the label to see what it specifies.
+  Label toolchain_label;
+  size_t open_paren = str.find('(');
+  if (open_paren != std::string::npos) {
+    // Has a toolchain definition, extract inside the parens.
+    size_t close_paren = str.find(')', open_paren);
+    if (close_paren == std::string::npos) {
+      *err = Err(value, "No close paren when looking for toolchain name.");
+      return LabelPattern();
+    }
+
+    std::string toolchain_string =
+        str.substr(open_paren + 1, close_paren - open_paren - 1).as_string();
+    if (toolchain_string.find('*') != std::string::npos) {
+      *err = Err(value, "Can't have a wildcard in the toolchain.");
+      return LabelPattern();
+    }
+
+    // Parse the inside of the parens as a label for a toolchain.
+    Value value_for_toolchain(value.origin(), toolchain_string);
+    toolchain_label =
+        Label::Resolve(current_dir, Label(), value_for_toolchain, err);
+    if (err->has_error())
+      return LabelPattern();
+
+    // Trim off the toolchain for the processing below.
+    str = str.substr(0, open_paren);
+  }
+
+  // Extract path and name.
+  base::StringPiece path;
+  base::StringPiece name;
+  size_t colon = str.find(':');
+  if (colon == std::string::npos) {
+    path = base::StringPiece(str);
+  } else {
+    path = str.substr(0, colon);
+    name = str.substr(colon + 1);
+  }
+
+  // The path can have these forms:
+  //   1. <empty>  (use current dir)
+  //   2. <non wildcard stuff>  (send through directory resolution)
+  //   3. <non wildcard stuff>*  (send stuff through dir resolution, note star)
+  //   4. *  (matches anything)
+  SourceDir dir;
+  bool has_path_star = false;
+  if (path.empty()) {
+    // Looks like ":foo".
+    dir = current_dir;
+  } else if (path[path.size() - 1] == '*') {
+    // Case 3 or 4 above.
+    has_path_star = true;
+
+    // Adjust path to contain everything but the star.
+    path = path.substr(0, path.size() - 1);
+
+    if (!path.empty() && path[path.size() - 1] != '/') {
+      // The input was "foo*" which is invalid.
+      *err = Err(value, "'*' must match full directories in a label pattern.",
+          "You did \"foo*\" but this thing doesn't do general pattern\n"
+          "matching. Instead, you have to add a slash: \"foo/*\" to match\n"
+          "all targets in a directory hierarchy.");
+      return LabelPattern();
+    }
+  }
+
+  // Resolve the part of the path that's not the wildcard.
+  if (!path.empty()) {
+    // The non-wildcard stuff better not have a wildcard.
+    if (path.find('*') != base::StringPiece::npos) {
+      *err = Err(value, "Label patterns only support wildcard suffixes.",
+          "The pattern contained a '*' that wasn't at tne end.");
+      return LabelPattern();
+    }
+
+    // Resolve the non-wildcard stuff.
+    dir = current_dir.ResolveRelativeDir(path);
+    if (dir.is_null()) {
+      *err = Err(value, "Label pattern didn't resolve to a dir.",
+          "The directory name \"" + path.as_string() + "\" didn't\n"
+          "resolve to a directory.");
+      return LabelPattern();
+    }
+  }
+
+  // Resolve the name. At this point, we're doing wildcard matches so the
+  // name should either be empty ("foo/*") or a wildcard ("foo:*");
+  if (colon != std::string::npos && name != "*") {
+    *err = Err(value, "Invalid label pattern.",
+        "You seem to be using the wildcard more generally that is supported.\n"
+        "Did you mean \"foo:*\" to match everything in the file, or\n"
+        "\"./*\" to recursively match everything in the currend subtree.");
+    return LabelPattern();
+  }
+
+  Type type;
+  if (has_path_star) {
+    // We know there's a wildcard, so if the name is empty it looks like
+    // "foo/*".
+    type = RECURSIVE_DIRECTORY;
+  } else {
+    // Everything else should be of the form "foo:*".
+    type = DIRECTORY;
+  }
+
+  // When we're doing wildcard matching, the name is always empty.
+  return LabelPattern(type, dir, base::StringPiece(), toolchain_label);
+}
+
+bool LabelPattern::Matches(const Label& label) const {
+  if (!toolchain_.is_null()) {
+    // Toolchain must match exactly.
+    if (toolchain_.dir() != label.toolchain_dir() ||
+        toolchain_.name() != label.toolchain_name())
+      return false;
+  }
+
+  switch (type_) {
+    case MATCH:
+      return label.name() == name_ && label.dir() == dir_;
+    case DIRECTORY:
+      // The directories must match exactly.
+      return label.dir() == dir_;
+    case RECURSIVE_DIRECTORY:
+      // Our directory must be a prefix of the input label for recursive.
+      return label.dir().value().compare(0, dir_.value().size(), dir_.value())
+          == 0;
+    default:
+      NOTREACHED();
+      return false;
+  }
+}
+
+std::string LabelPattern::Describe() const {
+  std::string result;
+
+  switch (type()) {
+    case MATCH:
+      result = DirectoryWithNoLastSlash(dir()) + ":" + name();
+      break;
+    case DIRECTORY:
+      result = DirectoryWithNoLastSlash(dir()) + ":*";
+      break;
+    case RECURSIVE_DIRECTORY:
+      result = dir().value() + "*";
+      break;
+  }
+
+  if (!toolchain_.is_null()) {
+    result.push_back('(');
+    result.append(toolchain_.GetUserVisibleName(false));
+    result.push_back(')');
+  }
+  return result;
+}
diff --git a/tools/gn/label_pattern.h b/tools/gn/label_pattern.h
new file mode 100644
index 0000000..e805ffb
--- /dev/null
+++ b/tools/gn/label_pattern.h
@@ -0,0 +1,72 @@
+// Copyright 2014 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.
+
+#ifndef TOOLS_GN_LABEL_PATTERN_H_
+#define TOOLS_GN_LABEL_PATTERN_H_
+
+#include "base/strings/string_piece.h"
+#include "tools/gn/label.h"
+#include "tools/gn/source_dir.h"
+
+class Err;
+class Value;
+
+extern const char kLabelPattern_Help[];
+
+// A label pattern is a simple pattern that matches labels. It is used for
+// specifying visibility and other times when multiple targets need to be
+// referenced.
+class LabelPattern {
+ public:
+  enum Type {
+    MATCH = 1,  // Exact match for a given target.
+    DIRECTORY,  // Only targets in the file in the given directory.
+    RECURSIVE_DIRECTORY  // The given directory and any subdir.
+                         // (also indicates "public" when dir is empty).
+  };
+
+  LabelPattern();
+  LabelPattern(Type type,
+               const SourceDir& dir,
+               const base::StringPiece& name,
+               const Label& toolchain_label);
+  ~LabelPattern();
+
+  // Converts the given input string to a pattern. This does special stuff
+  // to treat the pattern as a label. Sets the error on failure.
+  static LabelPattern GetPattern(const SourceDir& current_dir,
+                                 const Value& value,
+                                 Err* err);
+
+  // Returns true if this pattern matches the given label.
+  bool Matches(const Label& label) const;
+
+  // Returns a string representation of this pattern.
+  std::string Describe() const;
+
+  Type type() const { return type_; }
+
+  const SourceDir& dir() const { return dir_; }
+  const std::string& name() const { return name_; }
+
+  const Label& toolchain() const { return toolchain_; }
+  void set_toolchain(const Label& tc) { toolchain_ = tc; }
+
+ private:
+  // If nonempty, specifies the toolchain to use. If empty, this will match
+  // all toolchains. This is independent of the match type.
+  Label toolchain_;
+
+  Type type_;
+
+  // Used when type_ == PRIVATE and PRIVATE_RECURSIVE. This specifies the
+  // directory that to which the pattern is private to.
+  SourceDir dir_;
+
+  // Empty name means match everything. Otherwise the name must match
+  // exactly.
+  std::string name_;
+};
+
+#endif  // TOOLS_GN_LABEL_PATTERN_H_
diff --git a/tools/gn/label_pattern_unittest.cc b/tools/gn/label_pattern_unittest.cc
new file mode 100644
index 0000000..21d6a9b
--- /dev/null
+++ b/tools/gn/label_pattern_unittest.cc
@@ -0,0 +1,73 @@
+// Copyright 2014 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 "testing/gtest/include/gtest/gtest.h"
+#include "tools/gn/err.h"
+#include "tools/gn/label_pattern.h"
+#include "tools/gn/value.h"
+
+namespace {
+
+struct PatternCase {
+  const char* input;
+  bool success;
+
+  LabelPattern::Type type;
+  const char* dir;
+  const char* name;
+  const char* toolchain;
+};
+
+}  // namespace
+
+TEST(LabelPattern, PatternParse) {
+  SourceDir current_dir("//foo/");
+  PatternCase cases[] = {
+    // Missing stuff.
+    { "", false, LabelPattern::MATCH, "", "", "" },
+    { ":", false, LabelPattern::MATCH, "", "", "" },
+    // Normal things.
+    { ":bar", true, LabelPattern::MATCH, "//foo/", "bar", "" },
+    { "//la:bar", true, LabelPattern::MATCH, "//la/", "bar", "" },
+    { "*", true, LabelPattern::RECURSIVE_DIRECTORY, "", "", "" },
+    { ":*", true, LabelPattern::DIRECTORY, "//foo/", "", "" },
+    { "la:*", true, LabelPattern::DIRECTORY, "//foo/la/", "", "" },
+    { "la/*:*", true, LabelPattern::RECURSIVE_DIRECTORY, "//foo/la/", "", "" },
+    { "//la:*", true, LabelPattern::DIRECTORY, "//la/", "", "" },
+    { "./*", true, LabelPattern::RECURSIVE_DIRECTORY, "//foo/", "", "" },
+    { "foo/*", true, LabelPattern::RECURSIVE_DIRECTORY, "//foo/foo/", "", "" },
+    { "//l/*", true, LabelPattern::RECURSIVE_DIRECTORY, "//l/", "", "" },
+    // Toolchains.
+    { "//foo()", true, LabelPattern::MATCH, "//foo/", "foo", "" },
+    { "//foo(//bar)", true, LabelPattern::MATCH, "//foo/", "foo", "//bar:bar" },
+    { "//foo:*(//bar)", true, LabelPattern::DIRECTORY, "//foo/", "",
+      "//bar:bar" },
+    { "//foo/*(//bar)", true, LabelPattern::RECURSIVE_DIRECTORY, "//foo/", "",
+      "//bar:bar" },
+    // Wildcards in invalid places.
+    { "*foo*:bar", false, LabelPattern::MATCH, "", "", "" },
+    { "foo*:*bar", false, LabelPattern::MATCH, "", "", "" },
+    { "*foo:bar", false, LabelPattern::MATCH, "", "", "" },
+    { "foo:bar*", false, LabelPattern::MATCH, "", "", "" },
+    { "*:*", true, LabelPattern::RECURSIVE_DIRECTORY, "", "", "" },
+    // Invalid toolchain stuff.
+    { "//foo(//foo/bar:*)", false, LabelPattern::MATCH, "", "", "" },
+    { "//foo/*(*)", false, LabelPattern::MATCH, "", "", "" },
+    { "//foo(//bar", false, LabelPattern::MATCH, "", "", "" },
+  };
+
+  for (size_t i = 0; i < arraysize(cases); i++) {
+    const PatternCase& cur = cases[i];
+    Err err;
+    LabelPattern result =
+        LabelPattern::GetPattern(current_dir, Value(NULL, cur.input), &err);
+
+    EXPECT_EQ(cur.success, !err.has_error()) << i << " " << cur.input;
+    EXPECT_EQ(cur.type, result.type()) << i << " " << cur.input;
+    EXPECT_EQ(cur.dir, result.dir().value()) << i << " " << cur.input;
+    EXPECT_EQ(cur.name, result.name()) << i << " " << cur.input;
+    EXPECT_EQ(cur.toolchain, result.toolchain().GetUserVisibleName(false))
+        << i << " " << cur.input;
+  }
+}
diff --git a/tools/gn/pattern.cc b/tools/gn/pattern.cc
index e4ac8df..7747d62 100644
--- a/tools/gn/pattern.cc
+++ b/tools/gn/pattern.cc
@@ -6,40 +6,6 @@
 
 #include "tools/gn/value.h"
 
-const char kPattern_Help[] =
-    "Patterns\n"
-    "  Patterns are VERY limited regular expressions that are used in\n"
-    "  several places.\n"
-    "\n"
-    "  Patterns must match the entire input string to be counted as a match.\n"
-    "  In regular expression parlance, there is an implicit \"^...$\"\n"
-    "  surrounding your input. If you want to match a substring, you need to\n"
-    "  use wildcards at the beginning and end.\n"
-    "\n"
-    "  There are only two special tokens understood by the pattern matcher.\n"
-    "  Everything else is a literal.\n"
-    "\n"
-    "   * Matches zero or more of any character. It does not depend on the\n"
-    "     preceding character (in regular expression parlance it is\n"
-    "     equivalent to \".*\").\n"
-    "\n"
-    "  \\b Matches a path boundary. This will match the beginning or end of\n"
-    "     a string, or a slash.\n"
-    "\n"
-    "Examples\n"
-    "\n"
-    "  \"*asdf*\"\n"
-    "      Matches a string containing \"asdf\" anywhere.\n"
-    "\n"
-    "  \"asdf\"\n"
-    "      Matches only the exact string \"asdf\".\n"
-    "\n"
-    "  \"*.cc\"\n"
-    "      Matches strings ending in the literal \".cc\".\n"
-    "\n"
-    "  \"\\bwin/*\"\n"
-    "      Matches \"win/foo\" and \"foo/win/bar.cc\" but not \"iwin/foo\".\n";
-
 namespace {
 
 void ParsePattern(const std::string& s, std::vector<Pattern::Subrange>* out) {
diff --git a/tools/gn/pattern.h b/tools/gn/pattern.h
index 24dffd2..f5f432c 100644
--- a/tools/gn/pattern.h
+++ b/tools/gn/pattern.h
@@ -10,8 +10,6 @@
 
 #include "tools/gn/value.h"
 
-extern const char kPattern_Help[];
-
 class Pattern {
  public:
   struct Subrange {
diff --git a/tools/gn/setup.cc b/tools/gn/setup.cc
index f6a2068..bdd0c17 100644
--- a/tools/gn/setup.cc
+++ b/tools/gn/setup.cc
@@ -18,8 +18,8 @@
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
+#include "tools/gn/commands.h"
 #include "tools/gn/filesystem_utils.h"
-#include "tools/gn/header_checker.h"
 #include "tools/gn/input_file.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/parser.h"
@@ -188,19 +188,11 @@ bool CommonSetup::RunPostMessageLoop() {
   }
 
   if (check_public_headers_) {
-    std::vector<const Target*> targets = builder_->GetAllResolvedTargets();
-    scoped_refptr<HeaderChecker> header_checker(
-        new HeaderChecker(&build_settings_, targets));
-
-    std::vector<Err> header_errors;
-    header_checker->Run(&header_errors);
-    for (size_t i = 0; i < header_errors.size(); i++) {
-      if (i > 0)
-        OutputString("___________________\n", DECORATION_YELLOW);
-      header_errors[i].PrintToStdout();
-    }
-    if (!header_errors.empty())
+    if (!commands::CheckPublicHeaders(&build_settings_,
+                                      builder_->GetAllResolvedTargets(),
+                                      std::vector<const Target*>())) {
       return false;
+    }
   }
 
   // Write out tracing and timing if requested.
diff --git a/tools/gn/variables.cc b/tools/gn/variables.cc
index ccc5a00..c6cc068 100644
--- a/tools/gn/variables.cc
+++ b/tools/gn/variables.cc
@@ -759,26 +759,14 @@ const char kVisibility_Help[] =
     "  outside of any target, and the targets will inherit that scope and see\n"
     "  the definition.\n"
     "\n"
-    "Matching:\n"
+    "Patterns\n"
     "\n"
-    "  You can specify \"*\" but the inputs aren't general patterns. The\n"
-    "  following classes of patterns are supported:\n"
+    "  See \"gn help label_pattern\" for more details on what types of\n"
+    "  patterns are supported. If a toolchain is specified, only targets\n"
+    "  in that toolchain will be matched. If a toolchain is not specified on\n"
+    "  a pattern, targets in all toolchains will be matched.\n"
     "\n"
-    "   - Explicit (no wildcard):\n"
-    "       \"//foo/bar:baz\"\n"
-    "       \":baz\"\n"
-    "   - Wildcard target names:\n"
-    "       \"//foo/bar:*\" (any target in the //foo/bar/BUILD.gn file)\n"
-    "       \":*\"  (any target in the current build file)\n"
-    "   - Wildcard directory names (\"*\" is only supported at the end)\n"
-    "       \"*\"  (any target anywhere)\n"
-    "       \"//foo/bar/*\"  (any target in any subdir of //foo/bar)\n"
-    "       \"./*\"  (any target in the current build file or sub dirs)\n"
-    "\n"
-    "  The toolchain (normally an implicit part of a label) is ignored when\n"
-    "  checking visibility.\n"
-    "\n"
-    "Examples:\n"
+    "Examples\n"
     "\n"
     "  Only targets in the current buildfile (\"private\", the default):\n"
     "    visibility = \":*\"\n"
diff --git a/tools/gn/visibility.cc b/tools/gn/visibility.cc
index 6fc8fa1..c9dbb87 100644
--- a/tools/gn/visibility.cc
+++ b/tools/gn/visibility.cc
@@ -14,38 +14,6 @@
 #include "tools/gn/value.h"
 #include "tools/gn/variables.h"
 
-Visibility::VisPattern::VisPattern() : type_(MATCH) {
-}
-
-Visibility::VisPattern::VisPattern(Type type,
-                                   const SourceDir& dir,
-                                   const base::StringPiece& name)
-    : type_(type),
-      dir_(dir) {
-  name.CopyToString(&name_);
-}
-
-Visibility::VisPattern::~VisPattern() {
-}
-
-bool Visibility::VisPattern::Matches(const Label& label) const {
-  switch (type_) {
-    case MATCH:
-      return label.name() == name_ && label.dir() == dir_;
-    case DIRECTORY:
-      // The directories must match exactly for private visibility.
-      return label.dir() == dir_;
-    case RECURSIVE_DIRECTORY:
-      // Our directory must be a prefix of the input label for recursive
-      // private visibility.
-      return label.dir().value().compare(0, dir_.value().size(), dir_.value())
-          == 0;
-    default:
-      NOTREACHED();
-      return false;
-  }
-}
-
 Visibility::Visibility() {
 }
 
@@ -60,7 +28,7 @@ bool Visibility::Set(const SourceDir& current_dir,
   // Allow a single string to be passed in to make the common case (just one
   // pattern) easier to specify.
   if (value.type() == Value::STRING) {
-    patterns_.push_back(GetPattern(current_dir, value, err));
+    patterns_.push_back(LabelPattern::GetPattern(current_dir, value, err));
     return !err->has_error();
   }
 
@@ -70,7 +38,7 @@ bool Visibility::Set(const SourceDir& current_dir,
 
   const std::vector<Value>& list = value.list_value();
   for (size_t i = 0; i < list.size(); i++) {
-    patterns_.push_back(GetPattern(current_dir, list[i], err));
+    patterns_.push_back(LabelPattern::GetPattern(current_dir, list[i], err));
     if (err->has_error())
       return false;
   }
@@ -80,13 +48,15 @@ bool Visibility::Set(const SourceDir& current_dir,
 void Visibility::SetPublic() {
   patterns_.clear();
   patterns_.push_back(
-      VisPattern(VisPattern::RECURSIVE_DIRECTORY, SourceDir(), std::string()));
+      LabelPattern(LabelPattern::RECURSIVE_DIRECTORY, SourceDir(),
+      std::string(), Label()));
 }
 
 void Visibility::SetPrivate(const SourceDir& current_dir) {
   patterns_.clear();
   patterns_.push_back(
-      VisPattern(VisPattern::DIRECTORY, current_dir, std::string()));
+      LabelPattern(LabelPattern::DIRECTORY, current_dir, std::string(),
+      Label()));
 }
 
 bool Visibility::CanSeeMe(const Label& label) const {
@@ -112,22 +82,8 @@ std::string Visibility::Describe(int indent, bool include_brackets) const {
     inner_indent_string += "  ";
   }
 
-  for (size_t i = 0; i < patterns_.size(); i++) {
-    switch (patterns_[i].type()) {
-      case VisPattern::MATCH:
-        result += inner_indent_string +
-            DirectoryWithNoLastSlash(patterns_[i].dir()) + ":" +
-            patterns_[i].name() + "\n";
-        break;
-      case VisPattern::DIRECTORY:
-        result += inner_indent_string +
-            DirectoryWithNoLastSlash(patterns_[i].dir()) + ":*\n";
-        break;
-      case VisPattern::RECURSIVE_DIRECTORY:
-        result += inner_indent_string + patterns_[i].dir().value() + "*\n";
-        break;
-    }
-  }
+  for (size_t i = 0; i < patterns_.size(); i++)
+    result += inner_indent_string + patterns_[i].Describe() + "\n";
 
   if (include_brackets)
     result += outer_indent_string + "]\n";
@@ -135,118 +91,6 @@ std::string Visibility::Describe(int indent, bool include_brackets) const {
 }
 
 // static
-Visibility::VisPattern Visibility::GetPattern(const SourceDir& current_dir,
-                                              const Value& value,
-                                              Err* err) {
-  if (!value.VerifyTypeIs(Value::STRING, err))
-    return VisPattern();
-
-  const std::string& str = value.string_value();
-  if (str.empty()) {
-    *err = Err(value, "Visibility pattern must not be empty.");
-    return VisPattern();
-  }
-
-  // If there's no wildcard, this is specifying an exact label, use the
-  // label resolution code to get all the implicit name stuff.
-  size_t star = str.find('*');
-  if (star == std::string::npos) {
-    Label label = Label::Resolve(current_dir, Label(), value, err);
-    if (err->has_error())
-      return VisPattern();
-
-    // There should be no toolchain specified.
-    if (!label.toolchain_dir().is_null() || !label.toolchain_name().empty()) {
-      *err = Err(value, "Visibility label specified a toolchain.",
-          "Visibility names and patterns don't use toolchains, erase the\n"
-          "stuff in the ().");
-      return VisPattern();
-    }
-
-    return VisPattern(VisPattern::MATCH, label.dir(), label.name());
-  }
-
-  // Wildcard case, need to split apart the label to see what it specifies.
-  base::StringPiece path;
-  base::StringPiece name;
-  size_t colon = str.find(':');
-  if (colon == std::string::npos) {
-    path = base::StringPiece(str);
-  } else {
-    path = base::StringPiece(&str[0], colon);
-    name = base::StringPiece(&str[colon + 1], str.size() - colon - 1);
-  }
-
-  // The path can have these forms:
-  //   1. <empty>  (use current dir)
-  //   2. <non wildcard stuff>  (send through directory resolution)
-  //   3. <non wildcard stuff>*  (send stuff through dir resolution, note star)
-  //   4. *  (matches anything)
-  SourceDir dir;
-  bool has_path_star = false;
-  if (path.empty()) {
-    // Looks like ":foo".
-    dir = current_dir;
-  } else if (path[path.size() - 1] == '*') {
-    // Case 3 or 4 above.
-    has_path_star = true;
-
-    // Adjust path to contain everything but the star.
-    path = path.substr(0, path.size() - 1);
-
-    if (!path.empty() && path[path.size() - 1] != '/') {
-      // The input was "foo*" which is invalid.
-      *err = Err(value, "'*' must match full directories in visibility.",
-          "You did \"foo*\" but visibility doesn't do general pattern\n"
-          "matching. Instead, you have to add a slash: \"foo/*\".");
-      return VisPattern();
-    }
-  }
-
-  // Resolve the part of the path that's not the wildcard.
-  if (!path.empty()) {
-    // The non-wildcard stuff better not have a wildcard.
-    if (path.find('*') != base::StringPiece::npos) {
-      *err = Err(value, "Visibility patterns only support wildcard suffixes.",
-          "The visibility pattern contained a '*' that wasn't at tne end.");
-      return VisPattern();
-    }
-
-    // Resolve the non-wildcard stuff.
-    dir = current_dir.ResolveRelativeDir(path);
-    if (dir.is_null()) {
-      *err = Err(value, "Visibility pattern didn't resolve to a dir.",
-          "The directory name \"" + path.as_string() + "\" didn't\n"
-          "resolve to a directory.");
-      return VisPattern();
-    }
-  }
-
-  // Resolve the name. At this point, we're doing wildcard matches so the
-  // name should either be empty ("foo/*") or a wildcard ("foo:*");
-  if (colon != std::string::npos && name != "*") {
-    *err = Err(value, "Invalid visibility pattern.",
-        "You seem to be using the wildcard more generally that is supported.\n"
-        "Did you mean \"foo:*\" to match everything in the current file, or\n"
-        "\"./*\" to recursively match everything in the currend subtree.");
-    return VisPattern();
-  }
-
-  VisPattern::Type type;
-  if (has_path_star) {
-    // We know there's a wildcard, so if the name is empty it looks like
-    // "foo/*".
-    type = VisPattern::RECURSIVE_DIRECTORY;
-  } else {
-    // Everything else should be of the form "foo:*".
-    type = VisPattern::DIRECTORY;
-  }
-
-  // When we're doing wildcard matching, the name is always empty.
-  return VisPattern(type, dir, base::StringPiece());
-}
-
-// static
 bool Visibility::CheckItemVisibility(const Item* from,
                                      const Item* to,
                                      Err* err) {
diff --git a/tools/gn/visibility.h b/tools/gn/visibility.h
index 7ce2b78..2e1b680 100644
--- a/tools/gn/visibility.h
+++ b/tools/gn/visibility.h
@@ -9,6 +9,7 @@
 
 #include "base/basictypes.h"
 #include "base/strings/string_piece.h"
+#include "tools/gn/label_pattern.h"
 #include "tools/gn/source_dir.h"
 
 class Err;
@@ -19,37 +20,6 @@ class Value;
 
 class Visibility {
  public:
-  class VisPattern {
-   public:
-    enum Type {
-      MATCH = 1,  // Exact match for a given target.
-      DIRECTORY,  // Only targets in the file in the given directory.
-      RECURSIVE_DIRECTORY  // The given directory and any subdir.
-                           // (also indicates "public" when dir is empty).
-    };
-
-    VisPattern();
-    VisPattern(Type type, const SourceDir& dir, const base::StringPiece& name);
-    ~VisPattern();
-
-    bool Matches(const Label& label) const;
-
-    Type type() const { return type_; }
-    const SourceDir& dir() const { return dir_; }
-    const std::string& name() const { return name_; }
-
-   private:
-    Type type_;
-
-    // Used when type_ == PRIVATE and PRIVATE_RECURSIVE. This specifies the
-    // directory that to which the pattern is private to.
-    SourceDir dir_;
-
-    // Empty name means match everything. Otherwise the name must match
-    // exactly.
-    std::string name_;
-  };
-
   // Defaults to private visibility (only the current file).
   Visibility();
   ~Visibility();
@@ -74,12 +44,6 @@ class Visibility {
   // result will end in a newline.
   std::string Describe(int indent, bool include_brackets) const;
 
-  // Converts the given input string to a pattern. This does special stuff
-  // to treat the pattern as a label. Sets the error on failure.
-  static VisPattern GetPattern(const SourceDir& current_dir,
-                               const Value& value,
-                               Err* err);
-
   // Helper function to check visibility between the given two items. If
   // to is invisible to from, returns false and sets the error.
   static bool CheckItemVisibility(const Item* from, const Item* to, Err* err);
@@ -89,7 +53,7 @@ class Visibility {
   static bool FillItemVisibility(Item* item, Scope* scope, Err* err);
 
  private:
-  std::vector<VisPattern> patterns_;
+  std::vector<LabelPattern> patterns_;
 
   DISALLOW_COPY_AND_ASSIGN(Visibility);
 };
diff --git a/tools/gn/visibility_unittest.cc b/tools/gn/visibility_unittest.cc
index 0d09d4d..76e6b0a 100644
--- a/tools/gn/visibility_unittest.cc
+++ b/tools/gn/visibility_unittest.cc
@@ -8,61 +8,6 @@
 #include "tools/gn/value.h"
 #include "tools/gn/visibility.h"
 
-namespace {
-
-struct VisPatternCase {
-  const char* input;
-  bool success;
-
-  Visibility::VisPattern::Type type;
-  const char* dir;
-  const char* name;
-};
-
-}  // namespace
-
-TEST(Visibility, PatternParse) {
-  SourceDir current_dir("//foo/");
-  VisPatternCase cases[] = {
-    // Missing stuff.
-    { "", false, Visibility::VisPattern::MATCH, "", "" },
-    { ":", false, Visibility::VisPattern::MATCH, "", "" },
-    // Normal things.
-    { ":bar", true, Visibility::VisPattern::MATCH, "//foo/", "bar" },
-    { "//la:bar", true, Visibility::VisPattern::MATCH, "//la/", "bar" },
-    { "*", true, Visibility::VisPattern::RECURSIVE_DIRECTORY, "", "" },
-    { ":*", true, Visibility::VisPattern::DIRECTORY, "//foo/", "" },
-    { "la:*", true, Visibility::VisPattern::DIRECTORY, "//foo/la/", "" },
-    { "la/*:*", true, Visibility::VisPattern::RECURSIVE_DIRECTORY,
-      "//foo/la/", "" },
-    { "//la:*", true, Visibility::VisPattern::DIRECTORY, "//la/", "" },
-    { "./*", true, Visibility::VisPattern::RECURSIVE_DIRECTORY, "//foo/", "" },
-    { "foo/*", true, Visibility::VisPattern::RECURSIVE_DIRECTORY,
-      "//foo/foo/", "" },
-    { "//l/*", true, Visibility::VisPattern::RECURSIVE_DIRECTORY, "//l/", "" },
-    // No toolchains allowed.
-    { "//foo(//bar)", false, Visibility::VisPattern::MATCH, "", "" },
-    // Wildcards in invalid places.
-    { "*foo*:bar", false, Visibility::VisPattern::MATCH, "", "" },
-    { "foo*:*bar", false, Visibility::VisPattern::MATCH, "", "" },
-    { "*foo:bar", false, Visibility::VisPattern::MATCH, "", "" },
-    { "foo:bar*", false, Visibility::VisPattern::MATCH, "", "" },
-    { "*:*", true, Visibility::VisPattern::RECURSIVE_DIRECTORY, "", "" },
-  };
-
-  for (size_t i = 0; i < arraysize(cases); i++) {
-    const VisPatternCase& cur = cases[i];
-    Err err;
-    Visibility::VisPattern result =
-        Visibility::GetPattern(current_dir, Value(NULL, cur.input), &err);
-
-    EXPECT_EQ(cur.success, !err.has_error()) << i << " " << cur.input;
-    EXPECT_EQ(cur.type, result.type()) << i << " " << cur.input;
-    EXPECT_EQ(cur.dir, result.dir().value()) << i << " " << cur.input;
-    EXPECT_EQ(cur.name, result.name()) << i << " " << cur.input;
-  }
-}
-
 TEST(Visibility, CanSeeMe) {
   Value list(NULL, Value::LIST);
   list.list_value().push_back(Value(NULL, "//rec/*"));  // Recursive.