Propagate GN public shared libraries through shared libraries

tools/gn/target_unittest.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 "testing/gtest/include/gtest/gtest.h"
 #include "tools/gn/build_settings.h"
 #include "tools/gn/config.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/target.h"
 #include "tools/gn/test_with_scope.h"
@@ skipping 152 matching lines @@
   a.private_deps().push_back(LabelTargetPair(&b));
   b.private_deps().push_back(LabelTargetPair(&c));
   c.private_deps().push_back(LabelTargetPair(&d));
 
   ASSERT_TRUE(d.OnResolved(&err));
   ASSERT_TRUE(c.OnResolved(&err));
   ASSERT_TRUE(b.OnResolved(&err));
   ASSERT_TRUE(a.OnResolved(&err));
 
   // C should have D in its inherited libs.
-  const UniqueVector<const Target*>& c_inherited = c.inherited_libraries();
-  EXPECT_EQ(1u, c_inherited.size());
-  EXPECT_TRUE(c_inherited.IndexOf(&d) != static_cast<size_t>(-1));
+  std::vector<const Target*> c_inherited = c.inherited_libraries().GetOrdered();
+  ASSERT_EQ(1u, c_inherited.size());
+  EXPECT_EQ(&d, c_inherited[0]);
 
   // B should have C and D in its inherited libs.
-  const UniqueVector<const Target*>& b_inherited = b.inherited_libraries();
-  EXPECT_EQ(2u, b_inherited.size());
-  EXPECT_TRUE(b_inherited.IndexOf(&c) != static_cast<size_t>(-1));
-  EXPECT_TRUE(b_inherited.IndexOf(&d) != static_cast<size_t>(-1));
+  std::vector<const Target*> b_inherited = b.inherited_libraries().GetOrdered();
+  ASSERT_EQ(2u, b_inherited.size());
+  EXPECT_EQ(&c, b_inherited[0]);
+  EXPECT_EQ(&d, b_inherited[1]);
 
   // A should have B in its inherited libs, but not any others (the shared
   // library will include the static library and source set).
-  const UniqueVector<const Target*>& a_inherited = a.inherited_libraries();
-  EXPECT_EQ(1u, a_inherited.size());
-  EXPECT_TRUE(a_inherited.IndexOf(&b) != static_cast<size_t>(-1));
+  std::vector<const Target*> a_inherited = a.inherited_libraries().GetOrdered();
+  ASSERT_EQ(1u, a_inherited.size());
+  EXPECT_EQ(&b, a_inherited[0]);
 }
 
 TEST(Target, InheritCompleteStaticLib) {
   TestWithScope setup;
   Err err;
 
   // Create a dependency chain:
   //   A (executable) -> B (complete static lib) -> C (source set)
   Target a(setup.settings(), Label(SourceDir("//foo/"), "a"));
   a.set_output_type(Target::EXECUTABLE);
   a.visibility().SetPublic();
   a.SetToolchain(setup.toolchain());
   Target b(setup.settings(), Label(SourceDir("//foo/"), "b"));
   b.set_output_type(Target::STATIC_LIBRARY);
   b.visibility().SetPublic();
   b.set_complete_static_lib(true);
   b.SetToolchain(setup.toolchain());
   Target c(setup.settings(), Label(SourceDir("//foo/"), "c"));
   c.set_output_type(Target::SOURCE_SET);
   c.visibility().SetPublic();
   c.SetToolchain(setup.toolchain());
   a.public_deps().push_back(LabelTargetPair(&b));
   b.public_deps().push_back(LabelTargetPair(&c));
 
   ASSERT_TRUE(c.OnResolved(&err));
   ASSERT_TRUE(b.OnResolved(&err));
   ASSERT_TRUE(a.OnResolved(&err));
 
   // B should have C in its inherited libs.
-  const UniqueVector<const Target*>& b_inherited = b.inherited_libraries();
-  EXPECT_EQ(1u, b_inherited.size());
-  EXPECT_TRUE(b_inherited.IndexOf(&c) != static_cast<size_t>(-1));
+  std::vector<const Target*> b_inherited = b.inherited_libraries().GetOrdered();
+  ASSERT_EQ(1u, b_inherited.size());
+  EXPECT_EQ(&c, b_inherited[0]);
 
   // A should have B in its inherited libs, but not any others (the complete
   // static library will include the source set).
-  const UniqueVector<const Target*>& a_inherited = a.inherited_libraries();
+  std::vector<const Target*> a_inherited = a.inherited_libraries().GetOrdered();
   EXPECT_EQ(1u, a_inherited.size());
-  EXPECT_TRUE(a_inherited.IndexOf(&b) != static_cast<size_t>(-1));
+  EXPECT_EQ(&b, a_inherited[0]);
 }
 
 TEST(Target, InheritCompleteStaticLibNoDirectStaticLibDeps) {
   TestWithScope setup;
   Err err;
 
   // Create a dependency chain:
   //   A (complete static lib) -> B (static lib)
   Target a(setup.settings(), Label(SourceDir("//foo/"), "a"));
   a.set_output_type(Target::STATIC_LIBRARY);
@@ skipping 273 matching lines @@
   toolchain.SetTool(Toolchain::TYPE_SOLINK, solink_tool.Pass());
 
   Target target(setup.settings(), Label(SourceDir("//a/"), "a"));
   target.set_output_type(Target::SHARED_LIBRARY);
   target.SetToolchain(&toolchain);
   ASSERT_TRUE(target.OnResolved(&err));
 
   EXPECT_EQ("./liba.so", target.link_output_file().value());
   EXPECT_EQ("./liba.so.TOC", target.dependency_output_file().value());
 }
