Remove some old support for PNaCl Scons browser tests.

ppapi/native_client/chrome_main.scons

 #! -*- python -*-
 # Copyright (c) 2012 The Native Client Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import json
 import os
 import shutil
 import sys
 
@@ skipping 155 matching lines @@
 def CopyLibsForExtensionCommand(target, source, env):
   source_manifest = str(source[0])
   target_manifest = str(target[0])
   shutil.copyfile(source_manifest, target_manifest)
   target_dir = os.path.dirname(target_manifest)
   libs_file = open(str(source[1]), 'r')
   for line in libs_file.readlines():
     lib_info = ParseLibInfoInRunnableLdLog(line)
     if lib_info:
       lib_name, lib_path = lib_info
-      # Note: This probably does NOT work with pnacl _pexes_ right now, because
-      # the NEEDED metadata in the bitcode doesn't have the original file paths.
-      # This should probably be done without such knowledge.
       if lib_path == 'NaClMain':
         # This is a fake file name, which we cannot copy.
         continue
       shutil.copyfile(lib_path, os.path.join(target_dir, lib_name))
   shutil.copyfile(env.subst('${NACL_SDK_LIB}/runnable-ld.so'),
                   os.path.join(target_dir, 'runnable-ld.so'))
   libs_file.close()
 
 
 # Extensions are loaded from directory on disk and so all dynamic libraries
@@ skipping 96 matching lines @@
   obj['files']['main.nexe'] = {}
   for k, v in obj['program'].items():
     obj['files']['main.nexe'][k] = v.copy()
     v['url'] = 'runnable-ld.so'
   # Write the new manifest!
   target_file = open(str(target[0]), 'w')
   json.dump(obj, target_file, sort_keys=True, indent=2)
   target_file.close()
   return 0
 
