electron/spec-main/api-desktop-capturer-spec.ts
Jeremy Apthorp 2fad53e66b refactor: use v8 serialization for ipc (#20214)
* refactor: use v8 serialization for ipc

* cloning process.env doesn't work

* serialize host objects by enumerating key/values

* new serialization can handle NaN, Infinity, and undefined correctly

* can't allocate v8 objects during GC

* backport microtasks fix

* fix compile

* fix node_stream_loader reentrancy

* update subframe spec to expect undefined instead of null

* write undefined instead of crashing when serializing host objects

* fix webview spec

* fix download spec

* buffers are transformed into uint8arrays

* can't serialize promises

* fix chrome.i18n.getMessage

* fix devtools tests

* fix zoom test

* fix debug build

* fix lint

* update ipcRenderer tests

* fix printToPDF test

* update patch

* remove accidentally re-added remote-side spec

* wip

* don't attempt to serialize host objects

* jump through different hoops to set options.webContents sometimes

* whoops

* fix lint

* clean up error-handling logic

* fix memory leak

* fix lint

* convert host objects using old base::Value serialization

* fix lint more

* fall back to base::Value-based serialization

* remove commented-out code

* add docs to breaking-changes.md

* Update breaking-changes.md

* update ipcRenderer and WebContents docs

* lint

* use named values for format tag

* save a memcpy for ~30% speedup

* get rid of calls to ShallowClone

* extra debugging for paranoia

* d'oh, use the correct named tags

* apparently msstl doesn't like this DCHECK

* funny story about that DCHECK

* disable remote-related functions when enable_remote_module = false

* nits

* use EnableIf to disable remote methods in mojom

* fix include

* review comments
2019-10-09 13:59:08 -04:00

220 lines
8 KiB
TypeScript

import { expect } from 'chai'
import { desktopCapturer, screen, BrowserWindow, SourcesOptions } from 'electron'
import { emittedOnce } from './events-helpers'
import { ifdescribe, ifit } from './spec-helpers';
import { closeAllWindows } from './window-helpers';
const features = process.electronBinding('features')
ifdescribe(features.isDesktopCapturerEnabled() && !process.arch.includes('arm') && process.platform !== 'win32')('desktopCapturer', () => {
let w: BrowserWindow
before(async () => {
w = new BrowserWindow({ show: false, webPreferences: { nodeIntegration: true } })
await w.loadURL('about:blank')
})
after(closeAllWindows)
const getSources: typeof desktopCapturer.getSources = (options: SourcesOptions) => {
return w.webContents.executeJavaScript(`
require('electron').desktopCapturer.getSources(${JSON.stringify(options)}).then(m => JSON.parse(JSON.stringify(m)))
`)
}
it('should return a non-empty array of sources', async () => {
const sources = await getSources({ types: ['window', 'screen'] })
expect(sources).to.be.an('array').that.is.not.empty()
})
it('throws an error for invalid options', async () => {
const promise = getSources(['window', 'screen'] as any)
expect(promise).to.be.eventually.rejectedWith(Error, 'Invalid options')
})
it('does not throw an error when called more than once (regression)', async () => {
const sources1 = await getSources({ types: ['window', 'screen'] })
expect(sources1).to.be.an('array').that.is.not.empty()
const sources2 = await getSources({ types: ['window', 'screen'] })
expect(sources2).to.be.an('array').that.is.not.empty()
})
it('responds to subsequent calls of different options', async () => {
const promise1 = getSources({ types: ['window'] })
expect(promise1).to.not.eventually.be.rejected()
const promise2 = getSources({ types: ['screen'] })
expect(promise2).to.not.eventually.be.rejected()
})
// Linux doesn't return any window sources.
ifit(process.platform !== 'linux')('returns an empty display_id for window sources on Windows and Mac', async () => {
const w = new BrowserWindow({ width: 200, height: 200 })
const sources = await getSources({ types: ['window'] })
w.destroy()
expect(sources).to.be.an('array').that.is.not.empty()
for (const { display_id: displayId } of sources) {
expect(displayId).to.be.a('string').and.be.empty()
}
})
ifit(process.platform !== 'linux')('returns display_ids matching the Screen API on Windows and Mac', async () => {
const displays = screen.getAllDisplays()
const sources = await getSources({ types: ['screen'] })
expect(sources).to.be.an('array').of.length(displays.length)
for (let i = 0; i < sources.length; i++) {
expect(sources[i].display_id).to.equal(displays[i].id.toString())
}
})
ifit(process.platform !== 'linux')('returns an empty source list if blocked by the main process', async () => {
w.webContents.once('desktop-capturer-get-sources', (event) => {
event.preventDefault()
})
const sources = await getSources({ types: ['screen'] })
expect(sources).to.be.empty()
})
it('disabling thumbnail should return empty images', async () => {
const w2 = new BrowserWindow({ show: false, width: 200, height: 200 })
const wShown = emittedOnce(w2, 'show')
w2.show()
await wShown
const isEmpties: boolean[] = await w.webContents.executeJavaScript(`
require('electron').desktopCapturer.getSources({
types: ['window', 'screen'],
thumbnailSize: { width: 0, height: 0 }
}).then((sources) => {
return sources.map(s => s.thumbnail.constructor.name === 'NativeImage' && s.thumbnail.isEmpty())
})
`)
w2.destroy()
expect(isEmpties).to.be.an('array').that.is.not.empty()
expect(isEmpties.every(e => e === true)).to.be.true()
})
it('getMediaSourceId should match DesktopCapturerSource.id', async () => {
const w = new BrowserWindow({ show: false, width: 100, height: 100 })
const wShown = emittedOnce(w, 'show')
const wFocused = emittedOnce(w, 'focus')
w.show()
w.focus()
await wShown
await wFocused
const mediaSourceId = w.getMediaSourceId()
const sources = await getSources({
types: ['window'],
thumbnailSize: { width: 0, height: 0 }
})
w.destroy()
// TODO(julien.isorce): investigate why |sources| is empty on the linux
// bots while it is not on my workstation, as expected, with and without
// the --ci parameter.
if (process.platform === 'linux' && sources.length === 0) {
it.skip('desktopCapturer.getSources returned an empty source list')
return
}
expect(sources).to.be.an('array').that.is.not.empty()
const foundSource = sources.find((source) => {
return source.id === mediaSourceId
})
expect(mediaSourceId).to.equal(foundSource!.id)
})
it('moveAbove should move the window at the requested place', async () => {
// DesktopCapturer.getSources() is guaranteed to return in the correct
// z-order from foreground to background.
const MAX_WIN = 4
const mainWindow = w
const wList = [mainWindow]
try {
for (let i = 0; i < MAX_WIN - 1; i++) {
const w = new BrowserWindow({ show: true, width: 100, height: 100 })
wList.push(w)
}
expect(wList.length).to.equal(MAX_WIN)
// Show and focus all the windows.
wList.forEach(async (w) => {
const wFocused = emittedOnce(w, 'focus')
w.focus()
await wFocused
})
// At this point our windows should be showing from bottom to top.
// DesktopCapturer.getSources() returns sources sorted from foreground to
// background, i.e. top to bottom.
let sources = await getSources({
types: ['window'],
thumbnailSize: { width: 0, height: 0 }
})
// TODO(julien.isorce): investigate why |sources| is empty on the linux
// bots while it is not on my workstation, as expected, with and without
// the --ci parameter.
if (process.platform === 'linux' && sources.length === 0) {
wList.forEach((w) => {
if (w !== mainWindow) {
w.destroy()
}
})
it.skip('desktopCapturer.getSources returned an empty source list')
return
}
expect(sources).to.be.an('array').that.is.not.empty()
expect(sources.length).to.gte(MAX_WIN)
// Only keep our windows, they must be in the MAX_WIN first windows.
sources.splice(MAX_WIN, sources.length - MAX_WIN)
expect(sources.length).to.equal(MAX_WIN)
expect(sources.length).to.equal(wList.length)
// Check that the sources and wList are sorted in the reverse order.
const wListReversed = wList.slice(0).reverse()
const canGoFurther = sources.every(
(source, index) => source.id === wListReversed[index].getMediaSourceId())
if (!canGoFurther) {
// Skip remaining checks because either focus or window placement are
// not reliable in the running test environment. So there is no point
// to go further to test moveAbove as requirements are not met.
return
}
// Do the real work, i.e. move each window above the next one so that
// wList is sorted from foreground to background.
wList.forEach(async (w, index) => {
if (index < (wList.length - 1)) {
const wNext = wList[index + 1]
w.moveAbove(wNext.getMediaSourceId())
}
})
sources = await getSources({
types: ['window'],
thumbnailSize: { width: 0, height: 0 }
})
// Only keep our windows again.
sources.splice(MAX_WIN, sources.length - MAX_WIN)
expect(sources.length).to.equal(MAX_WIN)
expect(sources.length).to.equal(wList.length)
// Check that the sources and wList are sorted in the same order.
sources.forEach((source, index) => {
expect(source.id).to.equal(wList[index].getMediaSourceId())
})
} finally {
wList.forEach((w) => {
if (w !== mainWindow) {
w.destroy()
}
})
}
})
})