[Chromoting] Add ability to enable/disable GDrive support per-app in gyp.

remoting/webapp/build-webapp.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Creates a directory with with the unpacked contents of the remoting webapp.
 
 The directory will contain a copy-of or a link-to to all remoting webapp
 resources.  This includes HTML/JS and any plugin binaries. The script also
 massages resulting files appropriately with host plugin data. Finally,
@@ skipping 57 matching lines @@
                    '../../../third_party/jinja2'))
   sys.path.append(os.path.split(jinja2_path)[0])
   import jinja2
   (template_path, template_name) = os.path.split(input_file)
   include_paths = [template_path] + include_paths
   env = jinja2.Environment(loader=jinja2.FileSystemLoader(include_paths))
   template = env.get_template(template_name)
   rendered = template.render(context)
   io.open(output_file, 'w', encoding='utf-8').write(rendered)
 
-
 def buildWebApp(buildtype, version, destination, zip_path,
                 manifest_template, webapp_type, app_id, app_name,
-                app_description, files, locales, jinja_paths,
+                app_description, app_capabilities, files, locales, jinja_paths,
                 service_environment):
   """Does the main work of building the webapp directory and zipfile.
 
   Args:
     buildtype: the type of build ("Official", "Release" or "Dev").
     destination: A string with path to directory where the webapp will be
                  written.
     zipfile: A string with path to the zipfile to create containing the
              contents of |destination|.
     manifest_template: jinja2 template file for manifest.
     webapp_type: webapp type ("v1", "v2", "v2_pnacl" or "app_remoting").
     app_id: A string with the Remoting Application Id (only used for app
              remoting webapps). If supplied, it defaults to using the
              test API server.
     app_name: A string with the name of the application.
     app_description: A string with the description of the application.
+    app_capabilities: A set of strings naming the capabilities that should be
+                      enabled for this application.
     files: An array of strings listing the paths for resources to include
            in this webapp.
     locales: An array of strings listing locales, which are copied, along
              with their directory structure from the _locales directory down.
     jinja_paths: An array of paths to search for {%include} directives in
                  addition to the directory containing the manifest template.
     service_environment: Used to point the webApp to one of the
                          dev/test/staging/prod environments
   """
   # Ensure a fresh directory.
@@ skipping 201 matching lines @@
 
   # Set the correct API keys.
   # For overriding the client ID/secret via env vars, see google_api_keys.py.
   apiClientId = google_api_keys.GetClientID('REMOTING')
   apiClientSecret = google_api_keys.GetClientSecret('REMOTING')
   apiClientIdV2 = google_api_keys.GetClientID('REMOTING_IDENTITY_API')
 
   replaceString(destination, 'API_CLIENT_ID', apiClientId)
   replaceString(destination, 'API_CLIENT_SECRET', apiClientSecret)
 
+  # Write the application capabilities.
+  appCapabilities = ','.join(
+      ['remoting.ClientSession.Capability.' + x for x in app_capabilities])
+  findAndReplace(os.path.join(destination, 'app_capabilities.js'),
+                 "'APPLICATION_CAPABILITIES'", appCapabilities)
+
   # Use a consistent extension id for dev builds.
   # AppRemoting builds always use the dev app id - the correct app id gets
   # written into the manifest later.
   if buildtype != 'Official' or webapp_type == 'app_remoting':
     manifestKey = '"key": "remotingdevbuild",'
   else:
     manifestKey = ''
 
   # Generate manifest.
   if manifest_template:
     context = {
         'webapp_type': webapp_type,
         'FULL_APP_VERSION': version,
         'MANIFEST_KEY_FOR_UNOFFICIAL_BUILD': manifestKey,
         'OAUTH2_REDIRECT_URL': oauth2RedirectUrlJson,
         'TALK_GADGET_HOST': talkGadgetHostJson,
         'THIRD_PARTY_AUTH_REDIRECT_URL': thirdPartyAuthUrlJson,
         'REMOTING_IDENTITY_API_CLIENT_ID': apiClientIdV2,
         'OAUTH2_BASE_URL': oauth2BaseUrl,
         'OAUTH2_API_BASE_URL': oauth2ApiBaseUrl,
         'DIRECTORY_API_BASE_URL': directoryApiBaseUrl,
         'APP_REMOTING_API_BASE_URL': appRemotingApiBaseUrl,
         'OAUTH2_ACCOUNTS_HOST': oauth2AccountsHost,
         'GOOGLE_API_HOSTS': googleApiHosts,
         'APP_NAME': app_name,
         'APP_DESCRIPTION': app_description,
+        'OAUTH_GDRIVE_SCOPE': '',
     }
+    if 'GOOGLE_DRIVE' in app_capabilities:
+      context['OAUTH_GDRIVE_SCOPE'] = ('https://docs.google.com/feeds/ '
+                                       'https://www.googleapis.com/auth/drive')
     processJinjaTemplate(manifest_template,
                          jinja_paths,
                          os.path.join(destination, 'manifest.json'),
                          context)
 
   # Make the zipfile.
   createZip(zip_path, destination)
 
   return 0
 
 
 def main():
   if len(sys.argv) < 6:
     print ('Usage: build-webapp.py '
            '<build-type> <version> <dst> <zip-path> <manifest_template> '
            '<webapp_type> <other files...> '
            '--app_name <name> '
            '--app_description <description> '
+           '--app_capabilities <capabilities...> '
            '[--appid <appid>] '
            '[--locales <locales...>] '
            '[--jinja_paths <paths...>] '
            '[--service_environment <service_environment>]')
     return 1
 
   arg_type = ''
   files = []
   locales = []
   jinja_paths = []
   app_id = None
   app_name = None
   app_description = None
+  app_capabilities = set([])
   service_environment = ''
 
   for arg in sys.argv[7:]:
     if arg in ['--locales',
                '--jinja_paths',
                '--appid',
                '--app_name',
                '--app_description',
+               '--app_capabilities',
                '--service_environment']:
       arg_type = arg
     elif arg_type == '--locales':
       locales.append(arg)
     elif arg_type == '--jinja_paths':
       jinja_paths.append(arg)
     elif arg_type == '--appid':
       app_id = arg
       arg_type = ''
     elif arg_type == '--app_name':
       app_name = arg
       arg_type = ''
     elif arg_type == '--app_description':
       app_description = arg
       arg_type = ''
+    elif arg_type == '--app_capabilities':
+      app_capabilities.add(arg)
     elif arg_type == '--service_environment':
       service_environment = arg
       arg_type = ''
     else:
       files.append(arg)
 
   return buildWebApp(sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4],
                      sys.argv[5], sys.argv[6], app_id, app_name,
-                     app_description, files, locales, jinja_paths,
-                     service_environment)
+                     app_description, app_capabilities, files, locales,
+                     jinja_paths, service_environment)
 
 
 if __name__ == '__main__':
   sys.exit(main())