-def GenerateManifestPnacl(env, dest_file, manifest, exe_file):
-  return env.Command(
-      dest_file,
-      ['${GENNMF}', exe_file, manifest],
-      # Generate a flat url scheme to simplify file-staging.
-      ('${SOURCES[0]} ${SOURCES[1]} -L${NACL_SDK_LIB} -L${LIB_DIR} '
-       ' --flat-url-scheme --base-nmf ${SOURCES[2]} -o ${TARGET}'))
 
 def GenerateManifestDynamicLink(env, dest_file, lib_list_file,
                                 manifest, exe_file):
   # Run sel_ldr on the nexe to trace the NEEDED libraries.
   lib_list_node = env.Command(
       lib_list_file,
       [env.GetSelLdr(),
        '${NACL_SDK_LIB}/runnable-ld.so',
        exe_file,
        '${SCONSTRUCT_DIR}/DEPS'],
@@ skipping 17 matching lines @@
     fh.close()
   node = env.Command(dest_file, [], Func)[0]
   # Scons does not track the dependency of dest_file on exe_name or on
   # the Python code above, so we should always recreate dest_file when
   # it is used.
   env.AlwaysBuild(node)
   return node
 
 
 def GenerateSimpleManifest(env, dest_file, exe_name):
-  if env.Bit('pnacl_generate_pexe'):
-    static_manifest = GenerateSimpleManifestStaticLink(
-        env, '%s.static' % dest_file, exe_name)
-    return GenerateManifestPnacl(env, dest_file, static_manifest,
-                                 '${STAGING_DIR}/%s.pexe' %
-                                 env.ProgramNameForNmf(exe_name))
-  elif env.Bit('nacl_static_link'):
+  if env.Bit('nacl_static_link'):
     return GenerateSimpleManifestStaticLink(env, dest_file, exe_name)
   else:
     static_manifest = GenerateSimpleManifestStaticLink(
         env, '%s.static' % dest_file, exe_name)
     return GenerateManifestDynamicLink(
         env, dest_file, '%s.tmp_lib_list' % dest_file, static_manifest,
         '${STAGING_DIR}/%s.nexe' % env.ProgramNameForNmf(exe_name))
 
 pre_base_env.AddMethod(GenerateSimpleManifest)
 
 
 # Returns a pair (main program, is_portable), based on the program
 # specified in manifest file.
 def GetMainProgramFromManifest(env, manifest):
   obj = json.loads(env.File(manifest).get_contents())
   program_dict = obj['program']
-  if env.Bit('pnacl_generate_pexe') and 'portable' in program_dict:
-    return program_dict['portable']['pnacl-translate']['url']
-  else:
-    return program_dict[env.subst('${TARGET_FULLARCH}')]['url']
+  return program_dict[env.subst('${TARGET_FULLARCH}')]['url']
 
 
 # Returns scons node for generated manifest.
 def GeneratedManifestNode(env, manifest):
   manifest = env.subst(manifest)
   manifest_base_name = os.path.basename(manifest)
   main_program = GetMainProgramFromManifest(env, manifest)
   result = env.File('${STAGING_DIR}/' + manifest_base_name)
-  # Always generate the manifest for nacl_glibc and pnacl pexes.
+  # Always generate the manifest for nacl_glibc.
   # For nacl_glibc, generating the mapping of shared libraries is non-trivial.
-  # For pnacl, the manifest currently hosts a sha for the pexe.
-  if not env.Bit('nacl_glibc') and not env.Bit('pnacl_generate_pexe'):
+  if not env.Bit('nacl_glibc'):
     env.Install('${STAGING_DIR}', manifest)
     return result
-  if env.Bit('pnacl_generate_pexe'):
-    return GenerateManifestPnacl(
-        env,
-        '${STAGING_DIR}/' + manifest_base_name,
-        manifest,
-        env.File('${STAGING_DIR}/' + os.path.basename(main_program)))
-  else:
-    return GenerateManifestDynamicLink(
-        env, '${STAGING_DIR}/' + manifest_base_name,
-        # Note that CopyLibsForExtension() and WhitelistLibsForExtension()
-        # assume that it can find the library list file under this filename.
-        GlibcManifestLibsListFilename(manifest_base_name),
-        manifest,
-        env.File('${STAGING_DIR}/' + os.path.basename(main_program)))
+  return GenerateManifestDynamicLink(
+      env, '${STAGING_DIR}/' + manifest_base_name,
+      # Note that CopyLibsForExtension() and WhitelistLibsForExtension()
+      # assume that it can find the library list file under this filename.
+      GlibcManifestLibsListFilename(manifest_base_name),
+      manifest,
+      env.File('${STAGING_DIR}/' + os.path.basename(main_program)))
   return result
 
 
 # Compares output_file and golden_file.
 # If they are different, prints the difference and returns 1.
 # Otherwise, returns 0.
 def CheckGoldenFile(golden_file, output_file,
                     filter_regex, filter_inverse, filter_group_only):
   golden = open(golden_file).read()
   actual = open(output_file).read()
@@ skipping 50 matching lines @@
 
   # No browser tests run on arm-thumb2
   # Bug http://code.google.com/p/nativeclient/issues/detail?id=2224
   if env.Bit('target_arm_thumb2'):
     return []
 
   # Handle issues with mutating any python default arg lists.
   if browser_flags is None:
     browser_flags = []
 
-  if env.Bit('pnacl_generate_pexe'):
-    # We likely prefer to choose the 'portable' field in nmfs in this mode.
-    args = args + ['--prefer_portable_in_manifest']
-
   # Lint the extra arguments that are being passed to the tester.
   special_args = ['--ppapi_plugin', '--sel_ldr', '--irt_library', '--file',
                   '--map_file', '--extension', '--mime_type', '--tool',
                   '--browser_flag', '--test_arg']
   for arg_name in special_args:
     if arg_name in args:
       raise Exception('%s: %r is a test argument provided by the SCons test'
                       ' wrapper, do not specify it as an additional argument' %
                       (target, arg_name))
 
@@ skipping 121 matching lines @@
 
 pre_base_env.AddMethod(PPAPIGraphics3DIsBroken)
 
 
 def AddChromeFilesFromGroup(env, file_group):
   env['BUILD_SCONSCRIPTS'] = ExtendFileList(
       env.get('BUILD_SCONSCRIPTS', []),
       ppapi_scons_files[file_group])
 
 pre_base_env.AddMethod(AddChromeFilesFromGroup)