ninja/mac: Let copies sections that copy stuff inside a bundle mark the bundle as dirty.

pylib/gyp/generator/ninja.py

 # Copyright (c) 2012 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import copy
 import hashlib
 import multiprocessing
 import os.path
 import re
 import signal
@@ skipping 491 matching lines @@
     outputs = []
     extra_mac_bundle_resources = []
 
     if 'actions' in spec:
       outputs += self.WriteActions(spec['actions'], extra_sources, prebuild,
                                    extra_mac_bundle_resources)
     if 'rules' in spec:
       outputs += self.WriteRules(spec['rules'], extra_sources, prebuild,
                                  extra_mac_bundle_resources)
     if 'copies' in spec:
-      outputs += self.WriteCopies(spec['copies'], prebuild)
+      outputs += self.WriteCopies(spec['copies'], prebuild, mac_bundle_depends)
 
     if 'sources' in spec and self.flavor == 'win':
       outputs += self.WriteWinIdlFiles(spec, prebuild)
 
     stamp = self.WriteCollapsedDependencies('actions_rules_copies', outputs)
 
     if self.is_mac_bundle:
       mac_bundle_resources = spec.get('mac_bundle_resources', []) + \
                              extra_mac_bundle_resources
       self.WriteMacBundleResources(mac_bundle_resources, mac_bundle_depends)
@@ skipping 134 matching lines @@
             hashlib.md5(outputs[0]).hexdigest()))
         self.ninja.build(outputs, rule_name, self.GypPathToNinja(source),
                          implicit=inputs,
                          order_only=prebuild,
                          variables=extra_bindings)
 
         all_outputs.extend(outputs)
 
     return all_outputs
 
-  def WriteCopies(self, copies, prebuild):
+  def WriteCopies(self, copies, prebuild, mac_bundle_depends):
     outputs = []
     env = self.GetSortedXcodeEnv()
     for copy in copies:
       for path in copy['files']:
         # Normalize the path so trailing slashes don't confuse us.
         path = os.path.normpath(path)
         basename = os.path.split(path)[1]
         src = self.GypPathToNinja(path, env)
         dst = self.GypPathToNinja(os.path.join(copy['destination'], basename),
                                   env)
         outputs += self.ninja.build(dst, 'copy', src, order_only=prebuild)
+        if self.is_mac_bundle:
+          # gyp has mac_bundle_resources to copy things into a bundle's
+          # Resources folder, but there's no built-in way to copy files to other
+          # places in the bundle. Hence, some targets use copies for this. Check
+          # if this file is copied into the current bundle, and if so add it to
+          # the bundle depends so that dependent targets get rebuilt if the copy
+          # input changes.
+          if dst.startswith(self.xcode_settings.GetBundleContentsFolderPath()):
+            mac_bundle_depends.append(dst)
 
     return outputs
 
   def WriteMacBundleResources(self, resources, bundle_depends):
     """Writes ninja edges for 'mac_bundle_resources'."""
     for output, res in gyp.xcode_emulation.GetMacBundleResources(
         self.ExpandSpecial(generator_default_variables['PRODUCT_DIR']),
         self.xcode_settings, map(self.GypPathToNinja, resources)):
       self.ninja.build(output, 'mac_tool', res,
                        variables=[('mactool_cmd', 'copy-bundle-resource')])
@@ skipping 1091 matching lines @@
           arglists.append(
               (target_list, target_dicts, data, params, config_name))
           pool.map(CallGenerateOutputForConfig, arglists)
       except KeyboardInterrupt, e:
         pool.terminate()
         raise e
     else:
       for config_name in config_names:
         GenerateOutputForConfig(target_list, target_dicts, data, params,
                                 config_name)