Updates to make install_third_party build gtest and gmock on windows.

build_tools/install_gtest/install_gtest.py

 #!/usr/bin/python
 # Copyright (c) 2010 The Native Client Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that be
 # found in the LICENSE file.
 
 """Install GTest and GMock that can be linked to a NaCl module.  By default
 this script builds both the 32- and 64-bit versions of the libraries, and
 installs them in <toolchain>/nacl/usr/lib and <toolchain>/nacl64/usr/lib.  The
 header files are also installed in <toolchain>/<ncal_spec>/usr/include.
 """
@@ skipping 55 matching lines @@
     print "Error retrieving %s" % url
     raise
 
   os.chdir(options.old_cwd)
 
 
 # Apply the patch files to the extracted GTest and GMock pacakges.
 def PatchAll(options):
   def Patch(abs_path, patch_file):
     print "Patching %s with: %s" % (abs_path, patch_file)
-    p = subprocess.Popen('chmod -R a+w . && patch -p0 < %s' % (patch_file),
+    command = ''
+    if (sys.platform == 'win32'):
+      command = 'patch -p0 < %s' % (patch_file)
+    else:
+      command = 'chmod -R a+w . && patch -p0 < %s' % (patch_file)
+    p = subprocess.Popen(command,
                          cwd=abs_path,
                          env=options.shell_env,
                          shell=True)
     assert p.wait() == 0
 
-  Patch(options.working_dir, os.path.join(options.script_dir, GTEST_PATCH_FILE))
-  Patch(options.working_dir, os.path.join(options.script_dir, GMOCK_PATCH_FILE))
+  patch_path = os.path.join(options.script_dir, GTEST_PATCH_FILE)
+  print 'about to patch with working_dir %s, patch: %s' % (options.working_dir,
+                                                           patch_path)
+  Patch(options.working_dir, patch_path)
+  Patch(options.working_dir, patch_path)
 
 
 # Build GTest and GMock, then install them into the toolchain.  Note that
 # GTest has to be built and installed into the toolchain before GMock can be
 # built, because GMock relies on headers from GTest.  This method sets up all
 # the necessary shell environment variables for the makefiles, such as CC and
 # CXX.
 def BuildAndInstallAll(options):
   def BuildInPath(abs_path, shell_env):
     # Run make clean and make in |abs_path|.  Assumes there is a makefile in
@@ skipping 85 matching lines @@
                               shell=True,
                               stdin=tar_cf.stdout)
     tar_copy_err = tar_xf.communicate()[1]
     InstallLib('libgmock.a', gmock_path, nacl_usr_lib, build_env)
 
 
 # Main driver method that creates a working directory, then downloads and
 # extracts GTest and GMock, patches and builds them both, then installs them
 # into the toolchain specified in |options.toolchain|.
 def InstallTestingLibs(options):
+  print 'Making working directory.'
   MakeWorkingDir(options)
   try:
+    print 'Downloading and Extracting gtest.'
     DownloadAndExtractAll(options)
+    print 'Patching gtest.'
     PatchAll(options)
   except:
+    # TODO(mlinck) improve this error
+    print 'An Error occurred'
     return 1
 
+  print 'Building and installing gtest.'
   BuildAndInstallAll(options)
   # Clean up.
+  print 'Cleaning up gtest install files.'
   shutil.rmtree(options.working_dir, ignore_errors=True)
   return 0
 
 
 # Parse the command-line args and set up the options object.  There are two
 # command-line switches:
 #   --toolchain=<path to the platform-specific toolchain>
 #               e.g.: --toolchain=../toolchain/mac-x86
 #               default is |TOOLCHAIN_AUTODETECT| which means try to determine
 #               the toolchain dir from |sys.platform|.
@@ skipping 24 matching lines @@
   options.shell_env = shell_env
   options.script_dir = os.path.abspath(os.path.dirname(__file__))
   options.toolchain = build_utils.NormalizeToolchain(options.toolchain)
   print "Installing testing libs into toolchain %s" % options.toolchain
 
   return InstallTestingLibs(options)
 
 
 if __name__ == '__main__':
   main(sys.argv[1:])