Propagate GN public shared libraries through shared libraries

tools/gn/target.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "tools/gn/target.h"
 
 #include "base/bind.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "tools/gn/config_values_extractors.h"
@@ skipping 108 matching lines @@
 
   // Copy our own libs and lib_dirs to the final set. This will be from our
   // target and all of our configs. We do this specially since these must be
   // inherited through the dependency tree (other flags don't work this way).
   for (ConfigValuesIterator iter(this); !iter.done(); iter.Next()) {
     const ConfigValues& cur = iter.cur();
     all_lib_dirs_.append(cur.lib_dirs().begin(), cur.lib_dirs().end());
     all_libs_.append(cur.libs().begin(), cur.libs().end());
   }
 
-  PullDependentTargetInfo();
+  PullDependentTargets();
   PullForwardedDependentConfigs();
   PullRecursiveHardDeps();
 
   FillOutputFiles();
 
   if (!CheckVisibility(err))
     return false;
   if (!CheckTestonly(err))
     return false;
   if (!CheckNoNestedStaticLibs(err))
@@ skipping 61 matching lines @@
             "Alas, I can not continue.",
             label().GetUserVisibleName(false).c_str(),
             GetStringForOutputType(output_type_),
             label().GetToolchainLabel().GetUserVisibleName(false).c_str(),
             Toolchain::ToolTypeToName(
                 toolchain->GetToolTypeForTargetFinalOutput(this)).c_str()));
   }
   return false;
 }
 
-void Target::PullDependentTargetInfo() {
-  // Gather info from our dependents we need.
-  for (const auto& pair : GetDeps(DEPS_LINKED)) {
-    const Target* dep = pair.ptr;
-    MergeAllDependentConfigsFrom(dep, &configs_, &all_dependent_configs_);
-    MergePublicConfigsFrom(dep, &configs_);
+void Target::PullDependentTarget(const Target* dep, bool is_public) {
+  MergeAllDependentConfigsFrom(dep, &configs_, &all_dependent_configs_);
+  MergePublicConfigsFrom(dep, &configs_);
 
-    // Direct dependent libraries.
-    if (dep->output_type() == STATIC_LIBRARY ||
-        dep->output_type() == SHARED_LIBRARY ||
-        dep->output_type() == SOURCE_SET)
-      inherited_libraries_.push_back(dep);
+  // Direct dependent libraries.
+  if (dep->output_type() == STATIC_LIBRARY ||
+      dep->output_type() == SHARED_LIBRARY ||
+      dep->output_type() == SOURCE_SET)
+    inherited_libraries_.Append(dep, is_public);
 
-    // Inherited libraries and flags are inherited across static library
-    // boundaries.
-    if (!dep->IsFinal()) {
-      inherited_libraries_.Append(dep->inherited_libraries().begin(),
-                                  dep->inherited_libraries().end());
+  if (dep->output_type() == SHARED_LIBRARY) {
+    // Shared library dependendencies are inherited across public shared
+    // library boundaries.
+    //
+    // In this case:
+    //   EXE -> INTERMEDIATE_SHLIB --[public]--> FINAL_SHLIB
+    // The EXE will also link to to FINAL_SHLIB. The public dependeny means
+    // that the EXE can use the headers in FINAL_SHLIB so the FINAL_SHLIB
+    // will need to appear on EXE's link line.
+    //
+    // However, if the dependency is private:
+    //   EXE -> INTERMEDIATE_SHLIB --[private]--> FINAL_SHLIB
+    // the dependency will not be propogated because INTERMEDIATE_SHLIB is
+    // not granting permission to call functiosn from FINAL_SHLIB. If EXE
+    // wants to use functions (and link to) FINAL_SHLIB, it will need to do
+    // so explicitly.
+    //
+    // Static libraries and source sets aren't inherited across shared
+    // library boundaries because they will be linked into the shared
+    // library.
+    inherited_libraries_.AppendPublicSharedLibraries(
+        dep->inherited_libraries(), is_public);
+  } else if (!dep->IsFinal()) {
+    // The current target isn't linked, so propogate linked deps and
+    // libraries up the dependency tree.
+    inherited_libraries_.AppendInherited(dep->inherited_libraries(), is_public);
 
-      // Inherited library settings.
-      all_lib_dirs_.append(dep->all_lib_dirs());
-      all_libs_.append(dep->all_libs());
-    }
+    // Inherited library settings.
+    all_lib_dirs_.append(dep->all_lib_dirs());
+    all_libs_.append(dep->all_libs());
   }
 }
 
+void Target::PullDependentTargets() {
+  for (const auto& dep : public_deps_)
+    PullDependentTarget(dep.ptr, true);
+  for (const auto& dep : private_deps_)
+    PullDependentTarget(dep.ptr, false);
+}
+
 void Target::PullForwardedDependentConfigs() {
   // Pull public configs from each of our dependency's public deps.
   for (const auto& dep : public_deps_)
     PullForwardedDependentConfigsFrom(dep.ptr);
 
   // Forward public configs if explicitly requested.
   for (const auto& dep : forward_dependent_configs_) {
     const Target* from_target = dep.ptr;
 
     // The forward_dependent_configs_ must be in the deps (public or private)
@@ skipping 123 matching lines @@
 
   // Verify no deps are static libraries.
   for (const auto& pair : GetDeps(DEPS_ALL)) {
     if (pair.ptr->output_type() == Target::STATIC_LIBRARY) {
       *err = MakeStaticLibDepsError(this, pair.ptr);
       return false;
     }
   }
 
   // Verify no inherited libraries are static libraries.
-  for (const auto& lib : inherited_libraries()) {
+  for (const auto& lib : inherited_libraries().GetOrdered()) {
     if (lib->output_type() == Target::STATIC_LIBRARY) {
       *err = MakeStaticLibDepsError(this, lib);
       return false;
     }
   }
   return true;
 }