# Copyright 2017 The Cobalt Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

#####################################################################
# If you modify this file, PLEASE REMEMBER TO UPDATE
# //cobalt/build/config/base.gni AS WELL
#####################################################################

# This contains the defaults and documentation for all Cobalt-defined GYP
# variables. Starboard-defined variables are specified in
# starboard/build/base_configuration.gypi.
#
# starboard/build/cobalt_configuration includes this file automatically in all
# .gyp files processed by starboard/build/gyp_cobalt.
{
  'variables': {
    # Cobalt variables.

    # We need to define some variables inside of an inner 'variables' scope
    # so that they can be referenced by other outer variables here.  Also, it
    # allows for the specification of default values that get referenced by
    # a top level scope.
    'variables': {
      'cobalt_webapi_extension_source_idl_files%': [],
      'cobalt_webapi_extension_generated_header_idl_files%': [],
      'cobalt_v8_buildtime_snapshot%': 1,
      'cobalt_v8_enable_embedded_builtins%': 1,
    },

    # Whether Cobalt is being built.
    'cobalt': 1,

    # Contains the current build configuration.
    'cobalt_config%': 'gold',
    'cobalt_fastbuild%': 0,

    # Enable support for the map to mesh filter, which is primarily used to
    # implement spherical video playback.
    # This setting is deprecated in favor of the cobalt graphics extension
    # (CobaltGraphicsExtensionApi) function `IsMapToMeshEnabled()`.
    # If the CobaltGraphicsExtensionApi is not implemented, then Cobalt will
    # fall back onto a default. For starboard API versions 12 and later, the
    # default is true (i.e. Cobalt will assume map to mesh is supported).
    # For earlier starboard API versions, if this gyp variable is redefined to
    # a value other than -1, it will use the new value as the default. If it is
    # not redefined, the default is false.
    'enable_map_to_mesh%': -1,

    # This variable defines what Cobalt's preferred strategy should be for
    # handling internally triggered application exit requests (e.g. the user
    # chooses to back out of the application).
    #   'stop'    -- The application should call SbSystemRequestStop() on exit,
    #                resulting in a complete shutdown of the application.
    #   'suspend' -- The application should call SbSystemRequestSuspend() on
    #                exit, resulting in the application being "minimized".
    #   'noexit'  -- The application should never allow the user to trigger an
    #                exit, this will be managed by the system.
    'cobalt_user_on_exit_strategy%': 'stop',

    # Contains the current font package selection.  This can be used to trade
    # font quality, coverage, and latency for different font package sizes.
    # The font package can be one of the following options:
    #   'standard' -- The default package. It includes all sans-serif, serif,
    #                 and FCC fonts, non-CJK fallback fonts in both 'normal' and
    #                 'bold' weights, 'normal' weight CJK ('bold' weight CJK is
    #                 synthesized from it), historic script fonts, and color
    #                 emojis. This package is ~38.3MB.
    #   'limited'  -- A significantly smaller package than 'standard'. This
    #                 package removes all but 'normal' and 'bold' weighted
    #                 sans-serif and serif, removes the FCC fonts (which must be
    #                 provided by the system or downloaded from the web),
    #                 replaces standard CJK with low quality CJK, removes
    #                 historic script fonts, and replaces colored emojis with
    #                 uncolored ones. Because low quality CJK cannot synthesize
    #                 bold, bold glyphs are unavailable in Chinese, Japanese and
    #                 Korean. This package is ~8.3MB.
    #   'minimal'  -- The smallest possible font package. It only includes
    #                 Roboto's Basic Latin characters. Everything else must be
    #                 provided by the system or downloaded from the web. This
    #                 package is ~40.0KB.
    # NOTE: When bold is needed, but unavailable, it is typically synthesized,
    #       resulting in lower quality glyphs than those generated directly from
    #       a bold font. However, this does not occur with low quality CJK,
    #       which is not high enough quality to synthesize. Its glyphs always
    #       have a 'normal' weight.
    'cobalt_font_package%': 'standard',

    # Font package overrides can be used to modify the files included within the
    # selected package. The following values are available:
    #   -1 -- The package value for the specified category is not overridden.
    #    0 -- The package value is overridden and no fonts for the specified
    #         category are included.
    #    1 -- The package value is overridden and fonts from the specified
    #         category with a weight of 'normal' and a style of 'normal' are
    #         included.
    #    2 -- The package value is overridden and fonts from the specified
    #         category with a weight of either 'normal' or bold' and a style of
    #         'normal' are included.
    #    3 -- The package value is overridden and fonts from the specified
    #         category with a weight of either 'normal' or 'bold' and a style of
    #         either 'normal' or 'italic' are included.
    #    4 -- The package value is overridden and all available fonts from the
    #         specified category are included. This may include additional
    #         weights beyond 'normal' and 'bold'.
    # See content/fonts/README.md for details on the specific values used by
    # each of the packages use for the various font categories.
    'cobalt_font_package_override_named_sans_serif%': -1,
    'cobalt_font_package_override_named_serif%': -1,
    'cobalt_font_package_override_named_fcc_fonts%': -1,
    'cobalt_font_package_override_fallback_lang_non_cjk%': -1,
    'cobalt_font_package_override_fallback_lang_cjk%': -1,
    'cobalt_font_package_override_fallback_lang_cjk_low_quality%': -1,
    'cobalt_font_package_override_fallback_historic%': -1,
    'cobalt_font_package_override_fallback_color_emoji%': -1,
    'cobalt_font_package_override_fallback_emoji%': -1,
    'cobalt_font_package_override_fallback_symbols%': -1,

    # Build version number.
    'cobalt_version%': '<(BUILD_NUMBER)',

    # Defines what kind of rasterizer will be used.  This can be adjusted to
    # force a stub graphics implementation.
    # It can be one of the following options:
    #   'direct-gles' -- Uses a light wrapper over OpenGL ES to handle most
    #                    draw elements. This will fall back to the skia hardware
    #                    rasterizer for some render tree node types, but is
    #                    generally faster on the CPU and GPU. This can handle
    #                    360 rendering.
    #   'hardware'    -- As much hardware acceleration of graphics commands as
    #                    possible. This uses skia to wrap OpenGL ES commands.
    #                    Required for 360 rendering.
    #   'stub'        -- Stub graphics rasterization.  A rasterizer object will
    #                    still be available and valid, but it will do nothing.
    'rasterizer_type%': 'direct-gles',

    # If set to 1, will enable support for rendering only the regions of the
    # display that are modified due to animations, instead of re-rendering the
    # entire scene each frame.  This feature can reduce startup time where
    # usually there is a small loading spinner animating on the screen.  On GLES
    # renderers, Cobalt will attempt to implement this support by using
    # eglSurfaceAttrib(..., EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED), otherwise
    # the dirty region will be silently disabled.  On Blitter API platforms,
    # if this is enabled, we explicitly create an extra offscreen full-size
    # intermediate surface to render into.  Note that some GLES driver
    # implementations may internally allocate an extra full screen surface to
    # support this feature, and many have been noticed to not properly support
    # this functionality (but they report that they do), and for these reasons
    # this value is defaulted to 0.
    'render_dirty_region_only%': 0,

    # Override this value to adjust the default rasterizer setting for your
    # platform.
    'default_renderer_options_dependency%': '<(DEPTH)/cobalt/renderer/default_options_starboard.gyp:default_options',

    # Override this to inject a custom interface into Cobalt's JavaScript
    # `window` global object.  This implies that you will have to provide your
    # own IDL files to describe that interface and all interfaces that it
    # references.  See cobalt/doc/webapi_extension.md for more information.
    'cobalt_webapi_extension_source_idl_files%': [
      '<@(cobalt_webapi_extension_source_idl_files)',
    ],
    # Override this to have Cobalt build IDL files that result in generated
    # header files that may need to be included from other C++ source files.
    # This includes, for example, IDL enumerations.  See
    # cobalt/doc/webapi_extension.md for more information.
    'cobalt_webapi_extension_generated_header_idl_files%': [
      '<@(cobalt_webapi_extension_generated_header_idl_files)',
    ],

    # This gyp target must implement the functions defined in
    # <(DEPTH)/cobalt/browser/idl_extensions.h.  See
    # cobalt/doc/webapi_extension.md for more information.
    'cobalt_webapi_extension_gyp_target%':
        '<(DEPTH)/cobalt/browser/null_webapi_extension.gyp:null_webapi_extension',

    # Allow throttling of the frame rate. This is expressed in terms of
    # milliseconds and can be a floating point number. Keep in mind that
    # swapping frames may take some additional processing time, so it may be
    # better to specify a lower delay. For example, '33' instead of '33.33'
    # for 30 Hz refresh. This value is deprecated in favor of the usage of
    # CobaltExtensionGraphicsApi::GetMinimumFrameIntervalInMilliseconds API.
    # The default value has been moved into cobalt/renderer/pipeline.cc.
    'cobalt_minimum_frame_time_in_milliseconds%': '-1',

    # Cobalt will call eglSwapInterval() and specify this value before calling
    # eglSwapBuffers() each frame.
    'cobalt_egl_swap_interval%': 1,

    # Set to 1 to build with DIAL support.
    'in_app_dial%': 0,

    # Set to 1 to enable a custom MediaSessionClient.
    'custom_media_session_client%': 0,

    # Set to 1 to enable H5vccAccountManager.
    'enable_account_manager%': 0,

    # Set to 1 to enable H5vccCrashLog.
    'enable_crash_log%': 0,

    # Set to 1 to enable H5vccSSO (Single Sign On).
    'enable_sso%': 0,

    # Set to 1 to compile with SPDY support.
    'enable_spdy%': 1,

    # Set to 1 to enable filtering of HTTP headers before sending.
    'enable_xhr_header_filtering%': 0,

    # Set to 1 to enable setting Interceptors on the URLRequestJobFactory
    'enable_configure_request_job_factory%': 0,

    # List of platform-specific targets that get compiled into cobalt.
    'cobalt_platform_dependencies%': [],

    # The URL of default build time splash screen - see
    #   cobalt/doc/splash_screen.md for information about this.
    'fallback_splash_screen_url%': 'none',
    # The path to a splash screen to copy into content/data/web which can be
    # accessed via a file URL starting with
    # "file:///cobalt/browser/splash_screen/". If '', no file is copied.
    'cobalt_splash_screen_file%': '',

    # Some platforms have difficulty linking snapshot_app_stats
    'build_snapshot_app_stats%': 1,

    # Set to "true" to enable v8 snapshot generation at Cobalt build time.
    'cobalt_v8_buildtime_snapshot%': '<(cobalt_v8_buildtime_snapshot)',

    # Some compiler can not compile with raw assembly(.S files) and v8
    # converts asm to inline assembly for these platforms.
    'cobalt_v8_emit_builtins_as_inline_asm%': 1,

    'cobalt_enable_quic%': 1,

    # Cache parameters

    # The following set of parameters define how much memory is reserved for
    # different Cobalt caches.  These caches affect CPU *and* GPU memory usage.
    #
    # The sum of the following caches effectively describes the maximum GPU
    # texture memory usage (though it doesn't consider video textures and
    # display color buffers):
    #   - skia_cache_size_in_bytes (GLES2 rasterizer only)
    #   - scratch_surface_cache_size_in_bytes
    #   - image_cache_size_in_bytes
    #   - skia_glyph_atlas_width * skia_glyph_atlas_height
    #
    # The other caches affect CPU memory usage.

    # Determines the capacity of the skia cache.  The Skia cache is maintained
    # within Skia and is used to cache the results of complicated effects such
    # as shadows, so that Skia draw calls that are used repeatedly across
    # frames can be cached into surfaces.  This setting is only relevant when
    # using the hardware-accelerated Skia rasterizer (e.g. as opposed to the
    # Blitter API).
    'skia_cache_size_in_bytes%': 4 * 1024 * 1024,

    # Determines the capacity of the scratch surface cache.  The scratch
    # surface cache facilitates the reuse of temporary offscreen surfaces
    # within a single frame.  This setting is only relevant when using the
    # hardware-accelerated Skia rasterizer.
    'scratch_surface_cache_size_in_bytes%': 0,

    # Determines the amount of GPU memory the offscreen target atlases will
    # use. This is specific to the direct-GLES rasterizer and caches any render
    # tree nodes which require skia for rendering. Two atlases will be allocated
    # from this memory or multiple atlases of the frame size if the limit
    # allows. It is recommended that enough memory be reserved for two RGBA
    # atlases about a quarter of the frame size.
    'offscreen_target_cache_size_in_bytes%': -1,

    # Determines the capacity of the encoded image cache, which manages encoded
    # images downloaded from a web page. These images are cached within CPU
    # memory.  This not only reduces network traffic to download the encoded
    # images, but also allows the downloaded images to be held during suspend.
    # Note that there is also a cache for the decoded images whose capacity is
    # specified in |image_cache_size_in_bytes|.  The decoded images are often
    # cached in the GPU memory and will be released during suspend.
    #
    # If a system meet the following requirements:
    # 1. Has a fast image decoder.
    # 2. Has enough CPU memory, or has a unified memory architecture that allows
    #    sharing of CPU and GPU memory.
    # Then it may consider to set |encoded_image_cache_size_in_bytes| to a much
    # bigger value, and set the value of |image_cache_size_in_bytes| to a much
    # smaller value. This allows the app to cache significant more images.
    #
    # Set this to 0 can disable the cache completely.
    'encoded_image_cache_size_in_bytes%': 1024 * 1024,

    # Determines the capacity of the image cache, which manages image surfaces
    # downloaded from a web page.  While it depends on the platform, often (and
    # ideally) these images are cached within GPU memory.
    # Set to -1 to automatically calculate the value at runtime, based on
    # features like windows dimensions and the value of
    # SbSystemGetTotalGPUMemory().
    'image_cache_size_in_bytes%': -1,

    # Determines the capacity of the local font cache, which manages all fonts
    # loaded from local files. Newly encountered sections of font files are
    # lazily loaded into the cache, enabling subsequent requests to the same
    # file sections to be handled via direct memory access. Once the limit is
    # reached, further requests are handled via file stream.
    # Setting the value to 0 disables memory caching and causes all font file
    # accesses to be done using file streams.
    'local_font_cache_size_in_bytes%': 16 * 1024 * 1024,

    # Determines the capacity of the remote font cache, which manages all
    # fonts downloaded from a web page.
    'remote_font_cache_size_in_bytes%': 4 * 1024 * 1024,

    # Determines the capacity of the mesh cache. Each mesh is held compressed
    # in main memory, to be inflated into a GPU buffer when needed for
    # projection. When set to 'auto', will be adjusted according to whether
    # the enable_map_to_mesh is true or not.  If enable_map_to_mesh is false,
    # then the mesh cache size will be set to 0.
    'mesh_cache_size_in_bytes%': 'auto',

    # Only relevant if you are using the Blitter API.
    # Determines the capacity of the software surface cache, which is used to
    # cache all surfaces that are rendered via a software rasterizer to avoid
    # re-rendering them.
    'software_surface_cache_size_in_bytes%': 8 * 1024 * 1024,

    # Modifying this value to be non-1.0f will result in the image cache
    # capacity being cleared and then temporarily reduced for the duration that
    # a video is playing.  This can be useful for some platforms if they are
    # particularly constrained for (GPU) memory during video playback.  When
    # playing a video, the image cache is reduced to:
    # image_cache_size_in_bytes *
    #     image_cache_capacity_multiplier_when_playing_video.
    'image_cache_capacity_multiplier_when_playing_video%': '1.0f',

    # Determines the size in pixels of the glyph atlas where rendered glyphs are
    # cached. The resulting memory usage is 2 bytes of GPU memory per pixel.
    # When a value is used that is too small, thrashing may occur that will
    # result in visible stutter. Such thrashing is more likely to occur when CJK
    # language glyphs are rendered and when the size of the glyphs in pixels is
    # larger, such as for higher resolution displays.
    # The negative default values indicates to the engine that these settings
    # should be automatically set.
    'skia_glyph_atlas_width%': '-1',
    'skia_glyph_atlas_height%': '-1',

    # Determines the size of garbage collection threshold. After this many
    # bytes have been allocated, the SpiderMonkey garbage collector will run.
    # Lowering this has been found to reduce performance and decrease
    # JavaScript memory usage. For example, we have measured on at least one
    # platform that performance becomes 7% worse on average in certain cases
    # when adjusting this number from 8MB to 1MB.
    'mozjs_garbage_collection_threshold_in_bytes%': 8 * 1024 * 1024,

    # Max Cobalt CPU usage specifies that the cobalt program should
    # keep it's size below the specified size. A value of -1 causes this
    # value to be assumed from the starboard API function:
    # SbSystemGetTotalCPUMemory().
    'max_cobalt_cpu_usage%': -1,

    # Max Cobalt GPU usage specifies that the cobalt program should
    # keep it's size below the specified size. A value of -1 causes this
    # value to be assumed from the starboard API function:
    # SbSystemGetTotalGPUMemory().
    'max_cobalt_gpu_usage%': -1,

    # When specified this value will reduce the cpu memory consumption by
    # the specified amount. -1 disables the value.
    # When this value is specified then max_cobalt_cpu_usage will not be
    # used in memory_constrainer, but will still be used for triggering
    # a warning if the engine consumes more memory than this value specifies.
    'reduce_cpu_memory_by%': -1,

    # When specified this value will reduce the gpu memory consumption by
    # the specified amount. -1 disables the value.
    # When this value is specified then max_cobalt_gpu_usage will not be
    # used in memory_constrainer, but will still be used for triggering
    # a warning if the engine consumes more memory than this value specifies.
    'reduce_gpu_memory_by%': -1,

    # Note: Ideally, |javascript_engine| and |cobalt_enable_jit| would live
    # here, however due to weird gyp variable usage in bindings gyp files
    # (that if we removed, would result in large code duplication), we have to
    # define them in the python gyp platform files instead.  See
    # "starboard/build/platform_configuration.py" for their documentation.

    # Can be set to enable zealous garbage collection, if |javascript_engine|
    # supports it.  Zealous garbage collection will cause garbage collection
    # to occur much more frequently than normal, for the purpose of finding or
    # reproducing bugs.
    'cobalt_gc_zeal%': 0,

    # This can be set to "memory" or "file".  When it is set to "memory", the
    # media buffers will be stored in main memory allocated by SbMemory
    # functions.  When it is set to "file", the media buffers will be stored in
    # a temporary file in the system cache folder acquired by calling
    # SbSystemGetPath() with "kSbSystemPathCacheDirectory".  Note that when its
    # value is "file" the media stack will still allocate memory to cache the
    # the buffers in use.
    'cobalt_media_buffer_storage_type%': 'memory',
    # When either |cobalt_media_buffer_initial_capacity| or
    # |cobalt_media_buffer_allocation_unit| isn't zero, media buffers will be
    # allocated using a memory pool.  Set the following variable to 1 to
    # allocate the media buffer pool memory on demand and return all memory to
    # the system when there is no media buffer allocated.  Setting the following
    # value to 0 results in that Cobalt will allocate
    # |cobalt_media_buffer_initial_capacity| bytes for media buffer on startup
    # and will not release any media buffer memory back to the system even if
    # there is no media buffers allocated.
    'cobalt_media_buffer_pool_allocate_on_demand%': 1,
    # The amount of memory that will be used to store media buffers allocated
    # during system startup.  To allocate a large chunk at startup helps with
    # reducing fragmentation and can avoid failures to allocate incrementally.
    # This can be set to 0.
    'cobalt_media_buffer_initial_capacity%': 21 * 1024 * 1024,
    # The maximum amount of memory that will be used to store media buffers when
    # video resolution is no larger than 1080p. This must be larger than sum of
    # 1080p video budget and non-video budget.
    'cobalt_media_buffer_max_capacity_1080p%': 50 * 1024 * 1024,
    # The maximum amount of memory that will be used to store media buffers when
    # video resolution is 4k. If 0, then memory can grow without bound. This
    # must be larger than sum of 4k video budget and non-video budget.
    'cobalt_media_buffer_max_capacity_4k%': 140 * 1024 * 1024,

    # When the media stack needs more memory to store media buffers, it will
    # allocate extra memory in units of |cobalt_media_buffer_allocation_unit|.
    # This can be set to 0, in which case the media stack will allocate extra
    # memory on demand.  When |cobalt_media_buffer_initial_capacity| and this
    # value are both set to 0, the media stack will allocate individual buffers
    # directly using SbMemory functions.
    'cobalt_media_buffer_allocation_unit%': 1 * 1024 * 1024,

    # The media buffer will be allocated using the following alignment.  Set
    # this to a larger value may increase the memory consumption of media
    # buffers.
    'cobalt_media_buffer_alignment%': 1,
    # Extra bytes allocated at the end of a media buffer to ensure that the
    # buffer can be use optimally by specific instructions like SIMD.  Set to 0
    # to remove any padding.
    'cobalt_media_buffer_padding%': 0,

    # The memory used when playing mp4 videos that is not in DASH format.  The
    # resolution of such videos shouldn't go beyond 1080p.  Its value should be
    # less than the sum of 'cobalt_media_buffer_non_video_budget' and
    # 'cobalt_media_buffer_video_budget_1080p' but not less than 8 MB.
    'cobalt_media_buffer_progressive_budget%': 12 * 1024 * 1024,

    # Specifies the maximum amount of memory used by audio or text buffers of
    # media source before triggering a garbage collection.  A large value will
    # cause more memory being used by audio buffers but will also make
    # JavaScript app less likely to re-download audio data.  Note that the
    # JavaScript app may experience significant difficulty if this value is too
    # low.
    'cobalt_media_buffer_non_video_budget%': 5 * 1024 * 1024,

    # Specifies the maximum amount of memory used by video buffers of media
    # source before triggering a garbage collection when the video resolution is
    # lower than 1080p (1920x1080).  A large value will cause more memory being
    # used by video buffers but will also make JavaScript app less likely to
    # re-download video data.  Note that the JavaScript app may experience
    # significant difficulty if this value is too low.
    'cobalt_media_buffer_video_budget_1080p%': 30 * 1024 * 1024,
    # Specifies the maximum amount of memory used by video buffers of media
    # source before triggering a garbage collection when the video resolution is
    # lower than 4k (3840x2160).  A large value will cause more memory being
    # used by video buffers but will also make JavaScript app less likely to
    # re-download video data.  Note that the JavaScript app may experience
    # significant difficulty if this value is too low.
    'cobalt_media_buffer_video_budget_4k%': 100 * 1024 * 1024,

    # Specifies the duration threshold of media source garbage collection.  When
    # the accumulated duration in a source buffer exceeds this value, the media
    # source implementation will try to eject existing buffers from the cache.
    # This is usually triggered when the video being played has a simple content
    # and the encoded data is small.  In such case this can limit how much is
    # allocated for the book keeping data of the media buffers and avoid OOM of
    # system heap.
    # This should be set to 170 for most of the platforms.  But it can be
    # further reduced on systems with extremely low memory.
    'cobalt_media_source_garbage_collection_duration_threshold_in_seconds%': 170,

    'compiler_flags_host': [
      '-D__LB_HOST__',  # TODO: Is this still needed?
    ],

    'defines_debug': [
      'ALLOCATOR_STATS_TRACKING',
      'COBALT_BOX_DUMP_ENABLED',
      'COBALT_BUILD_TYPE_DEBUG',
      'COBALT_ENABLE_JAVASCRIPT_ERROR_LOGGING',
      'COBALT_ENABLE_VERSION_COMPATIBILITY_VALIDATIONS',
      'COBALT_SECURITY_SCREEN_CLEAR_TO_UGLY_COLOR',
      'ENABLE_DEBUG_COMMAND_LINE_SWITCHES',
      'ENABLE_DEBUG_C_VAL',
      'ENABLE_IGNORE_CERTIFICATE_ERRORS',
      'ENABLE_PARTIAL_LAYOUT_CONTROL',
      'ENABLE_TEST_DATA',
      'ENABLE_TEST_RUNNER',
      'ENABLE_TOKEN_ALPHABETICAL_SORTING',

      # TODO: Rename to COBALT_LOGGING_ENABLED.
      '__LB_SHELL__FORCE_LOGGING__',

      'SK_DEVELOPER',
    ],
    'defines_devel': [
      'ALLOCATOR_STATS_TRACKING',
      'COBALT_BUILD_TYPE_DEVEL',
      'COBALT_ENABLE_JAVASCRIPT_ERROR_LOGGING',
      'COBALT_ENABLE_VERSION_COMPATIBILITY_VALIDATIONS',
      'COBALT_SECURITY_SCREEN_CLEAR_TO_UGLY_COLOR',
      'ENABLE_DEBUG_COMMAND_LINE_SWITCHES',
      'ENABLE_DEBUG_C_VAL',
      'ENABLE_IGNORE_CERTIFICATE_ERRORS',
      'ENABLE_PARTIAL_LAYOUT_CONTROL',
      'ENABLE_TEST_DATA',
      'ENABLE_TEST_RUNNER',
      'ENABLE_TOKEN_ALPHABETICAL_SORTING',
      '__LB_SHELL__FORCE_LOGGING__',
      'SK_DEVELOPER',
    ],
    'defines_qa': [
      'ALLOCATOR_STATS_TRACKING',
      'COBALT_BUILD_TYPE_QA',
      'COBALT_ENABLE_JAVASCRIPT_ERROR_LOGGING',
      'COBALT_SECURITY_SCREEN_CLEAR_TO_UGLY_COLOR',
      'ENABLE_DEBUG_COMMAND_LINE_SWITCHES',
      'ENABLE_DEBUG_C_VAL',
      'ENABLE_IGNORE_CERTIFICATE_ERRORS',
      'ENABLE_PARTIAL_LAYOUT_CONTROL',
      'ENABLE_TEST_DATA',
      'ENABLE_TEST_RUNNER',
    ],
    'defines_gold': [
      'ALLOCATOR_STATS_TRACKING',
      'COBALT_BUILD_TYPE_GOLD',
      'COBALT_FORCE_CSP',
      'COBALT_FORCE_HTTPS',
      'OFFICIAL_BUILD',  # Chromium base relies on this.
      'TRACING_DISABLED',
    ],
  },

  'target_defaults': {
    'defines': [
      'COBALT',
      'COBALT_MEDIA_BUFFER_POOL_ALLOCATE_ON_DEMAND=<(cobalt_media_buffer_pool_allocate_on_demand)',
      'COBALT_MEDIA_BUFFER_INITIAL_CAPACITY=<(cobalt_media_buffer_initial_capacity)',
      'COBALT_MEDIA_BUFFER_MAX_CAPACITY_1080P=<(cobalt_media_buffer_max_capacity_1080p)',
      'COBALT_MEDIA_BUFFER_MAX_CAPACITY_4K=<(cobalt_media_buffer_max_capacity_4k)',
      'COBALT_MEDIA_BUFFER_ALLOCATION_UNIT=<(cobalt_media_buffer_allocation_unit)',
      'COBALT_MEDIA_BUFFER_ALIGNMENT=<(cobalt_media_buffer_alignment)',
      'COBALT_MEDIA_BUFFER_PADDING=<(cobalt_media_buffer_padding)',
      'COBALT_MEDIA_BUFFER_PROGRESSIVE_BUDGET=<(cobalt_media_buffer_progressive_budget)',
      'COBALT_MEDIA_BUFFER_NON_VIDEO_BUDGET=<(cobalt_media_buffer_non_video_budget)',
      'COBALT_MEDIA_BUFFER_VIDEO_BUDGET_1080P=<(cobalt_media_buffer_video_budget_1080p)',
      'COBALT_MEDIA_BUFFER_VIDEO_BUDGET_4K=<(cobalt_media_buffer_video_budget_4k)',
      'COBALT_MEDIA_SOURCE_GARBAGE_COLLECTION_DURATION_THRESHOLD_IN_SECONDS=<(cobalt_media_source_garbage_collection_duration_threshold_in_seconds)',
    ],
    'conditions': [
      ['cobalt_media_buffer_storage_type == "memory"', {
        'defines': [
          'COBALT_MEDIA_BUFFER_STORAGE_TYPE_MEMORY=1',
        ],
      }, {
        'defines': [
          'COBALT_MEDIA_BUFFER_STORAGE_TYPE_FILE=1',
        ],
      }],
      ['cobalt_gc_zeal == 1', {
        'defines': [
          'COBALT_GC_ZEAL=1',
          'JS_GC_ZEAL=1',
        ],
      }],
      ['in_app_dial == 1', {
        'defines': [
          'DIAL_SERVER',
        ],
      }],
      ['enable_spdy == 0', {
        'defines': [
          'COBALT_DISABLE_SPDY',
        ],
      }],
      ['enable_debugger == 1', {
        'defines': [
          'ENABLE_DEBUGGER',
        ],
      }],
      ['cobalt_v8_buildtime_snapshot == 1', {
        'defines': [
          'COBALT_V8_BUILDTIME_SNAPSHOT=1',
        ],
      }],
      ['cobalt_enable_quic == 1', {
        'defines': [
          'COBALT_ENABLE_QUIC',
        ],
      }],
      ['host_os=="win"', {
        # A few flags to mute MSVC compiler errors that does not appear on Linux.
        'compiler_flags_host': [
          '/wd4267',  # Possible loss of precision from size_t to a smaller type.
          '/wd4715',  # Not all control paths return value.
        ],
      }],
    ],
  }, # end of target_defaults

  # For configurations other than Gold, set the flag that lets test data files
  # be copied and carried along with the build.
  # Clients must copy over all content; to avoid having to copy over extra data, we
  # omit the test data
  'conditions': [
    ['cobalt_config != "gold"', {
      'variables' : {
        'enable_about_scheme': 1,
        'enable_fake_microphone': 1,
        'enable_network_logging': 1,
        'enable_webdriver%': 1,
      },
    },
    {
      'variables' : {
        'enable_about_scheme': 0,
        'enable_fake_microphone': 0,
        'enable_network_logging': 0,
        'enable_webdriver': 0,
      },
    }],
    ['cobalt_config != "gold"', {
      'variables' : {
        'cobalt_copy_test_data': 1,
      },
    },
    {
      'variables' : {
        'cobalt_copy_test_data': 0,
      },
    }],
  ],
}