public FileWithSections(IFileSystem fileSystem, FullPath filename)
 {
     _fileSystem = fileSystem;
       _filename = filename;
       _fileUpdateVolatileToken = new FileUpdateVolatileToken(_fileSystem, filename);
       _sections = new Lazy<Dictionary<string, List<string>>>(ReadFile);
 }

    public void LoadProcesses() {
      _processes.Clear();
      List<ChromiumProcess> chromes = new List<ChromiumProcess>();
      HashSet<int> chromePids = new HashSet<int>();
      foreach (Process p in Process.GetProcesses()) {
        // System.Diagnostics.Process uses a naive implementation that is unable to deal with many
        // types of processes (such as those already under a debugger, or those with a high
        // privilege level), so use NtProcess instead.
        NtProcess ntproc = new NtProcess(p.Id);
        if (!ntproc.IsValid)
          continue;

        FullPath processPath = new FullPath(ntproc.Win32ProcessImagePath);
        if (processPath.StartsWith(_installationData.InstallationPath)) {
          chromes.Add(new ChromiumProcess(ntproc, _installationData));
          chromePids.Add(p.Id);
        }
      }

      foreach (ChromiumProcess chrome in chromes) {
        // Only insert root processes at this level, child processes will be children of one of
        // these processes.
        if (!chromePids.Contains(chrome.ParentPid)) {
          ChromeProcessViewModel viewModel = new ChromeProcessViewModel(_root, chrome);
          viewModel.LoadProcesses(chromes.ToArray());
          _processes.Add(viewModel);
        }
      }
    }

 public IProject GetProjectFromRootPath(FullPath projectRootPath)
 {
     var name = projectRootPath;
       lock (_lock) {
     return _knownProjectRootDirectories.Get(name);
       }
 }

    private void CreateEntries(DirectoryEntry searchResults) {
      if (!_enabled)
        return;

      using (new TimeElapsedLogger("Creating document tracking entries for search results")) {
        _searchResults.Clear();
        foreach (DirectoryEntry projectRoot in searchResults.Entries) {
          var rootPath = new FullPath(projectRoot.Name);
          foreach (FileEntry fileEntry in projectRoot.Entries) {
            var path = rootPath.Combine(new RelativePath(fileEntry.Name));
            var spans = fileEntry.Data as FilePositionsData;
            if (spans != null) {
              _searchResults[path] = spans;

              // If the document is open, create the tracking spans now.
              var document = _textDocumentTable.GetOpenDocument(path);
              if (document != null) {
                var entry = new DocumentChangeTrackingEntry(spans);
                _trackingEntries[path] = entry;
                entry.CreateTrackingSpans(document.TextBuffer);
              }
            }
          }
        }
      }
    }

 public PathChangeKind GetPathChangeKind(FullPath path) {
   PathChangeKind result;
   if (!_map.Value.TryGetValue(path, out result)) {
     result = PathChangeKind.None;
   }
   return result;
 }

 private IEnumerable<FullPath> EnumerateParents(FullPath path)
 {
     var directory = path.Parent;
       for (var parent = directory; parent != default(FullPath); parent = parent.Parent) {
     yield return parent;
       }
 }

    private bool FetchRunningDocumentTable() {
      var rdt = new RunningDocumentTable(_serviceProvider);
      foreach (var info in rdt) {
        // Get doc data
        if (!FullPath.IsValid(info.Moniker))
          continue;

        var path = new FullPath(info.Moniker);
        if (_openDocuments.ContainsKey(path))
          continue;

        // Get vs buffer
        IVsTextBuffer docData = null;
        try {
          docData = info.DocData as IVsTextBuffer;
        }
        catch (Exception e) {
          Logger.LogWarning(e, "Error getting IVsTextBuffer for document {0}, skipping document", path);
        }
        if (docData == null)
          continue;

        // Get ITextDocument
        var textBuffer = _vsEditorAdaptersFactoryService.GetDocumentBuffer(docData);
        if (textBuffer == null)
          continue;

        ITextDocument document;
        if (!_textDocumentFactoryService.TryGetTextDocument(textBuffer, out document))
          continue;

        _openDocuments[path] = document;
      }
      return true;
    }

 public FileWithSections(IFileSystem fileSystem, FullPath filename) {
   _fileSystem = fileSystem;
   _filename = filename;
   _fileLines = new Lazy<IList<string>>(ReadFileLines);
   _hash = new Lazy<string>(ComputeHash);
   _sections = new Lazy<Dictionary<string, List<string>>>(ReadFile);
 }

        private FileContents ReadFile(FullPath fullName)
        {
            try {
            var fileInfo = new SlimFileInfo(fullName);
            const int trailingByteCount = 2;
            var block = NativeFile.ReadFileNulTerminated(fileInfo, trailingByteCount);
            var contentsByteCount = (int)block.ByteLength - trailingByteCount; // Padding added by ReadFileNulTerminated
            var kind = NativeMethods.Text_GetKind(block.Pointer, contentsByteCount);

            switch (kind) {
              case NativeMethods.TextKind.Ascii:
            return new AsciiFileContents(new FileContentsMemory(block, 0, contentsByteCount), fileInfo.LastWriteTimeUtc);

              case NativeMethods.TextKind.AsciiWithUtf8Bom:
            const int utf8BomSize = 3;
            return new AsciiFileContents(new FileContentsMemory(block, utf8BomSize, contentsByteCount - utf8BomSize), fileInfo.LastWriteTimeUtc);

              case NativeMethods.TextKind.Utf8WithBom:
            var utf16Block = Conversion.UTF8ToUnicode(block);
            block.Dispose();
            return new UTF16FileContents(new FileContentsMemory(utf16Block, 0, utf16Block.ByteLength), fileInfo.LastWriteTimeUtc);

              case NativeMethods.TextKind.Unknown:
              default:
            // TODO(rpaquay): Figure out a better way to detect encoding.
            //Logger.Log("Text Encoding of file \"{0}\" is not recognized.", fullName);
            return new AsciiFileContents(new FileContentsMemory(block, 0, contentsByteCount), fileInfo.LastWriteTimeUtc);
            //throw new NotImplementedException(string.Format("Text Encoding of file \"{0}\" is not recognized.", fullName));
            }
              }
              catch (Exception e) {
            Logger.LogException(e, "Error reading content of text file \"{0}\", skipping file.", fullName);
            return StringFileContents.Empty;
              }
        }

    public DirectorySnapshot FindRootDirectory(FullPath rootPath) {
      var index = SortedArrayHelpers.BinarySearch(_snapshot.ProjectRoots, rootPath, ProjectRootComparer);
      if (index >= 0)
        return _snapshot.ProjectRoots[index].Directory;

      return null;
    }

    public DirectoryName CreateAbsoluteDirectoryName(FullPath rootPath) {
      var rootdirectory = FindRootDirectory(rootPath);
      if (rootdirectory != null)
        return rootdirectory.DirectoryName;

      return _previous.CreateAbsoluteDirectoryName(rootPath);
    }

    private void AddDirectory(FullPath directory) {
      FileSystemWatcher watcher;
      lock (_watchersLock) {
        if (_pollingThread == null) {
          _pollingThread = new Thread(ThreadLoop) { IsBackground = true };
          _pollingThread.Start();
        }
        if (_watchers.TryGetValue(directory, out watcher))
          return;

        watcher = new FileSystemWatcher();
        _watchers.Add(directory, watcher);
      }

      Logger.LogInfo("Starting monitoring directory \"{0}\" for change notifications.", directory);
      watcher.Path = directory.Value;
      watcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.DirectoryName | NotifyFilters.FileName;
      watcher.IncludeSubdirectories = true;
      watcher.InternalBufferSize = 50 * 1024; // 50KB sounds more reasonable than 8KB
      watcher.Changed += WatcherOnChanged;
      watcher.Created += WatcherOnCreated;
      watcher.Deleted += WatcherOnDeleted;
      watcher.Renamed += WatcherOnRenamed;
      watcher.Error += WatcherOnError;
      watcher.EnableRaisingEvents = true;
    }

 public IProject GetProject(FullPath filename) {
   return _providers
     .Select(t => t.GetProjectFromAnyPath(filename))
     .Where(project => project != null)
     .OrderByDescending(p => p.RootPath.Value.Length)
     .FirstOrDefault();
 }

 public Options(FullPath fullPath)
 {
    
     Path = fullPath.RelativePath;
     Url = fullPath.Root.Url;
     ThumbnailsUrl = fullPath.Root.TmbUrl;
 }

    public bool ApplyCodingStyle(string filename) {
      var path = new FullPath(filename);
      var root = _chromiumDiscoveryProvider.GetEnlistmentRootFromFilename(path, x => x);
      if (root == default(FullPath))
        return false;

      return _applyCodingStyleResults.GetOrAdd(filename, (key) => ApplyCodingStyleWorker(root, key));
    }

    public FullPath GetEnlistmentRoot(FullPath filename) {
      var directory = filename.Parent;
      if (!_fileSystem.DirectoryExists(directory))
        return default(FullPath);

      return EnumerateParents(filename)
        .FirstOrDefault(x => IsChromiumSourceDirectory(x, _chromiumEnlistmentFilePatterns));
    }

 public Project(IConfigurationSectionProvider configurationSectionProvider, FullPath rootPath)
 {
     _rootPath = rootPath;
       _configurationToken = configurationSectionProvider.WhenUpdated();
       _directoryFilter = new DirectoryFilter(configurationSectionProvider);
       _fileFilter = new FileFilter(configurationSectionProvider);
       _searchableFilesFilter = new SearchableFilesFilter(configurationSectionProvider);
 }

 public static bool IsChromiumSourceDirectory(FullPath path, IPathPatternsFile chromiumEnlistmentPatterns)
 {
     // We need to ensure that all pattern lines are covered by at least one file/directory of |path|.
       IList<string> directories;
       IList<string> files;
       NativeFile.GetDirectoryEntries(path.Value, out directories, out files);
       return chromiumEnlistmentPatterns.GetPathMatcherLines()
     .All(item => MatchFileOrDirectory(item, directories, files));
 }

		public PhpSourceFile(FullPath root, FullPath fullPath)
		{
			root.EnsureNonEmpty("root");
			fullPath.EnsureNonEmpty("fullPath");

			this.fullPath = fullPath;
			this.relativePath = RelativePath.Empty;
			this.root = root;
		}

 public FileContents ReadFileContents(FullPath path) {
   try {
     var fileInfo = _fileSystem.GetFileInfoSnapshot(path);
     return ReadFileContentsWorker(fileInfo);
   }
   catch (Exception e) {
     Logger.LogWarning(e, "Error reading content of text file \"{0}\", skipping file.", path);
     return BinaryFileContents.Empty;
   }
 }