[iOS] Add application target as dependency of xctest module target.

tools/gn/xcode_object.cc

 // Copyright 2016 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/xcode_object.h"
 
 #include <iomanip>
 #include <sstream>
 #include <utility>
 
@@ skipping 226 matching lines @@
 }  // namespace
 
 // PBXObjectClass -------------------------------------------------------------
 
 const char* ToString(PBXObjectClass cls) {
   switch (cls) {
     case PBXAggregateTargetClass:
       return "PBXAggregateTarget";
     case PBXBuildFileClass:
       return "PBXBuildFile";
+    case PBXContainerItemProxyClass:
+      return "PBXContainerItemProxy";
     case PBXFileReferenceClass:
       return "PBXFileReference";
     case PBXFrameworksBuildPhaseClass:
       return "PBXFrameworksBuildPhase";
     case PBXGroupClass:
       return "PBXGroup";
     case PBXNativeTargetClass:
       return "PBXNativeTarget";
     case PBXProjectClass:
       return "PBXProject";
     case PBXShellScriptBuildPhaseClass:
       return "PBXShellScriptBuildPhase";
     case PBXSourcesBuildPhaseClass:
       return "PBXSourcesBuildPhase";
+    case PBXTargetDependencyClass:
+      return "PBXTargetDependency";
     case XCBuildConfigurationClass:
       return "XCBuildConfiguration";
     case XCConfigurationListClass:
       return "XCConfigurationList";
   }
   NOTREACHED();
   return nullptr;
 }
 
 // PBXObjectVisitor -----------------------------------------------------------
@@ skipping 45 matching lines @@
     : configurations_(new XCConfigurationList(config_name, attributes, this)),
       name_(name) {
   if (!shell_script.empty()) {
     build_phases_.push_back(
         base::MakeUnique<PBXShellScriptBuildPhase>(name, shell_script));
   }
 }
 
 PBXTarget::~PBXTarget() {}
 
+void PBXTarget::AddDependency(std::unique_ptr<PBXTargetDependency> dependency) {
+  DCHECK(dependency);
+  dependencies_.push_back(std::move(dependency));
+}
+
 std::string PBXTarget::Name() const {
   return name_;
 }
 
 void PBXTarget::Visit(PBXObjectVisitor& visitor) {
   PBXObject::Visit(visitor);
   configurations_->Visit(visitor);
-  for (const auto& build_phase : build_phases_) {
+  for (const auto& dependency : dependencies_)
+    dependency->Visit(visitor);
+  for (const auto& build_phase : build_phases_)
     build_phase->Visit(visitor);
-  }
 }
 
 // PBXAggregateTarget ---------------------------------------------------------
 
 PBXAggregateTarget::PBXAggregateTarget(const std::string& name,
                                        const std::string& shell_script,
                                        const std::string& config_name,
                                        const PBXAttributes& attributes)
     : PBXTarget(name, shell_script, config_name, attributes) {}
 
@@ skipping 46 matching lines @@
   PrintProperty(out, rules, "fileRef", file_reference_);
   if (compiler_flag_ == CompilerFlags::HELP) {
     std::map<std::string, std::string> settings = {
         {"COMPILER_FLAGS", "--help"},
     };
     PrintProperty(out, rules, "settings", settings);
   }
   out << "};\n";
 }
 