+
+// Shared libraries should be inherited across public shared liobrary
+// boundaries.
+TEST(Target, SharedInheritance) {
+  TestWithScope setup;
+  Err err;
+
+  // Create two leaf shared libraries.
+  Target pub(setup.settings(), Label(SourceDir("//foo/"), "pub"));
+  pub.set_output_type(Target::SHARED_LIBRARY);
+  pub.visibility().SetPublic();
+  pub.SetToolchain(setup.toolchain());
+  ASSERT_TRUE(pub.OnResolved(&err));
+
+  Target priv(setup.settings(), Label(SourceDir("//foo/"), "priv"));
+  priv.set_output_type(Target::SHARED_LIBRARY);
+  priv.visibility().SetPublic();
+  priv.SetToolchain(setup.toolchain());
+  ASSERT_TRUE(priv.OnResolved(&err));
+
+  // Intermediate shared library with the leaf shared libraries as
+  // dependencies, one public, one private.
+  Target inter(setup.settings(), Label(SourceDir("//foo/"), "inter"));
+  inter.set_output_type(Target::SHARED_LIBRARY);
+  inter.visibility().SetPublic();
+  inter.public_deps().push_back(LabelTargetPair(&pub));
+  inter.private_deps().push_back(LabelTargetPair(&priv));
+  inter.SetToolchain(setup.toolchain());
+  ASSERT_TRUE(inter.OnResolved(&err));
+
+  // The intermediate shared library should have both "pub" and "priv" in its
+  // inherited libraries.
+  std::vector<const Target*> inter_inherited =
+      inter.inherited_libraries().GetOrdered();
+  ASSERT_EQ(2u, inter_inherited.size());
+  EXPECT_EQ(&pub, inter_inherited[0]);
+  EXPECT_EQ(&priv, inter_inherited[1]);
+
+  // Make a toplevel executable target depending on the intermediate one.
+  Target exe(setup.settings(), Label(SourceDir("//foo/"), "exe"));
+  exe.set_output_type(Target::SHARED_LIBRARY);
+  exe.visibility().SetPublic();
+  exe.private_deps().push_back(LabelTargetPair(&inter));
+  exe.SetToolchain(setup.toolchain());
+  ASSERT_TRUE(exe.OnResolved(&err));
+
+  // The exe's inherited libraries should be "inter" (because it depended
+  // directly on it) and "pub" (because inter depended publicly on it).
+  std::vector<const Target*> exe_inherited =
+      exe.inherited_libraries().GetOrdered();
+  ASSERT_EQ(2u, exe_inherited.size());
+  EXPECT_EQ(&inter, exe_inherited[0]);
+  EXPECT_EQ(&pub, exe_inherited[1]);
+}