Add public deps to GN

tools/gn/target.h

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef TOOLS_GN_TARGET_H_
 #define TOOLS_GN_TARGET_H_
 
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 107 matching lines @@
   FileList& data() { return data_; }
 
   // Returns true if targets depending on this one should have an order
   // dependency.
   bool hard_dep() const {
     return output_type_ == ACTION ||
            output_type_ == ACTION_FOREACH ||
            output_type_ == COPY_FILES;
   }
 
-  // Linked dependencies.
-  const LabelTargetVector& deps() const { return deps_; }
-  LabelTargetVector& deps() { return deps_; }
+  // Linked private dependencies.
+  const LabelTargetVector& private_deps() const { return private_deps_; }
+  LabelTargetVector& private_deps() { return private_deps_; }
+
+  // Linked public dependencies.
+  const LabelTargetVector& public_deps() const { return public_deps_; }
+  LabelTargetVector& public_deps() { return public_deps_; }
 
   // Non-linked dependencies.
-  const LabelTargetVector& datadeps() const { return datadeps_; }
-  LabelTargetVector& datadeps() { return datadeps_; }
+  const LabelTargetVector& data_deps() const { return data_deps_; }
+  LabelTargetVector& data_deps() { return data_deps_; }
 
   // List of configs that this class inherits settings from. Once a target is
-  // resolved, this will also list all- and direct-dependent configs.
+  // resolved, this will also list all-dependent and public configs.
   const UniqueVector<LabelConfigPair>& configs() const { return configs_; }
   UniqueVector<LabelConfigPair>& configs() { return configs_; }
 
   // List of configs that all dependencies (direct and indirect) of this
   // target get. These configs are not added to this target. Note that due
   // to the way this is computed, there may be duplicates in this list.
   const UniqueVector<LabelConfigPair>& all_dependent_configs() const {
     return all_dependent_configs_;
   }
   UniqueVector<LabelConfigPair>& all_dependent_configs() {
     return all_dependent_configs_;
   }
 
   // List of configs that targets depending directly on this one get. These
-  // configs are not added to this target.
-  const UniqueVector<LabelConfigPair>& direct_dependent_configs() const {
-    return direct_dependent_configs_;
+  // configs are also added to this target.
+  const UniqueVector<LabelConfigPair>& public_configs() const {
+    return public_configs_;
   }
-  UniqueVector<LabelConfigPair>& direct_dependent_configs() {
-    return direct_dependent_configs_;
+  UniqueVector<LabelConfigPair>& public_configs() {
+    return public_configs_;
   }
 
-  // A list of a subset of deps where we'll re-export direct_dependent_configs
-  // as direct_dependent_configs of this target.
+  // A list of a subset of deps where we'll re-export public_configs as
+  // public_configs of this target.
   const UniqueVector<LabelTargetPair>& forward_dependent_configs() const {
     return forward_dependent_configs_;
   }
   UniqueVector<LabelTargetPair>& forward_dependent_configs() {
     return forward_dependent_configs_;
   }
 
   // Dependencies that can include files from this target.
   const std::set<Label>& allow_circular_includes_from() const {
     return allow_circular_includes_from_;
@@ skipping 45 matching lines @@
   // that. This is a cache of the files to prevent every target that depends on
   // a given library from recomputing the same pattern.
   const OutputFile& link_output_file() const {
     return link_output_file_;
   }
   const OutputFile& dependency_output_file() const {
     return dependency_output_file_;
   }
 
  private:
-  void ExpandGroups();
-
   // Pulls necessary information from dependencies to this one when all
   // dependencies have been resolved.
   void PullDependentTargetInfo();
 
   // These each pull specific things from dependencies to this one when all
   // deps have been resolved.
   void PullForwardedDependentConfigs();
+  void PullForwardedDependentConfigsFrom(const Target* from);
   void PullRecursiveHardDeps();
 
   // Fills the link and dependency output files when a target is resolved.
   void FillOutputFiles();
 
   // Validates the given thing when a target is resolved.
   bool CheckVisibility(Err* err) const;
   bool CheckTestonly(Err* err) const;
 
   OutputType output_type_;
   std::string output_name_;
   std::string output_extension_;
 
   FileList sources_;
   bool all_headers_public_;
   FileList public_headers_;
   bool check_includes_;
   bool complete_static_lib_;
   bool testonly_;
   FileList inputs_;
   FileList data_;
 
   bool hard_dep_;
 
-  // Note that if there are any groups in the deps, once the target is resolved
-  // these vectors will list *both* the groups as well as the groups' deps.
-  //
-  // This is because, in general, groups should be "transparent" ways to add
-  // groups of dependencies, so adding the groups deps make this happen with
-  // no additional complexity when iterating over a target's deps.
-  //
-  // However, a group may also have specific settings and configs added to it,
-  // so we also need the group in the list so we find these things. But you
-  // shouldn't need to look inside the deps of the group since those will
-  // already be added.
-  LabelTargetVector deps_;
-  LabelTargetVector datadeps_;
+  LabelTargetVector private_deps_;
+  LabelTargetVector public_deps_;
+  LabelTargetVector data_deps_;
 
   UniqueVector<LabelConfigPair> configs_;
   UniqueVector<LabelConfigPair> all_dependent_configs_;
-  UniqueVector<LabelConfigPair> direct_dependent_configs_;
+  UniqueVector<LabelConfigPair> public_configs_;
   UniqueVector<LabelTargetPair> forward_dependent_configs_;
 
   std::set<Label> allow_circular_includes_from_;
 
   bool external_;
 
   // Static libraries and source sets from transitive deps. These things need
   // to be linked only with the end target (executable, shared library). Source
   // sets do not get pushed beyond static library boundaries, and neither
   // source sets nor static libraries get pushed beyond sahred library
@@ skipping 32 matching lines @@
 };
 #elif defined(COMPILER_MSVC)
 inline size_t hash_value(const Target* t) {
   return reinterpret_cast<size_t>(t);
 }
 #endif  // COMPILER...
 
 }  // namespace BASE_HASH_NAMESPACE
 
 #endif  // TOOLS_GN_TARGET_H_