+// PBXContainerItemProxy ------------------------------------------------------
+PBXContainerItemProxy::PBXContainerItemProxy(const PBXProject* project,
+                                             const PBXTarget* target)
+    : project_(project), target_(target) {}
+
+PBXContainerItemProxy::~PBXContainerItemProxy() {}
+
+PBXObjectClass PBXContainerItemProxy::Class() const {
+  return PBXContainerItemProxyClass;
+}
+
+void PBXContainerItemProxy::Visit(PBXObjectVisitor& visitor) {
+  PBXObject::Visit(visitor);
+}
+
+std::string PBXContainerItemProxy::Name() const {
+  return "PBXContainerItemProxy";
+}
+
+void PBXContainerItemProxy::Print(std::ostream& out, unsigned indent) const {
+  const std::string indent_str(indent, '\t');
+  const IndentRules rules = {true, 0};
+  out << indent_str << Reference() << " = {";
+  PrintProperty(out, rules, "isa", ToString(Class()));
+  PrintProperty(out, rules, "containerPortal", project_);
+  PrintProperty(out, rules, "proxyType", 1u);
+  PrintProperty(out, rules, "remoteGlobalIDString", target_);
+  PrintProperty(out, rules, "remoteInfo", target_->Name());
+  out << indent_str << "};\n";
+}
+
 // PBXFileReference -----------------------------------------------------------
 
 PBXFileReference::PBXFileReference(const std::string& name,
                                    const std::string& path,
                                    const std::string& type)
     : name_(name), path_(path), type_(type) {}
 
 PBXFileReference::~PBXFileReference() {}
 
 PBXObjectClass PBXFileReference::Class() const {
@@ skipping 185 matching lines @@
 }
 
 void PBXNativeTarget::Print(std::ostream& out, unsigned indent) const {
   const std::string indent_str(indent, '\t');
   const IndentRules rules = {false, indent + 1};
   out << indent_str << Reference() << " = {\n";
   PrintProperty(out, rules, "isa", ToString(Class()));
   PrintProperty(out, rules, "buildConfigurationList", configurations_);
   PrintProperty(out, rules, "buildPhases", build_phases_);
   PrintProperty(out, rules, "buildRules", EmptyPBXObjectVector());
-  PrintProperty(out, rules, "dependencies", EmptyPBXObjectVector());
+  PrintProperty(out, rules, "dependencies", dependencies_);
   PrintProperty(out, rules, "name", name_);
   PrintProperty(out, rules, "productName", product_name_);
   PrintProperty(out, rules, "productReference", product_reference_);
   PrintProperty(out, rules, "productType", product_type_);
   out << indent_str << "};\n";
 }
 
 // PBXProject -----------------------------------------------------------------
 
 PBXProject::PBXProject(const std::string& name,
@@ skipping 218 matching lines @@
   const std::string indent_str(indent, '\t');
   const IndentRules rules = {false, indent + 1};
   out << indent_str << Reference() << " = {\n";
   PrintProperty(out, rules, "isa", ToString(Class()));
   PrintProperty(out, rules, "buildActionMask", 0x7fffffffu);
   PrintProperty(out, rules, "files", files_);
   PrintProperty(out, rules, "runOnlyForDeploymentPostprocessing", 0u);
   out << indent_str << "};\n";
 }
 
+PBXTargetDependency::PBXTargetDependency(
+    const PBXTarget* target,
+    std::unique_ptr<PBXContainerItemProxy> container_item_proxy)
+    : target_(target), container_item_proxy_(std::move(container_item_proxy)) {}
+
+PBXTargetDependency::~PBXTargetDependency() {}
+
+PBXObjectClass PBXTargetDependency::Class() const {
+  return PBXTargetDependencyClass;
+}
+std::string PBXTargetDependency::Name() const {
+  return "PBXTargetDependency";
+}
+void PBXTargetDependency::Visit(PBXObjectVisitor& visitor) {
+  PBXObject::Visit(visitor);
+  container_item_proxy_->Visit(visitor);
+}
+void PBXTargetDependency::Print(std::ostream& out, unsigned indent) const {
+  const std::string indent_str(indent, '\t');
+  const IndentRules rules = {false, indent + 1};
+  out << indent_str << Reference() << " = {\n";
+  PrintProperty(out, rules, "isa", ToString(Class()));
+  PrintProperty(out, rules, "target", target_);
+  PrintProperty(out, rules, "targetProxy", container_item_proxy_);
+  out << indent_str << "};\n";
+}
+
 // XCBuildConfiguration -------------------------------------------------------
 
 XCBuildConfiguration::XCBuildConfiguration(const std::string& name,
                                            const PBXAttributes& attributes)
     : attributes_(attributes), name_(name) {}
 
 XCBuildConfiguration::~XCBuildConfiguration() {}
 
 PBXObjectClass XCBuildConfiguration::Class() const {
   return XCBuildConfigurationClass;
@@ skipping 49 matching lines @@
   const std::string indent_str(indent, '\t');
   const IndentRules rules = {false, indent + 1};
   out << indent_str << Reference() << " = {\n";
   PrintProperty(out, rules, "isa", ToString(Class()));
   PrintProperty(out, rules, "buildConfigurations", configurations_);
   PrintProperty(out, rules, "defaultConfigurationIsVisible", 1u);
   PrintProperty(out, rules, "defaultConfigurationName",
                 configurations_[0]->Name());
   out << indent_str << "};\n";
 }