| // Copyright 2015 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| import './icons.html.js'; |
| // <if expr="_google_chrome"> |
| import './internal/icons.html.js'; |
| // </if> |
| import 'chrome://resources/cr_elements/cr_action_menu/cr_action_menu.js'; |
| import 'chrome://resources/cr_elements/cr_button/cr_button.js'; |
| import 'chrome://resources/cr_elements/cr_icon_button/cr_icon_button.js'; |
| import 'chrome://resources/cr_elements/cr_icons.css.js'; |
| import 'chrome://resources/cr_elements/cr_hidden_style.css.js'; |
| // <if expr="_google_chrome"> |
| import 'chrome://resources/cr_elements/cr_link_row/cr_link_row.js'; |
| // </if> |
| import 'chrome://resources/cr_elements/cr_progress/cr_progress.js'; |
| import 'chrome://resources/cr_elements/icons.html.js'; |
| import 'chrome://resources/cr_elements/cr_shared_vars.css.js'; |
| import 'chrome://resources/js/action_link.js'; |
| import 'chrome://resources/cr_elements/action_link.css.js'; |
| import './strings.m.js'; |
| import 'chrome://resources/polymer/v3_0/iron-icon/iron-icon.js'; |
| |
| import {getInstance as getAnnouncerInstance} from 'chrome://resources/cr_elements/cr_a11y_announcer/cr_a11y_announcer.js'; |
| import type {CrActionMenuElement} from 'chrome://resources/cr_elements/cr_action_menu/cr_action_menu.js'; |
| import type {CrIconButtonElement} from 'chrome://resources/cr_elements/cr_icon_button/cr_icon_button.js'; |
| import {getToastManager} from 'chrome://resources/cr_elements/cr_toast/cr_toast_manager.js'; |
| import {FocusRowMixin} from 'chrome://resources/cr_elements/focus_row_mixin.js'; |
| import {I18nMixin} from 'chrome://resources/cr_elements/i18n_mixin.js'; |
| import {assert, assertNotReached} from 'chrome://resources/js/assert.js'; |
| import {loadTimeData} from 'chrome://resources/js/load_time_data.js'; |
| import {mojoString16ToString} from 'chrome://resources/js/mojo_type_util.js'; |
| import {sanitizeInnerHtml} from 'chrome://resources/js/parse_html_subset.js'; |
| import {htmlEscape} from 'chrome://resources/js/util.js'; |
| import type {String16} from 'chrome://resources/mojo/mojo/public/mojom/base/string16.mojom-webui.js'; |
| import {PolymerElement} from 'chrome://resources/polymer/v3_0/polymer/polymer_bundled.min.js'; |
| |
| import {BrowserProxy} from './browser_proxy.js'; |
| import type {MojomData} from './data.js'; |
| import type {PageHandlerInterface} from './downloads.mojom-webui.js'; |
| import {DangerType, SafeBrowsingState, State, TailoredWarningType} from './downloads.mojom-webui.js'; |
| import {IconLoaderImpl} from './icon_loader.js'; |
| import {getTemplate} from './item.html.js'; |
| |
| export interface DownloadsItemElement { |
| $: { |
| 'controlled-by': HTMLElement, |
| 'file-icon': HTMLImageElement, |
| 'file-link': HTMLAnchorElement, |
| 'referrer-url': HTMLAnchorElement, |
| 'url': HTMLAnchorElement, |
| }; |
| } |
| |
| const DownloadsItemElementBase = I18nMixin(FocusRowMixin(PolymerElement)); |
| |
| /** |
| * The UI pattern for displaying a download. Computed from DangerType and other |
| * properties of the download and user's profile. |
| */ |
| enum DisplayType { |
| NORMAL, |
| DANGEROUS, |
| SUSPICIOUS, |
| UNVERIFIED, |
| INSECURE, |
| ERROR, |
| } |
| |
| export class DownloadsItemElement extends DownloadsItemElementBase { |
| static get is() { |
| return 'downloads-item'; |
| } |
| |
| static get template() { |
| return getTemplate(); |
| } |
| |
| static get properties() { |
| return { |
| data: Object, |
| |
| completelyOnDisk_: { |
| computed: 'computeCompletelyOnDisk_(' + |
| 'data.state, data.fileExternallyRemoved)', |
| type: Boolean, |
| value: true, |
| }, |
| |
| shouldLinkFilename_: { |
| computed: 'computeShouldLinkFilename_(' + |
| 'data.dangerType, completelyOnDisk_)', |
| type: Boolean, |
| value: true, |
| }, |
| |
| hasShowInFolderLink_: { |
| computed: 'computeHasShowInFolderLink_(' + |
| 'data.state, data.fileExternallyRemoved, data.dangerType)', |
| type: Boolean, |
| value: true, |
| }, |
| |
| controlledBy_: { |
| computed: 'computeControlledBy_(data.byExtId, data.byExtName)', |
| type: String, |
| value: '', |
| }, |
| |
| iconAriaLabel_: { |
| type: String, |
| computed: 'computeIconAriaLabel_(displayType_)', |
| }, |
| |
| isActive_: { |
| computed: 'computeIsActive_(data.fileExternallyRemoved, completelyOnDisk_)', |
| type: Boolean, |
| value: true, |
| }, |
| |
| isDangerous_: { |
| computed: 'computeIsDangerous_(data.state)', |
| type: Boolean, |
| value: false, |
| }, |
| |
| isMalware_: { |
| computed: 'computeIsMalware_(isDangerous_, data.dangerType)', |
| type: Boolean, |
| value: false, |
| }, |
| |
| isReviewable_: { |
| computed: 'computeIsReviewable_(data.isReviewable)', |
| type: Boolean, |
| value: false, |
| }, |
| |
| isInProgress_: { |
| computed: 'computeIsInProgress_(data.state)', |
| type: Boolean, |
| value: false, |
| }, |
| |
| pauseOrResumeText_: { |
| computed: 'computePauseOrResumeText_(isInProgress_, data.resume)', |
| type: String, |
| }, |
| |
| showCancel_: { |
| computed: 'computeShowCancel_(data.state)', |
| type: Boolean, |
| value: false, |
| }, |
| |
| showProgress_: { |
| computed: 'computeShowProgress_(showCancel_, data.percent)', |
| type: Boolean, |
| value: false, |
| }, |
| |
| showDeepScan_: { |
| computed: 'computeShowDeepScan_(data.state)', |
| type: Boolean, |
| value: false, |
| }, |
| |
| showOpenAnyway_: { |
| computed: 'computeShowOpenAnyway_(data.dangerType)', |
| type: Boolean, |
| value: false, |
| }, |
| |
| displayType_: { |
| computed: 'computeDisplayType_(data.isInsecure, data.state,' + |
| 'data.dangerType, data.safeBrowsingState,' + |
| 'data.hasSafeBrowsingVerdict)', |
| type: DisplayType, |
| value: DisplayType.NORMAL, |
| }, |
| |
| // <if expr="_google_chrome"> |
| showEsbPromotion: { |
| type: Boolean, |
| value: false, |
| }, |
| // </if> |
| |
| useFileIcon_: Boolean, |
| |
| showReferrerUrl_: { |
| type: Boolean, |
| value: () => loadTimeData.getBoolean('showReferrerUrl'), |
| }, |
| }; |
| } |
| |
| static get observers() { |
| return [ |
| // TODO(dbeam): this gets called way more when I observe data.byExtId |
| // and data.byExtName directly. Why? |
| 'observeControlledBy_(controlledBy_)', |
| 'observeDisplayType_(displayType_, isDangerous_, data.*)', |
| 'restoreFocusAfterCancelIfNeeded_(data)', |
| ]; |
| } |
| |
| data: MojomData; |
| // <if expr="_google_chrome"> |
| showEsbPromotion: boolean; |
| // </if> |
| private mojoHandler_: PageHandlerInterface|null = null; |
| private controlledBy_: string; |
| private iconAriaLabel_: string; |
| private isActive_: boolean; |
| private isDangerous_: boolean; |
| private isReviewable_: boolean; |
| private isInProgress_: boolean; |
| private pauseOrResumeText_: string; |
| private showCancel_: boolean; |
| private showProgress_: boolean; |
| private showDeepScan_: boolean; |
| private showOpenAnyway_: boolean; |
| private useFileIcon_: boolean; |
| private restoreFocusAfterCancel_: boolean = false; |
| private displayType_: DisplayType; |
| private completelyOnDisk_: boolean; |
| override overrideCustomEquivalent: boolean; |
| |
| constructor() { |
| super(); |
| |
| /** Used by FocusRowMixin. */ |
| this.overrideCustomEquivalent = true; |
| } |
| |
| override ready() { |
| super.ready(); |
| |
| this.setAttribute('role', 'row'); |
| this.mojoHandler_ = BrowserProxy.getInstance().handler; |
| } |
| |
| /** Overrides FocusRowMixin. */ |
| override getCustomEquivalent(sampleElement: HTMLElement): HTMLElement|null { |
| if (sampleElement.getAttribute('focus-type') === 'cancel') { |
| return this.shadowRoot!.querySelector('[focus-type="retry"]'); |
| } |
| if (sampleElement.getAttribute('focus-type') === 'retry') { |
| return this.shadowRoot!.querySelector('[focus-type="pauseOrResume"]'); |
| } |
| return null; |
| } |
| |
| getFileIcon(): HTMLImageElement { |
| return this.$['file-icon']; |
| } |
| |
| getMoreActionsButton(): CrIconButtonElement|null { |
| const button = |
| this.shadowRoot!.querySelector<CrIconButtonElement>('#more-actions'); |
| return button || null; |
| } |
| |
| getMoreActionsMenu(): CrActionMenuElement { |
| const menu = this.shadowRoot!.querySelector<CrActionMenuElement>( |
| '#more-actions-menu'); |
| assert(!!menu); |
| return menu; |
| } |
| |
| /** |
| * @return A JS string of the display URL. |
| */ |
| private getDisplayUrlStr_(displayUrl: String16): string { |
| return mojoString16ToString(displayUrl); |
| } |
| |
| private computeClass_(): string { |
| const classes = []; |
| |
| if (this.isActive_) { |
| classes.push('is-active'); |
| } |
| |
| if (this.isDangerous_) { |
| classes.push('dangerous'); |
| } |
| |
| if (this.showProgress_) { |
| classes.push('show-progress'); |
| } |
| |
| return classes.join(' '); |
| } |
| |
| private computeCompletelyOnDisk_(): boolean { |
| if (this.data.fileExternallyRemoved) { |
| return false; |
| } |
| switch (this.data.state) { |
| case State.kComplete: |
| return true; |
| case State.kInProgress: |
| case State.kCancelled: |
| case State.kPaused: |
| case State.kDangerous: |
| case State.kInterrupted: |
| case State.kInsecure: |
| case State.kAsyncScanning: |
| case State.kPromptForScanning: |
| case State.kPromptForLocalPasswordScanning: |
| return false; |
| default: |
| assertNotReached('Unhandled State encountered'); |
| } |
| } |
| |
| private computeShouldLinkFilename_(): boolean { |
| if (this.data === undefined) { |
| return false; |
| } |
| |
| if (!this.completelyOnDisk_) { |
| return false; |
| } |
| |
| switch (this.data.dangerType) { |
| case DangerType.kDeepScannedFailed: |
| return false; |
| case DangerType.kNoApplicableDangerType: |
| case DangerType.kDangerousFile: |
| case DangerType.kDangerousUrl: |
| case DangerType.kDangerousContent: |
| case DangerType.kCookieTheft: |
| case DangerType.kUncommonContent: |
| case DangerType.kDangerousHost: |
| case DangerType.kPotentiallyUnwanted: |
| case DangerType.kAsyncScanning: |
| case DangerType.kAsyncLocalPasswordScanning: |
| case DangerType.kBlockedPasswordProtected: |
| case DangerType.kBlockedTooLarge: |
| case DangerType.kSensitiveContentWarning: |
| case DangerType.kSensitiveContentBlock: |
| case DangerType.kDeepScannedSafe: |
| case DangerType.kDeepScannedOpenedDangerous: |
| case DangerType.kBlockedScanFailed: |
| return true; |
| default: |
| assertNotReached('Unhandled DangerType encountered'); |
| } |
| } |
| |
| private computeHasShowInFolderLink_(): boolean { |
| if (this.data === undefined) { |
| return false; |
| } |
| |
| if (!this.computeCompletelyOnDisk_()) { |
| return false; |
| } |
| |
| switch (this.data.dangerType) { |
| case DangerType.kDeepScannedFailed: |
| return false; |
| case DangerType.kNoApplicableDangerType: |
| case DangerType.kDangerousFile: |
| case DangerType.kDangerousUrl: |
| case DangerType.kDangerousContent: |
| case DangerType.kCookieTheft: |
| case DangerType.kUncommonContent: |
| case DangerType.kDangerousHost: |
| case DangerType.kPotentiallyUnwanted: |
| case DangerType.kAsyncScanning: |
| case DangerType.kAsyncLocalPasswordScanning: |
| case DangerType.kBlockedPasswordProtected: |
| case DangerType.kBlockedTooLarge: |
| case DangerType.kSensitiveContentWarning: |
| case DangerType.kSensitiveContentBlock: |
| case DangerType.kDeepScannedSafe: |
| case DangerType.kDeepScannedOpenedDangerous: |
| case DangerType.kBlockedScanFailed: |
| return true; |
| default: |
| assertNotReached('Unhandled DangerType encountered'); |
| } |
| } |
| |
| private computeControlledBy_(): string { |
| if (!this.data.byExtId || !this.data.byExtName) { |
| return ''; |
| } |
| |
| const url = `chrome://extensions/?id=${this.data.byExtId}`; |
| const name = this.data.byExtName; |
| return loadTimeData.getStringF('controlledByUrl', url, htmlEscape(name)); |
| } |
| |
| private computeDate_(): string { |
| assert(typeof this.data.hideDate === 'boolean'); |
| if (this.data.hideDate) { |
| return ''; |
| } |
| return this.data.sinceString || this.data.dateString; |
| } |
| |
| private computeDescriptionVisible_(): boolean { |
| return this.computeDescription_() !== ''; |
| } |
| |
| private computeSecondLineVisible_(): boolean { |
| if (!this.data) { |
| return false; |
| } |
| switch (this.data.state) { |
| case State.kAsyncScanning: |
| return true; |
| case State.kInProgress: |
| case State.kCancelled: |
| case State.kComplete: |
| case State.kPaused: |
| case State.kDangerous: |
| case State.kInterrupted: |
| case State.kInsecure: |
| case State.kPromptForScanning: |
| case State.kPromptForLocalPasswordScanning: |
| return false; |
| default: |
| assertNotReached('Unhandled State encountered'); |
| } |
| } |
| |
| private isSuspiciousEnterpriseApVerdict_( |
| requestsApVerdicts: boolean, dangerType: DangerType): boolean { |
| switch (dangerType) { |
| case DangerType.kUncommonContent: |
| return requestsApVerdicts; |
| case DangerType.kSensitiveContentWarning: |
| return true; |
| case DangerType.kNoApplicableDangerType: |
| case DangerType.kDangerousFile: |
| case DangerType.kDangerousUrl: |
| case DangerType.kDangerousContent: |
| case DangerType.kCookieTheft: |
| case DangerType.kDangerousHost: |
| case DangerType.kPotentiallyUnwanted: |
| case DangerType.kAsyncScanning: |
| case DangerType.kAsyncLocalPasswordScanning: |
| case DangerType.kBlockedPasswordProtected: |
| case DangerType.kBlockedTooLarge: |
| case DangerType.kSensitiveContentBlock: |
| case DangerType.kDeepScannedFailed: |
| case DangerType.kDeepScannedSafe: |
| case DangerType.kDeepScannedOpenedDangerous: |
| case DangerType.kBlockedScanFailed: |
| return false; |
| default: |
| assertNotReached('Unhandled DangerType encountered'); |
| } |
| } |
| |
| private computeDisplayType_(): DisplayType { |
| // Most downloads are normal. If we don't have data, don't assume danger. |
| if (!this.data) { |
| return DisplayType.NORMAL; |
| } |
| |
| if (this.data.isInsecure) { |
| return DisplayType.INSECURE; |
| } |
| |
| switch (this.data.state) { |
| case State.kAsyncScanning: |
| case State.kPromptForScanning: |
| case State.kPromptForLocalPasswordScanning: |
| return DisplayType.SUSPICIOUS; |
| case State.kInsecure: |
| return DisplayType.INSECURE; |
| case State.kInProgress: |
| case State.kCancelled: |
| case State.kComplete: |
| case State.kPaused: |
| case State.kDangerous: |
| case State.kInterrupted: |
| break; |
| default: |
| assertNotReached('Unhandled State encountered'); |
| } |
| |
| // Enterprise AP verdicts. |
| if (this.isSuspiciousEnterpriseApVerdict_( |
| loadTimeData.getBoolean('requestsApVerdicts'), |
| this.data.dangerType)) { |
| return DisplayType.SUSPICIOUS; |
| } |
| |
| switch (this.data.dangerType) { |
| // Mimics logic in download_ui_model.cc for downloads with danger_type |
| // DOWNLOAD_DANGER_TYPE_DANGEROUS_FILE. |
| case DangerType.kDangerousFile: |
| return this.data.hasSafeBrowsingVerdict ? DisplayType.SUSPICIOUS : |
| DisplayType.UNVERIFIED; |
| case DangerType.kDangerousUrl: |
| case DangerType.kDangerousContent: |
| case DangerType.kCookieTheft: |
| case DangerType.kDangerousHost: |
| case DangerType.kPotentiallyUnwanted: |
| case DangerType.kDeepScannedOpenedDangerous: |
| return DisplayType.DANGEROUS; |
| case DangerType.kUncommonContent: |
| case DangerType.kDeepScannedFailed: |
| return DisplayType.SUSPICIOUS; |
| case DangerType.kNoApplicableDangerType: |
| case DangerType.kAsyncScanning: |
| case DangerType.kAsyncLocalPasswordScanning: |
| case DangerType.kSensitiveContentWarning: |
| case DangerType.kDeepScannedSafe: |
| case DangerType.kBlockedScanFailed: |
| return DisplayType.NORMAL; |
| case DangerType.kBlockedPasswordProtected: |
| case DangerType.kBlockedTooLarge: |
| case DangerType.kSensitiveContentBlock: |
| return DisplayType.ERROR; |
| default: |
| assertNotReached('Unhandled DangerType encountered'); |
| } |
| } |
| |
| private computeDeepScanControlText_(): string { |
| switch (this.data.state) { |
| case State.kPromptForScanning: |
| return loadTimeData.getString('controlDeepScan'); |
| case State.kPromptForLocalPasswordScanning: |
| return loadTimeData.getString('controlLocalPasswordScan'); |
| case State.kInProgress: |
| case State.kCancelled: |
| case State.kComplete: |
| case State.kPaused: |
| case State.kDangerous: |
| case State.kInterrupted: |
| case State.kInsecure: |
| case State.kAsyncScanning: |
| return ''; |
| default: |
| assertNotReached('Unhandled State encountered'); |
| } |
| } |
| |
| private computeSaveDangerousLabel_(): string { |
| switch (this.displayType_) { |
| case DisplayType.DANGEROUS: |
| return this.i18n('controlKeepDangerous'); |
| case DisplayType.SUSPICIOUS: |
| return this.i18n('controlKeepSuspicious'); |
| case DisplayType.UNVERIFIED: |
| return this.i18n('controlKeepUnverified'); |
| case DisplayType.INSECURE: |
| return this.i18n('controlKeepInsecure'); |
| case DisplayType.NORMAL: |
| case DisplayType.ERROR: |
| return ''; |
| default: |
| assertNotReached('Unhandled DisplayType encountered'); |
| } |
| } |
| |
| private computeDescription_(): string { |
| if (!this.data) { |
| return ''; |
| } |
| |
| const data = this.data; |
| |
| switch (data.state) { |
| case State.kComplete: |
| switch (data.dangerType) { |
| case DangerType.kDeepScannedOpenedDangerous: |
| return loadTimeData.getString('deepScannedOpenedDangerousDesc'); |
| case DangerType.kDeepScannedFailed: |
| return loadTimeData.getString('deepScannedFailedDesc'); |
| case DangerType.kNoApplicableDangerType: |
| case DangerType.kDangerousFile: |
| case DangerType.kDangerousUrl: |
| case DangerType.kDangerousContent: |
| case DangerType.kCookieTheft: |
| case DangerType.kUncommonContent: |
| case DangerType.kDangerousHost: |
| case DangerType.kPotentiallyUnwanted: |
| case DangerType.kAsyncScanning: |
| case DangerType.kAsyncLocalPasswordScanning: |
| case DangerType.kBlockedPasswordProtected: |
| case DangerType.kBlockedTooLarge: |
| case DangerType.kSensitiveContentWarning: |
| case DangerType.kSensitiveContentBlock: |
| case DangerType.kDeepScannedSafe: |
| case DangerType.kBlockedScanFailed: |
| return ''; |
| default: |
| assertNotReached('Unhandled DangerType encountered'); |
| } |
| case State.kInsecure: |
| return loadTimeData.getString('insecureDownloadDesc'); |
| case State.kDangerous: |
| switch (data.dangerType) { |
| case DangerType.kNoApplicableDangerType: |
| return ''; |
| case DangerType.kDangerousFile: |
| return data.safeBrowsingState === |
| SafeBrowsingState.kNoSafeBrowsing ? |
| loadTimeData.getString('noSafeBrowsingDesc') : |
| loadTimeData.getString('dangerFileDesc'); |
| case DangerType.kDangerousUrl: |
| case DangerType.kDangerousContent: |
| case DangerType.kDangerousHost: |
| return loadTimeData.getString('dangerDownloadDesc'); |
| case DangerType.kCookieTheft: |
| switch (data.tailoredWarningType) { |
| case TailoredWarningType.kCookieTheft: |
| return loadTimeData.getString('dangerDownloadCookieTheft'); |
| case TailoredWarningType.kCookieTheftWithAccountInfo: |
| return data.accountEmail ? |
| loadTimeData.getStringF( |
| 'dangerDownloadCookieTheftAndAccountDesc', |
| data.accountEmail) : |
| loadTimeData.getString('dangerDownloadCookieTheft'); |
| case TailoredWarningType.kSuspiciousArchive: |
| case TailoredWarningType.kNoApplicableTailoredWarningType: |
| return loadTimeData.getString('dangerDownloadDesc'); |
| default: |
| assertNotReached('Unhandled TailoredWarningType encountered'); |
| } |
| case DangerType.kUncommonContent: |
| switch (data.tailoredWarningType) { |
| case TailoredWarningType.kSuspiciousArchive: |
| return loadTimeData.getString( |
| 'dangerUncommonSuspiciousArchiveDesc'); |
| case TailoredWarningType.kCookieTheft: |
| case TailoredWarningType.kCookieTheftWithAccountInfo: |
| case TailoredWarningType.kNoApplicableTailoredWarningType: |
| return loadTimeData.getString('dangerUncommonDesc'); |
| default: |
| assertNotReached('Unhandled TailoredWarningType encountered'); |
| } |
| case DangerType.kPotentiallyUnwanted: |
| return loadTimeData.getString('dangerSettingsDesc'); |
| case DangerType.kAsyncScanning: |
| case DangerType.kAsyncLocalPasswordScanning: |
| case DangerType.kBlockedPasswordProtected: |
| case DangerType.kBlockedTooLarge: |
| return ''; |
| case DangerType.kSensitiveContentWarning: |
| return loadTimeData.getString('sensitiveContentWarningDesc'); |
| case DangerType.kSensitiveContentBlock: |
| case DangerType.kDeepScannedFailed: |
| case DangerType.kDeepScannedSafe: |
| case DangerType.kDeepScannedOpenedDangerous: |
| case DangerType.kBlockedScanFailed: |
| return ''; |
| default: |
| assertNotReached('Unhandled DangerType encountered'); |
| } |
| case State.kAsyncScanning: |
| return loadTimeData.getString('asyncScanningDownloadDesc'); |
| case State.kPromptForScanning: |
| return loadTimeData.getString('promptForScanningDesc'); |
| case State.kPromptForLocalPasswordScanning: |
| return loadTimeData.getString('promptForLocalPasswordScanningDesc'); |
| case State.kInProgress: |
| case State.kPaused: // Fallthrough. |
| return data.progressStatusText; |
| case State.kInterrupted: |
| switch (data.dangerType) { |
| case DangerType.kNoApplicableDangerType: |
| case DangerType.kDangerousFile: |
| case DangerType.kDangerousUrl: |
| case DangerType.kDangerousContent: |
| case DangerType.kDangerousHost: |
| case DangerType.kCookieTheft: |
| case DangerType.kUncommonContent: |
| case DangerType.kPotentiallyUnwanted: |
| case DangerType.kAsyncScanning: |
| case DangerType.kAsyncLocalPasswordScanning: |
| return ''; |
| case DangerType.kBlockedPasswordProtected: |
| return loadTimeData.getString('blockedPasswordProtectedDesc'); |
| case DangerType.kBlockedTooLarge: |
| return loadTimeData.getString('blockedTooLargeDesc'); |
| case DangerType.kSensitiveContentWarning: |
| return ''; |
| case DangerType.kSensitiveContentBlock: |
| return loadTimeData.getString('sensitiveContentBlockedDesc'); |
| case DangerType.kDeepScannedFailed: |
| case DangerType.kDeepScannedSafe: |
| case DangerType.kDeepScannedOpenedDangerous: |
| case DangerType.kBlockedScanFailed: |
| return ''; |
| default: |
| assertNotReached('Unhandled DangerType encountered'); |
| } |
| case State.kCancelled: |
| return ''; |
| default: |
| assertNotReached('Unhandled State encountered'); |
| } |
| } |
| |
| private computeIconAriaHidden_(): string { |
| return (this.iconAriaLabel_ === '').toString(); |
| } |
| |
| private computeIconAriaLabel_(): string { |
| switch (this.displayType_) { |
| case DisplayType.DANGEROUS: |
| return this.i18n('accessibleLabelDangerous'); |
| case DisplayType.INSECURE: |
| return this.i18n('accessibleLabelInsecure'); |
| case DisplayType.UNVERIFIED: |
| return this.i18n('accessibleLabelUnverified'); |
| case DisplayType.SUSPICIOUS: |
| return this.i18n('accessibleLabelSuspicious'); |
| case DisplayType.NORMAL: |
| case DisplayType.ERROR: |
| return ''; |
| default: |
| assertNotReached('Unhandled DisplayType encountered'); |
| } |
| } |
| |
| private iconAndDescriptionColor_(): string { |
| switch (this.displayType_) { |
| case DisplayType.DANGEROUS: |
| case DisplayType.ERROR: |
| return 'red'; |
| case DisplayType.INSECURE: |
| case DisplayType.UNVERIFIED: |
| case DisplayType.SUSPICIOUS: |
| return 'grey'; |
| case DisplayType.NORMAL: |
| return ''; |
| default: |
| assertNotReached('Unhandled DisplayType encountered'); |
| } |
| } |
| |
| private computeIcon_(): string { |
| if (this.data) { |
| switch (this.displayType_) { |
| case DisplayType.DANGEROUS: |
| return 'downloads:dangerous'; |
| case DisplayType.INSECURE: |
| case DisplayType.UNVERIFIED: |
| case DisplayType.SUSPICIOUS: |
| return 'cr:warning'; |
| case DisplayType.ERROR: |
| return 'cr:error'; |
| case DisplayType.NORMAL: |
| break; |
| default: |
| assertNotReached('Unhandled DisplayType encountered'); |
| } |
| |
| assert(this.displayType_ === DisplayType.NORMAL); |
| const dangerType = this.data.dangerType as DangerType; |
| if (this.isSuspiciousEnterpriseApVerdict_( |
| loadTimeData.getBoolean('requestsApVerdicts'), dangerType)) { |
| return 'cr:warning'; |
| } |
| |
| switch (dangerType) { |
| case DangerType.kDeepScannedFailed: |
| return 'cr:info'; |
| case DangerType.kSensitiveContentBlock: |
| case DangerType.kBlockedTooLarge: |
| case DangerType.kBlockedPasswordProtected: |
| return 'cr:error'; |
| case DangerType.kNoApplicableDangerType: |
| case DangerType.kDangerousFile: |
| case DangerType.kDangerousUrl: |
| case DangerType.kDangerousContent: |
| case DangerType.kCookieTheft: |
| case DangerType.kUncommonContent: |
| case DangerType.kDangerousHost: |
| case DangerType.kPotentiallyUnwanted: |
| case DangerType.kAsyncScanning: |
| case DangerType.kAsyncLocalPasswordScanning: |
| case DangerType.kSensitiveContentWarning: |
| case DangerType.kDeepScannedSafe: |
| case DangerType.kDeepScannedOpenedDangerous: |
| case DangerType.kBlockedScanFailed: |
| break; |
| default: |
| assertNotReached('Unhandled DangerType encountered'); |
| } |
| |
| switch (this.data.state) { |
| case State.kAsyncScanning: |
| case State.kPromptForScanning: |
| case State.kPromptForLocalPasswordScanning: |
| return 'cr:warning'; |
| case State.kInProgress: |
| case State.kCancelled: |
| case State.kComplete: |
| case State.kPaused: |
| case State.kDangerous: |
| case State.kInterrupted: |
| case State.kInsecure: |
| break; |
| default: |
| assertNotReached('Unhandled State encountered'); |
| } |
| } |
| if (this.isDangerous_) { |
| return 'downloads:dangerous'; |
| } |
| if (!this.useFileIcon_) { |
| return 'cr:insert-drive-file'; |
| } |
| return ''; |
| } |
| |
| private computeIconColor_(): string { |
| if (this.data) { |
| return this.iconAndDescriptionColor_(); |
| } |
| if (this.isDangerous_) { |
| return 'red'; |
| } |
| if (!this.useFileIcon_) { |
| return 'light-grey'; |
| } |
| return ''; |
| } |
| |
| private computeIsActive_(): boolean { |
| if (this.data && this.data.fileExternallyRemoved) { |
| return false; |
| } |
| return this.completelyOnDisk_; |
| } |
| |
| private computeIsDangerous_(): boolean { |
| switch (this.data.state) { |
| case State.kDangerous: |
| case State.kInsecure: |
| return true; |
| case State.kInProgress: |
| case State.kCancelled: |
| case State.kComplete: |
| case State.kPaused: |
| case State.kInterrupted: |
| case State.kAsyncScanning: |
| case State.kPromptForScanning: |
| case State.kPromptForLocalPasswordScanning: |
| return false; |
| default: |
| assertNotReached('Unhandled State encountered'); |
| } |
| } |
| |
| private computeIsInProgress_(): boolean { |
| switch (this.data.state) { |
| case State.kInProgress: |
| return true; |
| case State.kCancelled: |
| case State.kComplete: |
| case State.kPaused: |
| case State.kDangerous: |
| case State.kInterrupted: |
| case State.kInsecure: |
| case State.kAsyncScanning: |
| case State.kPromptForScanning: |
| case State.kPromptForLocalPasswordScanning: |
| return false; |
| default: |
| assertNotReached('Unhandled State encountered'); |
| } |
| } |
| |
| private computeIsMalware_(): boolean { |
| if (!this.isDangerous_) { |
| return false; |
| } |
| |
| switch (this.data.dangerType) { |
| case DangerType.kDangerousUrl: |
| case DangerType.kDangerousContent: |
| case DangerType.kCookieTheft: |
| case DangerType.kDangerousHost: |
| case DangerType.kPotentiallyUnwanted: |
| return true; |
| case DangerType.kNoApplicableDangerType: |
| case DangerType.kDangerousFile: |
| case DangerType.kUncommonContent: |
| case DangerType.kAsyncScanning: |
| case DangerType.kAsyncLocalPasswordScanning: |
| case DangerType.kBlockedPasswordProtected: |
| case DangerType.kBlockedTooLarge: |
| case DangerType.kSensitiveContentWarning: |
| case DangerType.kSensitiveContentBlock: |
| case DangerType.kDeepScannedFailed: |
| case DangerType.kDeepScannedSafe: |
| case DangerType.kDeepScannedOpenedDangerous: |
| case DangerType.kBlockedScanFailed: |
| return false; |
| default: |
| assertNotReached('Unhandled DangerType encountered'); |
| } |
| } |
| |
| private computeIsReviewable_(): boolean { |
| return this.data.isReviewable; |
| } |
| |
| private computePauseOrResumeText_(): string { |
| if (this.data === undefined) { |
| return ''; |
| } |
| |
| if (this.isInProgress_) { |
| return loadTimeData.getString('controlPause'); |
| } |
| if (this.data.resume) { |
| return loadTimeData.getString('controlResume'); |
| } |
| return ''; |
| } |
| |
| private computeShowRemove_(): boolean { |
| const canDelete = loadTimeData.getBoolean('allowDeletingHistory'); |
| const hideRemove = this.isDangerous_ || this.showCancel_ || !canDelete; |
| return !hideRemove; |
| } |
| |
| private computeRemoveStyle_(): string { |
| return this.computeShowRemove_() ? '' : 'visibility: hidden'; |
| } |
| |
| private computeShowControlsForDangerous_(): boolean { |
| return !this.isReviewable_ && this.isDangerous_; |
| } |
| |
| private computeShowCancel_(): boolean { |
| if (!this.data) { |
| return false; |
| } |
| switch (this.data.state) { |
| case State.kInProgress: |
| case State.kPaused: |
| return true; |
| case State.kCancelled: |
| case State.kComplete: |
| case State.kDangerous: |
| case State.kInterrupted: |
| case State.kInsecure: |
| case State.kAsyncScanning: |
| case State.kPromptForScanning: |
| case State.kPromptForLocalPasswordScanning: |
| return false; |
| default: |
| assertNotReached('Unhandled State encountered'); |
| } |
| } |
| |
| private computeShowProgress_(): boolean { |
| if (!this.data) { |
| return false; |
| } |
| switch (this.data.state) { |
| case State.kInProgress: |
| case State.kCancelled: |
| case State.kComplete: |
| case State.kPaused: |
| case State.kDangerous: |
| case State.kInterrupted: |
| case State.kInsecure: |
| return this.showCancel_ && this.data.percent >= -1; |
| case State.kAsyncScanning: |
| return true; |
| case State.kPromptForScanning: |
| case State.kPromptForLocalPasswordScanning: |
| return false; |
| default: |
| assertNotReached('Unhandled State encountered'); |
| } |
| } |
| |
| private computeShowDeepScan_(): boolean { |
| switch (this.data.state) { |
| case State.kPromptForScanning: |
| case State.kPromptForLocalPasswordScanning: |
| return true; |
| case State.kInProgress: |
| case State.kCancelled: |
| case State.kComplete: |
| case State.kPaused: |
| case State.kDangerous: |
| case State.kInterrupted: |
| case State.kInsecure: |
| case State.kAsyncScanning: |
| return false; |
| default: |
| assertNotReached('Unhandled State encountered'); |
| } |
| } |
| |
| private computeShowOpenAnyway_(): boolean { |
| switch (this.data.dangerType) { |
| case DangerType.kDeepScannedFailed: |
| return true; |
| case DangerType.kNoApplicableDangerType: |
| case DangerType.kDangerousFile: |
| case DangerType.kDangerousUrl: |
| case DangerType.kDangerousContent: |
| case DangerType.kCookieTheft: |
| case DangerType.kUncommonContent: |
| case DangerType.kDangerousHost: |
| case DangerType.kPotentiallyUnwanted: |
| case DangerType.kAsyncScanning: |
| case DangerType.kAsyncLocalPasswordScanning: |
| case DangerType.kBlockedPasswordProtected: |
| case DangerType.kBlockedTooLarge: |
| case DangerType.kSensitiveContentWarning: |
| case DangerType.kSensitiveContentBlock: |
| case DangerType.kDeepScannedSafe: |
| case DangerType.kDeepScannedOpenedDangerous: |
| case DangerType.kBlockedScanFailed: |
| return false; |
| default: |
| assertNotReached('Unhandled DangerType encountered'); |
| } |
| } |
| |
| private computeShowActionMenu_(): boolean { |
| if (!this.data) { |
| return false; |
| } |
| // If any of these actions are available, the action menu must be shown |
| // because they don't have corresponding "quick actions". |
| return !!this.pauseOrResumeText_ || // pause-or-resume |
| this.computeShowControlsForDangerous_() || // save-dangerous |
| this.data.retry || // retry |
| this.showDeepScan_ || // deep-scan and bypass-deep-scan |
| this.showCancel_ || // cancel |
| this.showOpenAnyway_ || // open-anyway |
| this.isReviewable_; // review-dangerous |
| } |
| |
| private computeShowCopyDownloadLink_(): boolean { |
| return !!(this.data && this.data.url); |
| } |
| |
| private computeShowQuickRemove_(): boolean { |
| return this.isReviewable_ || this.computeShowRemove_() || |
| this.computeShowControlsForDangerous_(); |
| } |
| |
| private computeShowQuickShow_(): boolean { |
| // Only show the quick "show in folder" button if the full action menu |
| // is hidden. If the action menu is shown, hide the quick "show in folder" |
| // button to save space since this action will have an entry in the menu |
| // anyway. |
| return this.computeHasShowInFolderLink_() && !this.computeShowActionMenu_(); |
| } |
| |
| private computeTag_(): string { |
| switch (this.data.state) { |
| case State.kCancelled: |
| return loadTimeData.getString('statusCancelled'); |
| case State.kInterrupted: |
| return this.data.lastReasonText; |
| case State.kComplete: |
| return this.data.fileExternallyRemoved ? |
| loadTimeData.getString('statusRemoved') : |
| ''; |
| case State.kInProgress: |
| case State.kPaused: |
| case State.kDangerous: |
| case State.kInsecure: |
| case State.kAsyncScanning: |
| case State.kPromptForScanning: |
| case State.kPromptForLocalPasswordScanning: |
| return ''; |
| default: |
| assertNotReached('Unhandled State encountered'); |
| } |
| } |
| |
| private isIndeterminate_(): boolean { |
| if (this.data.percent === -1) { |
| return true; |
| } |
| switch (this.data.state) { |
| case State.kAsyncScanning: |
| return true; |
| case State.kInProgress: |
| case State.kCancelled: |
| case State.kComplete: |
| case State.kPaused: |
| case State.kDangerous: |
| case State.kInterrupted: |
| case State.kInsecure: |
| case State.kPromptForScanning: |
| case State.kPromptForLocalPasswordScanning: |
| return false; |
| default: |
| assertNotReached('Unhandled State encountered'); |
| } |
| } |
| |
| private observeControlledBy_() { |
| this.$['controlled-by'].innerHTML = sanitizeInnerHtml(this.controlledBy_); |
| if (this.controlledBy_) { |
| const link = this.shadowRoot!.querySelector('#controlled-by a'); |
| link!.setAttribute('focus-row-control', ''); |
| link!.setAttribute('focus-type', 'controlledBy'); |
| } |
| } |
| |
| private shouldShowReferrerUrl_(): boolean { |
| return loadTimeData.getBoolean('showReferrerUrl') && |
| this.data.displayReferrerUrl.data.length > 0; |
| } |
| |
| getReferrerUrlAnchorElement(): HTMLAnchorElement|null { |
| return this.$['referrer-url'].querySelector('a') || null; |
| } |
| |
| private observeDisplayType_() { |
| const removeFileUrlLinks = () => { |
| this.$.url.removeAttribute('href'); |
| this.$['file-link'].removeAttribute('href'); |
| }; |
| |
| const updateReferrerUrlLinkHref = (hrefValue?: string) => { |
| const referrerUrlLink = this.getReferrerUrlAnchorElement(); |
| if (!referrerUrlLink) { |
| // No <a> tag, nothing to do. |
| return; |
| } |
| if (!hrefValue) { |
| referrerUrlLink.removeAttribute('href'); |
| return; |
| } |
| referrerUrlLink.setAttribute('href', hrefValue); |
| referrerUrlLink.setAttribute('focus-row-control', ''); |
| referrerUrlLink.setAttribute('focus-type', 'referrerUrl'); |
| referrerUrlLink.setAttribute('target', '_blank'); |
| referrerUrlLink.setAttribute('rel', 'noopener'); |
| }; |
| |
| if (!this.data) { |
| return; |
| } |
| |
| // "else" case already handled by `shouldShowReferrerUrl_`. |
| if (this.data.displayReferrerUrl.data.length > 0) { |
| const referrerLine = loadTimeData.getStringF( |
| 'referrerLine', mojoString16ToString(this.data.displayReferrerUrl)); |
| this.$['referrer-url'].innerHTML = sanitizeInnerHtml(referrerLine); |
| } |
| |
| // Returns whether to use the file icon, and additionally clears file url |
| // links if necessary. |
| const mayUseFileIcon = () => { |
| const use = this.displayType_ === DisplayType.NORMAL; |
| if (!use) { |
| removeFileUrlLinks(); |
| updateReferrerUrlLinkHref(); |
| } |
| return use; |
| }; |
| |
| this.useFileIcon_ = mayUseFileIcon(); |
| if (!this.useFileIcon_) { |
| return; |
| } |
| |
| // The file is not dangerous. Link the url if supplied. |
| if (this.data.url) { |
| this.$.url.href = this.data.url.url; |
| } else { |
| removeFileUrlLinks(); |
| } |
| |
| // The file is not dangerous. Link the referrer_url if supplied. |
| if (this.data.referrerUrl) { |
| updateReferrerUrlLinkHref(this.data.referrerUrl.url); |
| } else { |
| updateReferrerUrlLinkHref(); |
| } |
| |
| const path = this.data.filePath; |
| IconLoaderImpl.getInstance() |
| .loadIcon(this.$['file-icon'], path) |
| .then(success => { |
| if (path === this.data.filePath && |
| this.data.state !== State.kAsyncScanning) { |
| // Check again if we may use the file icon, to avoid a race between |
| // loading the icon and determining the proper danger type. |
| this.useFileIcon_ = mayUseFileIcon() && success; |
| } |
| }); |
| } |
| |
| // <if expr="_google_chrome"> |
| private onEsbPromotionClick_() { |
| assert(!!this.mojoHandler_); |
| this.mojoHandler_.openEsbSettings(); |
| } |
| // </if> |
| |
| private onCopyDownloadLinkClick_(e: Event) { |
| if (!this.data.url) { |
| return; |
| } |
| navigator.clipboard.writeText(this.data.url.url); |
| this.displayCopyToast_(e); |
| } |
| |
| private onMoreActionsClick_() { |
| const button = this.getMoreActionsButton(); |
| // The menu button is not always shown, but if this handler is invoked, then |
| // it must be. |
| assert(!!button); |
| this.getMoreActionsMenu().showAt(button); |
| } |
| |
| // Handles the "x" remove button which can be different actions depending on |
| // the state of the download. |
| private onQuickRemoveClick_(e: Event) { |
| if (this.isReviewable_ || this.computeShowControlsForDangerous_()) { |
| this.onDiscardDangerousClick_(e); |
| return; |
| } |
| assert(this.computeShowRemove_()); |
| this.onRemoveClick_(e); |
| } |
| |
| private onCancelClick_() { |
| this.restoreFocusAfterCancel_ = true; |
| assert(!!this.mojoHandler_); |
| this.mojoHandler_.cancel(this.data.id); |
| getAnnouncerInstance().announce( |
| loadTimeData.getString('screenreaderCanceled')); |
| this.getMoreActionsMenu().close(); |
| } |
| |
| private onDiscardDangerousClick_(e: Event) { |
| assert(!!this.mojoHandler_); |
| this.mojoHandler_.discardDangerous(this.data.id); |
| this.displayRemovedToast_(/*canUndo=*/ false, e); |
| this.getMoreActionsMenu().close(); |
| } |
| |
| private onOpenNowClick_() { |
| this.mojoHandler_!.openDuringScanningRequiringGesture(this.data.id); |
| this.getMoreActionsMenu().close(); |
| } |
| |
| private onDeepScanClick_() { |
| this.mojoHandler_!.deepScan(this.data.id); |
| this.getMoreActionsMenu().close(); |
| } |
| |
| private onBypassDeepScanClick_() { |
| this.mojoHandler_!.bypassDeepScanRequiringGesture(this.data.id); |
| this.getMoreActionsMenu().close(); |
| } |
| |
| private onReviewDangerousClick_() { |
| this.mojoHandler_!.reviewDangerousRequiringGesture(this.data.id); |
| this.getMoreActionsMenu().close(); |
| } |
| |
| private onOpenAnywayClick_() { |
| this.mojoHandler_!.openFileRequiringGesture(this.data.id); |
| this.getMoreActionsMenu().close(); |
| } |
| |
| private onDragStart_(e: Event) { |
| e.preventDefault(); |
| this.mojoHandler_!.drag(this.data.id); |
| } |
| |
| private onFileLinkClick_(e: Event) { |
| e.preventDefault(); |
| this.mojoHandler_!.openFileRequiringGesture(this.data.id); |
| } |
| |
| private onUrlClick_() { |
| if (!this.data.url) { |
| return; |
| } |
| chrome.send( |
| 'metricsHandler:recordAction', ['Downloads_OpenUrlOfDownloadedItem']); |
| } |
| |
| private doPause_() { |
| assert(!!this.mojoHandler_); |
| this.mojoHandler_.pause(this.data.id); |
| getAnnouncerInstance().announce( |
| loadTimeData.getString('screenreaderPaused')); |
| } |
| |
| private doResume_() { |
| assert(!!this.mojoHandler_); |
| this.mojoHandler_.resume(this.data.id); |
| getAnnouncerInstance().announce( |
| loadTimeData.getString('screenreaderResumed')); |
| } |
| |
| private onPauseOrResumeClick_() { |
| if (this.isInProgress_) { |
| this.doPause_(); |
| } else { |
| this.doResume_(); |
| } |
| this.getMoreActionsMenu().close(); |
| } |
| |
| private displayCopyToast_(e: Event) { |
| if (!this.data.url) { |
| return; |
| } |
| |
| const pieces = loadTimeData.getSubstitutedStringPieces( |
| loadTimeData.getString('toastCopiedDownloadLink'), |
| this.data.url.url) as unknown as |
| Array<{collapsible: boolean, value: string, arg: string}>; |
| pieces.forEach(p => { |
| p.collapsible = !!p.arg; |
| }); |
| getToastManager().showForStringPieces(pieces, /*hideSlotted=*/ true); |
| |
| e.stopPropagation(); |
| e.preventDefault(); |
| } |
| |
| private displayRemovedToast_(canUndo: boolean, e: Event) { |
| const templateStringId = |
| (this.displayType_ === DisplayType.NORMAL && this.completelyOnDisk_) ? |
| 'toastDeletedFromHistoryStillOnDevice' : |
| 'toastDeletedFromHistory'; |
| const pieces = |
| loadTimeData.getSubstitutedStringPieces( |
| loadTimeData.getString(templateStringId), this.data.fileName) as |
| unknown as Array<{collapsible: boolean, value: string, arg?: string}>; |
| |
| pieces.forEach(p => { |
| // Make the file name collapsible. |
| p.collapsible = !!p.arg; |
| }); |
| getToastManager().showForStringPieces(pieces, /*hideSlotted=*/ !canUndo); |
| |
| // Stop propagating a click to the document to remove toast. |
| e.stopPropagation(); |
| e.preventDefault(); |
| } |
| |
| private onRemoveClick_(e: Event) { |
| assert(!!this.mojoHandler_); |
| this.mojoHandler_.remove(this.data.id); |
| const canUndo = !this.data.isDangerous && !this.data.isInsecure; |
| this.displayRemovedToast_(canUndo, e); |
| this.getMoreActionsMenu().close(); |
| } |
| |
| private onRetryClick_() { |
| this.mojoHandler_!.retryDownload(this.data.id); |
| this.getMoreActionsMenu().close(); |
| } |
| |
| private notifySaveDangerousClick_() { |
| this.dispatchEvent(new CustomEvent('save-dangerous-click', { |
| bubbles: true, |
| composed: true, |
| detail: {id: this.data.id}, |
| })); |
| } |
| |
| private onSaveDangerousClick_() { |
| this.getMoreActionsMenu().close(); |
| |
| if (this.displayType_ === DisplayType.DANGEROUS) { |
| this.notifySaveDangerousClick_(); |
| return; |
| } |
| |
| // "Suspicious" types which show up in grey can be validated directly. |
| // This maps each such display type to its applicable screenreader |
| // announcement string id. |
| const SAVED_FROM_PAGE_TYPES_ANNOUNCEMENTS = new Map([ |
| [DisplayType.SUSPICIOUS, 'screenreaderSavedSuspicious'], |
| [DisplayType.UNVERIFIED, 'screenreaderSavedUnverified'], |
| [DisplayType.INSECURE, 'screenreaderSavedInsecure'], |
| ]); |
| assert(SAVED_FROM_PAGE_TYPES_ANNOUNCEMENTS.has(this.displayType_)); |
| assert(!!this.mojoHandler_); |
| this.mojoHandler_.saveSuspiciousRequiringGesture(this.data.id); |
| const announcement = loadTimeData.getString( |
| SAVED_FROM_PAGE_TYPES_ANNOUNCEMENTS.get(this.displayType_) as string); |
| getAnnouncerInstance().announce(announcement); |
| } |
| |
| private onShowClick_() { |
| this.mojoHandler_!.show(this.data.id); |
| this.getMoreActionsMenu().close(); |
| } |
| |
| private restoreFocusAfterCancelIfNeeded_() { |
| if (!this.restoreFocusAfterCancel_) { |
| return; |
| } |
| this.restoreFocusAfterCancel_ = false; |
| setTimeout(() => { |
| const element = this.getFocusRow().getFirstFocusable('retry'); |
| if (element) { |
| (element as HTMLElement).focus(); |
| } |
| }); |
| } |
| } |
| |
| declare global { |
| interface HTMLElementTagNameMap { |
| 'downloads-item': DownloadsItemElement; |
| } |
| } |
| |
| customElements.define(DownloadsItemElement.is, DownloadsItemElement); |
