Fixes two bugs in analyzer

pylib/gyp/generator/analyzer.py

 # Copyright (c) 2014 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.
 
 """
 This script is intended for use as a GYP_GENERATOR. It takes as input (by way of
 the generator flag file_path) the list of relative file paths to consider. If
 any target has at least one of the paths as a source (or input to an action or
 rule) then 'Found dependency' is output, otherwise 'No dependencies' is output.
 """
@@ skipping 37 matching lines @@
     path = path[0:len(path) - len('#target')]
   return path
 
 def __ExtractBasePath(target):
   """Extracts the path components of the specified gyp target path."""
   last_index = target.rfind('/')
   if last_index == -1:
     return ''
   return target[0:(last_index + 1)]
 
+def __ResolveParent(path, base_path_components):
+  """Resolves |path|, which starts with at least one '../'. Returns an empty
+  string if the path shouldn't be considered. See __AddSources() for a
+  description of |base_path_components|."""
+  depth = 0
+  while path.startswith('../'):
+    depth += 1
+    path = path[3:]
+  # Relative includes may go outside the source tree. For example, an action may
+  # have inputs in /usr/include, which are not in the source tree.
+  if depth > len(base_path_components):
+    return ''
+  if depth == len(base_path_components):
+    return path
+  return '/'.join(base_path_components[0:len(base_path_components) - depth]) + \
+      '/' + path
+
 def __AddSources(sources, base_path, base_path_components, result):
   """Extracts valid sources from |sources| and adds them to |result|. Each
   source file is relative to |base_path|, but may contain '..'. To make
   resolving '..' easier |base_path_components| contains each of the
   directories in |base_path|. Additionally each source may contain variables.
   Such sources are ignored as it is assumed dependencies on them are expressed
   and tracked in some other means."""
   # NOTE: gyp paths are always posix style.
   for source in sources:
     if not len(source) or source.startswith('!!!') or source.startswith('$'):
       continue
     # variable expansion may lead to //.
     source = source[0] + source[1:].replace('//', '/')
     if source.startswith('../'):
-      path_components = base_path_components[:]
-      # Resolve relative paths.
-      while source.startswith('../'):
-        path_components.pop(len(path_components) - 1)
-        source = source[3:]
-      result.append('/'.join(path_components) + source)
+      source = __ResolveParent(source, base_path_components)
+      if len(source):
+        result.append(source)
       continue
     result.append(base_path + source)
 
 def __ExtractSourcesFromAction(action, base_path, base_path_components,
                                results):
   if 'inputs' in action:
     __AddSources(action['inputs'], base_path, base_path_components, results)
 
 def __ExtractSources(target, target_dict):
   base_path = posixpath.dirname(target)
@@ skipping 106 matching lines @@
 
   files_set = frozenset(files)
   found_in_all_sources = 0
   for target_name, target in targets.iteritems():
     sources = files_set.intersection(target.sources)
     if len(sources):
       print 'Found dependency'
       return
 
   print 'No dependencies'