shaka-player 4.6.4 → 4.7.0

package/.github/workflows/appspot.yaml

@@ -1,39 +0,0 @@
-name: Deploy to Appspot (one-off)
-
-on:
-  workflow_dispatch:
-    # Allows for manual triggering, to correct deployment issues.
-    inputs:
-      ref:
-        description: "A tag name or SHA1 to deploy."
-        required: true
-      subdomain:
-        description: "An appspot subdomain to deploy to.  Be careful!  Do not overwrite an existing subdomain!"
-        required: true
-
-jobs:
-  appspot:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          ref: ${{ inputs.ref }}
-          fetch-depth: 0
-          persist-credentials: false
-
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 16
-          registry-url: 'https://registry.npmjs.org'
-
-      - uses: ./.github/workflows/custom-actions/prep-for-appspot
-
-      - uses: google-github-actions/auth@v0
-        with:
-          credentials_json: '${{ secrets.APPENGINE_DEPLOY_KEY }}'
-
-      - uses: google-github-actions/deploy-appengine@v0
-        with:
-          project_id: shaka-player-demo
-          version: ${{ inputs.subdomain }}
-          promote: false

package/.github/workflows/build-and-test.yaml

@@ -1,222 +0,0 @@
-name: Build and Test PR
-
-on:
-  pull_request: # Trigger for pull requests.
-    types: [opened, synchronize, reopened, ready_for_review]
-    branches:
-      - main
-      - v[0-9]*
-  workflow_dispatch: # Allows for manual triggering.
-    inputs:
-      ref:
-        description: "The ref to build and test."
-        required: false
-
-# If another instance of this workflow is started for the same PR, cancel the
-# old one.  If a PR is updated and a new test run is started, the old test run
-# will be cancelled automatically to conserve resources.
-concurrency:
-  group: ${{ github.workflow }}-${{ inputs.ref || github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  lint:
-    name: Lint
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-        with:
-          ref: ${{ inputs.ref || github.ref }}
-
-      - name: Lint
-        run: python build/check.py
-
-  build_and_test:
-    # Don't waste time doing a full matrix of test runs when there was an
-    # obvious linter error.
-    needs: lint
-    strategy:
-      matrix:
-        include:
-          # Run Linux browsers with xvfb, so they're in a headless X session.
-          # Additionally, generate a code coverage report from Linux Chrome.
-          # It should be the uncompiled build, or else we won't execute any
-          # coverage instrumentation on full-stack player integration tests.
-          - os: ubuntu-latest
-            browser: Chrome
-            extra_flags: "--use-xvfb"
-          - os: ubuntu-latest
-            browser: Firefox
-            extra_flags: "--use-xvfb"
-          - os: ubuntu-latest
-            browser: Edge
-            extra_flags: "--use-xvfb"
-
-          - os: macos-latest
-            browser: Chrome
-          - os: macos-latest
-            browser: Firefox
-          - os: macos-latest
-            browser: Edge
-          - os: macos-latest
-            browser: Safari
-          - os: macos-latest
-            browser: Safari-old
-
-          - os: windows-latest
-            browser: Chrome
-          - os: windows-latest
-            browser: Firefox
-          - os: windows-latest
-            browser: Edge
-            extra_flags: "--html-coverage-report --uncompiled"
-
-      # Disable fail-fast so that one matrix-job failing doesn't make the other
-      # ones end early.
-      fail-fast: false
-
-    name: ${{ matrix.os }} ${{ matrix.browser }}
-    runs-on: ${{ matrix.os }}
-
-    steps:
-      # Firefox on Ubuntu appears to not have the right things installed in
-      # the environment used by GitHub actions, so make sure that ffmpeg is
-      # installed. Otherwise, the browser might not support some codecs that the
-      # tests assume will be supported.
-      - name: Install FFmpeg
-        if: matrix.os == 'ubuntu-latest' && matrix.browser == 'Firefox'
-        run: sudo apt -y update && sudo apt -y install ffmpeg
-
-      - name: Checkout code
-        uses: actions/checkout@v3
-        with:
-          ref: ${{ inputs.ref || github.ref }}
-
-      # Older versions of Safari can be installed, but not to the root, and it
-      # can't replace the standard version, at least not on GitHub's VMs.  If
-      # you try to install directly to the root with sudo, it will appear to
-      # succeed, but will have no effect.  If you try to script it explicitly
-      # with rm -rf and cp, this will fail.  Safari may be on a read-only
-      # filesystem.
-      - name: Install old Safari to home directory
-        if: matrix.os == 'macos-latest' && matrix.browser == 'Safari-old'
-        run: |
-          # Download Safari 15
-          # This URL discovered through the seed files listed at
-          # https://github.com/zhangyoufu/swscan.apple.com/blob/master/url.txt
-          curl -Lv http://swcdn.apple.com/content/downloads/42/33/012-57329-A_41P2VU6UHN/5fw5vna27fdw4mqfak5adj3pjpxvo9hgh7/Safari15.6.1CatalinaAuto.pkg > Safari.pkg
-
-          # Install older Safari to homedir specifically.
-          installer -pkg Safari.pkg -target CurrentUserHomeDirectory
-
-          # Install a launcher that can execute a shell script to launch this
-          npm install karma-script-launcher --save-dev
-
-      # When "Chrome for Testing" is installed on Mac or Windows, it gets
-      # invoked instead of simply "Chrome".  This other copy of Chrome,
-      # however, doesn't seem to have basic codecs like AAC and H264 available,
-      # causing many of our test scenarios to fail.  Deleting "Chrome for
-      # Testing" fixes this.
-      - name: 'Delete "Chrome for Testing" on Mac'
-        if: matrix.os == 'macos-latest' && matrix.browser == 'Chrome'
-        run: sudo rm -rf /Applications/Google\ Chrome\ for\ Testing.app
-      - name: 'Overwrite "Chrome for Testing" on Windows'
-        if: matrix.os == 'windows-latest' && matrix.browser == 'Chrome'
-        shell: bash
-        run: choco install -y googlechrome --ignore-checksums
-
-      # Some CI images (self-hosted or otherwise) don't have the minimum Java
-      # version necessary for the compiler (Java 11).
-      - uses: actions/setup-java@v3
-        with:
-          distribution: zulu
-          java-version: 11
-
-      - name: Build Player
-        run: python build/all.py
-
-      - name: Test Player
-        shell: bash
-        run: |
-          browser=${{ matrix.browser }}
-
-          if [[ "$browser" == "Safari-old" ]]; then
-            # Replace the browser name with a script that can launch this
-            # browser from the command line.
-            browser="$PWD/.github/workflows/safari-homedir-launcher.sh"
-          fi
-
-          python build/test.py \
-            --browsers "$browser" \
-            --reporters spec --spec-hide-passed \
-            ${{ matrix.extra_flags }}
-
-      - name: Find coverage reports
-        id: coverage
-        if: always() # Even on failure of an earlier step.
-        shell: bash
-        run: |
-          # If the "coverage" directory exists...
-          if [ -d coverage ]; then
-            # Find the path to the coverage output folder.  It includes the
-            # exact browser version in the path, so it will vary.
-            coverage_folder="$( (ls -d coverage/* || true) | head -1 )"
-
-            # Build a folder to stage all the coverage artifacts with
-            # predictable paths.  The resulting zip file will not have any
-            # internal directories.
-            mkdir coverage/staging/
-            cp "$coverage_folder"/coverage.json coverage/staging/
-            cp "$coverage_folder"/coverage-details.json coverage/staging/
-            echo "${{ github.event.number }}" > coverage/staging/pr-number.json
-
-            echo "coverage_found=true" >> $GITHUB_OUTPUT
-            echo "Coverage report staged."
-          else
-            echo "No coverage report generated."
-          fi
-
-      - name: Upload coverage reports
-        uses: actions/upload-artifact@v3
-        if: ${{ always() && steps.coverage.outputs.coverage_found }}
-        with:
-          name: coverage
-          # This will create a download called coverage.zip containing all of
-          # these files, with no internal folders.
-          path: |
-            coverage/staging/coverage.json
-            coverage/staging/coverage-details.json
-            coverage/staging/pr-number.json
-          # Since we've already filtered this step for instances where there is
-          # an environment variable set, the file should definitely be there.
-          if-no-files-found: error
-
-      # Upload new screenshots and diffs on failure; ignore if missing
-      - name: Upload screenshots
-        uses: actions/upload-artifact@v3
-        if: ${{ failure() }}
-        with:
-          name: screenshots-${{ matrix.browser }}
-          path: |
-            test/test/assets/screenshots/*/*.png-new
-            test/test/assets/screenshots/*/*.png-diff
-          if-no-files-found: ignore
-          retention-days: 5
-
-  build_in_docker:
-    # Don't waste time doing a full matrix of test runs when there was an
-    # obvious linter error.
-    needs: lint
-    name: Docker
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-        with:
-          ref: ${{ inputs.ref || github.ref }}
-
-      - name: Docker
-        run: |
-          docker build -t shaka-player-build build/docker
-          docker run -v $(pwd):/usr/src --user $(id -u):$(id -g) shaka-player-build

package/.github/workflows/compute-incremental-coverage.py

@@ -1,265 +0,0 @@
-#!/usr/bin/env python3
-#
-# Copyright 2022 Google LLC
-#
-# 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.
-
-import argparse
-import io
-import json
-import os
-import re
-import subprocess
-import zipfile
-
-# TODO(joeyparrish): Figure out how to get karma to output relative paths only.
-def StripGitDir(path):
-  # Convert Windows-style paths to Unix-style paths so we can read coverage
-  # data from Windows runners, too.
-  path = path.replace('\\', '/')
-  # Strip the path to the git clone, leaving only the source path within the
-  # repo.
-  return re.sub(r'.*?/(lib|ui)/', r'\1/', path)
-
-def RunCommand(args, text=True):
-  proc = subprocess.run(args, capture_output=True, text=text)
-  if proc.returncode != 0:
-    raise RuntimeError("Command failed:", args, proc.stdout, proc.stderr)
-  return proc.stdout
-
-def GitHubApi(repo, path, text=True):
-  args = ["gh", "api", "/repos/%s/%s" % (repo, path)]
-  output = RunCommand(args, text)
-  if text:
-    return json.loads(output)
-  else:
-    return output
-
-def GetCoverageArtifacts(repo, run_id):
-  # Fetch all artifacts from this run ID.
-  api_path = "actions/runs/%s/artifacts" % run_id
-  results = GitHubApi(repo, api_path)["artifacts"]
-  # Get the one that is named "coverage" (should be the only one).
-  artifact = list(filter(lambda x: x["name"] == "coverage", results))[0]
-
-  # Fetch and open the zip file containing the artifacts.
-  api_path = "actions/artifacts/%s/zip" % artifact["id"]
-  zip_data = GitHubApi(repo, api_path, text=False)
-  return zipfile.ZipFile(io.BytesIO(zip_data), 'r')
-
-def CoverageLines(coverage_range):
-  start_line = coverage_range["start"]["line"]
-  end_line = coverage_range["end"]["line"]
-
-  lines = set()
-  for line in range(start_line, end_line + 1):
-    lines.add(line)
-  return lines
-
-class CoverageDetails(object):
-  def __init__(self, file_data):
-    json_data = json.loads(file_data)
-
-    self.files = {}
-
-    # The structure is something like:
-    # {
-    #   "/path/to/lib/player.js": {
-    #     "statementMap": { ... },
-    #     "fnMap": { ... },
-    #     "s": { ... }
-    #   }
-    # }
-    for path, path_data in json_data.items():
-      path = StripGitDir(path)
-
-      statement_to_lines = {}
-      instrumented_lines = set()
-
-      # The function map is a structure to map where each function is in a
-      # source file:
-      # {
-      #   "0": {
-      #     "loc": {
-      #       "start": {
-      #         "line": 7,
-      #         "column": 0
-      #       },
-      #       "end": {
-      #         "line": 8,
-      #         "column": 29
-      #       }
-      #     }
-      #   },
-      #   ...
-      # }
-      # We extract function locations and remove them from statement spans
-      # below, so that we don't count (for example) class declaration statements
-      # as containing all the lines of every method in the class.
-      function_locations = []
-      for key, value in path_data["fnMap"].items():
-        lines = CoverageLines(value["loc"])
-        function_locations.append(lines)
-
-      # The statement map is a structure to map where each statement is in a
-      # source file:
-      # {
-      #   "0": {
-      #     "start": {
-      #       "line": 7,
-      #       "column": 0
-      #     },
-      #     "end": {
-      #       "line": 8,
-      #       "column": 29
-      #     }
-      #   },
-      #   ...
-      # }
-      for key, value in path_data["statementMap"].items():
-        # All the lines of the statement, which may include other functions or
-        # statements.
-        lines = CoverageLines(value)
-
-        # Subtract from that the lines of any function that is a subset of
-        # these lines.  By excluding entire methods before adding back their
-        # child statements, we exclude empty lines in class methods.
-        for function_lines in function_locations:
-          if function_lines < lines:  # strict subset
-            lines -= function_lines  # set subtraction
-
-        # If this statement is inside the range of another statement, remove
-        # this inner range from that outer one.  This is important because loops
-        # and conditional statements contain their inner branches.
-        for older_key, older_lines in statement_to_lines.items():
-          # Check for a proper subset (lines contains all elements of
-          # child_lines, but child_lines is not an equal set).
-          if lines < older_lines:  # strict subset
-            statement_to_lines[older_key] -= lines  # set subtraction
-
-        statement_to_lines[key] = lines
-
-      # Whatever is left in any statement, we count as instrumented.
-      for key, lines in statement_to_lines.items():
-        for line in lines:
-          instrumented_lines.add(line)
-
-      # The "s" field is a map from statement numbers to number of times
-      # executed.
-      executed_lines = set()
-      for key, executed in path_data["s"].items():
-        if executed:
-          for line in statement_to_lines[key]:
-            executed_lines.add(line)
-
-      self.files[path] = {
-        "instrumented": instrumented_lines,
-        "executed": executed_lines,
-      }
-
-class PullRequest(object):
-  def __init__(self, repo, number):
-    data = GitHubApi(repo, "pulls/%d" % number)
-    sha = data["merge_commit_sha"]
-
-    self.number = number
-    self.changes = {}
-
-    files = GitHubApi(repo, "commits/%s" % sha)["files"]
-
-    for file_data in files:
-      # The patch field is missing for binary files.  Skip those.
-      if "patch" not in file_data:
-        continue
-
-      filename = file_data["filename"]
-      patch = file_data["patch"]
-
-      # Parse through the unified diff in "patch" to find the touched line
-      # numbers.
-      touched_lines = []
-      line_number = None
-      for line in patch.split("\n"):
-        if line[0] == "@":
-          # Turns a header like "@@ -749,7 +757,19 @@ foo" into line number 757.
-          # Note that the last part of the new file range could be omitted:
-          # "@@ -0,0 +1 @@ foo"
-          new_file_range = line.split("+")[1].split(" @@")[0]
-          line_number = int(new_file_range.split(",")[0])
-        elif line[0] == " ":
-          line_number += 1
-        elif line[0] == "+":
-          touched_lines.append(line_number)
-          line_number += 1
-
-      self.changes[filename] = touched_lines
-
-def IncrementalCoverage(pr, coverage_details):
-  num_changed = 0
-  num_covered = 0
-
-  for path in pr.changes:
-    if path in coverage_details.files:
-      changed_lines = pr.changes[path]
-      instrumented_lines = coverage_details.files[path]["instrumented"]
-      executed_lines = coverage_details.files[path]["executed"]
-
-      for line in changed_lines:
-        # Only count the instrumented lines, not whitespace or comments.
-        if line in instrumented_lines:
-          num_changed += 1
-          if line in executed_lines:
-            num_covered += 1
-
-  if num_changed == 0:
-    return None
-  return num_covered / num_changed
-
-def set_output(name, value):
-  path = os.environ.get("GITHUB_OUTPUT")
-  if path:
-    # Inside GitHub Actions, output the data to a special file GitHub provides.
-    with open(path, "a") as f:
-      f.write("{}={}\n".format(name, value))
-  else:
-    # Outside of GitHub Actions, just print the data.
-    print("OUTPUT {}={}".format(name, value))
-
-def main():
-  parser = argparse.ArgumentParser(
-      description="Compute incremental code coverage for a PR",
-      formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-  parser.add_argument(
-      "--repo",
-      required=True,
-      help="The GitHub repo, such as shaka-project/shaka-player")
-  parser.add_argument(
-      "--run-id",
-      required=True,
-      help="The workflow run ID to download coverage data from")
-  args = parser.parse_args()
-
-  artifacts = GetCoverageArtifacts(args.repo, args.run_id)
-  coverage_details = CoverageDetails(artifacts.read("coverage-details.json"))
-  pr_number = json.loads(artifacts.read("pr-number.json"))
-  pr = PullRequest(args.repo, pr_number)
-  coverage = IncrementalCoverage(pr, coverage_details)
-
-  set_output("pr_number", str(pr_number))
-  if coverage is None:
-    set_output("coverage", "No instrumented code was changed.")
-  else:
-    set_output("coverage", "%.2f%%" % (coverage * 100.0))
-
-if __name__ == "__main__":
-  main()

package/.github/workflows/custom-actions/prep-for-appspot/action.yaml

@@ -1,56 +0,0 @@
-name: Prep Appspot Deployment
-
-description: |
-  A reusable action that prepares the sources to deploy the Shaka Player Demo
-  to appspot.  Assumes that the source is already checked out.
-
-runs:
-  using: composite
-  steps:
-    - name: Install dependencies
-      shell: bash
-      run: npm ci
-
-    - name: Build Shaka Player
-      shell: bash
-      run: python build/all.py
-
-    - name: Extract git version
-      shell: bash
-      run: |
-        (
-          cd build
-          python3 -c 'from shakaBuildHelpers import git_version; print(git_version())'
-        ) > demo-version
-
-    - name: Tag the Player version
-      shell: bash
-      run: |
-        DEMO_VERSION="$(cat demo-version)-uncompiled"
-        sed \
-            -i lib/player.js \
-            -e "s/\(shaka.Player.version\) = .*/\1 = '$DEMO_VERSION';/"
-        rm demo-version
-
-    - name: Backup demo node modules
-      shell: bash
-      run: |
-        DEMO_NODE_MODULES=$(jq -r .shakaCustom.demoDeps[] package.json)
-        tar cf demo-modules.tar \
-            $(echo "$DEMO_NODE_MODULES" | sed -e 's@^@node_modules/@')
-
-    - name: Delete unneeded files
-      shell: bash
-      run: rm -rf .git .github build externs test node_modules
-
-    - name: Restore demo node modules
-      shell: bash
-      run: |
-        tar xf demo-modules.tar
-        rm demo-modules.tar
-
-    - name: Install App Engine code
-      shell: bash
-      run: |
-        mv app-engine/shaka-player-demo/* .
-        rm README.md

package/.github/workflows/custom-actions/set-commit-status/action.yaml

@@ -1,37 +0,0 @@
-name: Set Commit Status
-
-description: |
-  A reusable action that sets the commit status.  This is used to set PR status
-  from workflows with non-PR triggers (such as manually-triggered workflows).
-
-inputs:
-  context:
-    description: An arbitrary string to identify the status check.
-    required: true
-  state:
-    description: Either "pending", "error", "success", or "failure".
-    required: true
-  token:
-    description: A GitHub access token.
-    required: true
-
-runs:
-  using: composite
-  steps:
-    - name: Report Commit Status
-      shell: bash
-      run: |
-        # This is the URL to view this workflow run on GitHub.  It will be
-        # attached to the commit status, so that when someone clicks "details"
-        # next to the status on the PR, it will link to this run where they can
-        # see the logs.
-        RUN_URL="https://github.com/${{github.repository}}/actions/runs/${{github.run_id}}"
-        SHA1=$(git rev-parse HEAD)
-
-        GITHUB_TOKEN=${{ inputs.token }} \
-        gh api \
-          -X POST \
-          -F "context=${{ inputs.context }}" \
-          -F "state=${{ inputs.state }}" \
-          -F "target_url=$RUN_URL" \
-          "repos/${{ github.repository }}/statuses/$SHA1"

package/.github/workflows/deflake.yaml

@@ -1,31 +0,0 @@
-name: Deflake Tests
-
-# Runs when the Selenum lab test or PR test workflows complete.  This will run
-# with full privileges, even if the other workflow doesn't.  That allows us to
-# trigger re-runs if we think the results might be flaky.  A test run will be
-# given up to 3 runs to succeed.
-on:
-  workflow_run:
-    workflows:
-      - Selenium Lab Tests
-      - Build and Test PR
-    types: [completed]
-
-jobs:
-  deflake:
-    if: ${{ github.event.workflow_run.conclusion == 'failure' }}
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Check run count and re-run workflow
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          gh api /repos/${{ github.repository }}/actions/runs/${{ github.event.workflow_run.id }} > run.json
-          RUNS=$(jq -r .run_attempt < run.json)
-          if [[ "$RUNS" -lt 3 ]]; then
-            echo "$RUNS failed runs so far; re-running workflow."
-            gh run rerun ${{ github.event.workflow_run.id }} --failed -R ${{ github.repository }}
-          else
-            echo "$RUNS failed runs so far; not re-running workflow."
-          fi

package/.github/workflows/demo-version-index.yaml

@@ -1,43 +0,0 @@
-name: Deploy Demo Version Index
-
-on:
-  workflow_dispatch:
-    # Allows for manual triggering.
-  push:
-    branches:
-      - main
-    paths:
-      - .github/workflows/demo-version-index.yaml
-      - app-engine/demo-version-index/**
-  release:
-    types: [published]
-  # NOTE: So long as releases are made without a personal access token (PAT),
-  # they will not activate this workflow's release trigger.  For now, the
-  # schedule trigger will compensate for that by updating the index nightly.
-  schedule:
-    # Run every night at 10pm PST / 6am UTC.
-    - cron: '0 6 * * *'
-
-jobs:
-  appspot:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          # We need a list of all tags for this, so fetch the entire history.
-          fetch-depth: 0
-
-      - uses: google-github-actions/auth@v0
-        with:
-          credentials_json: '${{ secrets.APPENGINE_DEPLOY_KEY }}'
-
-      - name: Generate static content
-        run: python3 app-engine/demo-version-index/generate.py
-
-      - uses: google-github-actions/deploy-appengine@v0
-        with:
-          project_id: shaka-player-demo
-          version: index
-          working_directory: app-engine/demo-version-index/
-          promote: false
-