src/chromiumos/tast/local/chrome/ash/launcher.go - chromiumos/platform/tast-tests - Git at Google

 // Copyright 2019 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 package ash

 import (
 	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
 	"image"
 	"image/png"
 	"io/ioutil"
 	"os"
 	"path/filepath"
 	"time"

 	"chromiumos/tast/errors"
 	"chromiumos/tast/local/chrome"
 	"chromiumos/tast/local/chrome/internal/cdputil"
 	"chromiumos/tast/local/chrome/internal/extension"
 )

 // AppListBubbleClassName is the automation API class name of the bubble launcher.
 const AppListBubbleClassName = "AppListBubbleView"

 // LauncherState represents the launcher (a.k.a AppList) state.
 type LauncherState string

 // LauncherState as defined in
 // https://cs.chromium.org/chromium/src/ash/public/cpp/app_list/app_list_types.h
 const (
 	Peeking           LauncherState = "Peeking"
 	FullscreenAllApps LauncherState = "FullscreenAllApps"
 	FullscreenSearch  LauncherState = "FullscreenSearch"
 	Half              LauncherState = "Half"
 	Closed            LauncherState = "Closed"
 )

 // Accelerator represents the accelerator key to trigger certain actions.
 type Accelerator struct {
 	KeyCode string `json:"keyCode"`
 	Shift   bool   `json:"shift"`
 	Control bool   `json:"control"`
 	Alt     bool   `json:"alt"`
 	Search  bool   `json:"search"`
 }

 // Accelerator key used to trigger launcher state change.
 var (
 	AccelSearch      = Accelerator{KeyCode: "search", Shift: false, Control: false, Alt: false, Search: false}
 	AccelShiftSearch = Accelerator{KeyCode: "search", Shift: true, Control: false, Alt: false, Search: false}
 )

 // WaitForLauncherState waits until the launcher state becomes state. It waits
 // up to 10 seconds and fail if the launcher doesn't have the desired state.
 // Expected to fail with "Not supported for bubble launcher" error when waiting
 // for state different from "Closed" if called for clamshell productivity (bubble)
 // launcher. Note that the autotest API is expected to return immediately, but still
 // asynchronously, in this case.
 // NOTE: Waiting for "Closed" state will always wait for the fullscreen launcher to
 // hide, even if one would otherwise expect bubble launcher to be used for the current
 // session state - this supports waiting for launcher UI hide animation to complete
 // after transitioning from tablet mode to clamshell.
 func WaitForLauncherState(ctx context.Context, tconn *chrome.TestConn, state LauncherState) error {
 	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
 	defer cancel()
 	if err := tconn.Call(ctx, nil, "tast.promisify(chrome.autotestPrivate.waitForLauncherState)", state); err != nil {
 		return errors.Wrap(err, "failed to wait for launcher state")
 	}
 	return nil
 }

 // TriggerLauncherStateChange will cause the launcher state change via accelerator.
 func TriggerLauncherStateChange(ctx context.Context, tconn *chrome.TestConn, accel Accelerator) error {
 	// Send the press event to store it in the history. It'll not be handled, so ignore the result.
 	if err := tconn.Call(ctx, nil, `async (acceleratorKey) => {
 	  acceleratorKey.pressed = true;
 	  chrome.autotestPrivate.activateAccelerator(acceleratorKey, () => {});
 	  acceleratorKey.pressed = false;
 	  await tast.promisify(chrome.autotestPrivate.activateAccelerator)(acceleratorKey);
 	}`, accel); err != nil {
 		return errors.Wrap(err, "failed to execute accelerator")
 	}
 	return nil
 }

 func scaleImage(src image.Image, siz int) image.Image {
 	srcSize := src.Bounds().Size().X
 	scaled := image.NewRGBA(image.Rect(0, 0, siz, siz))
 	for x := 0; x < siz; x++ {
 		for y := 0; y < siz; y++ {
 			scaled.Set(x, y, src.At(x*srcSize/siz, y*srcSize/siz))
 		}
 	}
 	return scaled
 }

 func saveImageAsPng(filename string, img image.Image) error {
 	w, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE, 0644)
 	if err != nil {
 		return err
 	}
 	defer w.Close()
 	return png.Encode(w, img)
 }

 // generateFakeAppNames generates default names for fake apps.
 func generateFakeAppNames(numFakeApps int) []string {
 	fakeAppNames := make([]string, numFakeApps)
 	for i := 0; i < numFakeApps; i++ {
 		fakeAppNames[i] = fmt.Sprintf("fake app %d", i)
 	}
 	return fakeAppNames
 }

 // GeneratePrepareFakeAppsWithNamesOptions calls PrepareDefaultFakeApps() and
 // returns options to be used by chrome.New() for logging in with the newly
 // created fake apps. baseDir is the path to the directory for keeping app data.
 // The function caller should always clean baseDir regardless of function
 // execution results. names specify app names.
 func GeneratePrepareFakeAppsWithNamesOptions(baseDir string, names []string) ([]chrome.Option, error) {
 	dirs, err := PrepareDefaultFakeApps(baseDir, names, true)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to create fake apps")
 	}

 	opts := make([]chrome.Option, 0, len(names))
 	for _, dir := range dirs {
 		opts = append(opts, chrome.UnpackedExtension(dir))
 	}
 	return opts, nil
 }

 // GeneratePrepareFakeAppsWithIconDataOptions is similar with GeneratePrepareFakeAppsWithNamesOptions,
 // with a difference that GeneratePrepareFakeAppsWithIconDataOptions allows the
 // caller to specify both app names and icon data. The caller has the duty to
 // clean baseDir.
 func GeneratePrepareFakeAppsWithIconDataOptions(baseDir string, names []string, iconData [][]byte) ([]chrome.Option, error) {
 	if len(names) != len(iconData) {
 		return nil, errors.Errorf("unexpected count of icon data: got %d, expecting %d", len(iconData), len(names))
 	}

 	dirs, err := prepareFakeAppsWithIconData(baseDir, names, iconData)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to prepare data for fake apps")
 	}

 	opts := make([]chrome.Option, 0, len(names))
 	for _, dir := range dirs {
 		opts = append(opts, chrome.UnpackedExtension(dir))
 	}
 	return opts, nil
 }

 // GeneratePrepareFakeAppsOptions is similar with GeneratePrepareFakeAppsWithNamesOptions,
 // with a difference that GeneratePrepareFakeAppsOptions accepts the fake app
 // count as the parameter.
 func GeneratePrepareFakeAppsOptions(baseDir string, numFakeApps int) ([]chrome.Option, error) {
 	return GeneratePrepareFakeAppsWithNamesOptions(baseDir, generateFakeAppNames(numFakeApps))
 }

 // prepareFakeApp creates data for a fake app with the specified app name and
 // icon (if any).
 func prepareFakeApp(baseDir, appName, iconDir string, iconFileMap map[int]string) (string, error) {
 	// The manifest.json data for the fake hosted app; it just opens google.com
 	// page on launch.
 	const manifestTmpl = `{
 		"description": "fake",
 		"name": "%s",
 		"manifest_version": 2,
 		"version": "0",
 		%s
 		"app": {
 			"launch": {
 				"web_url": "https://www.google.com/"
 			}
 		}
 	}`

 	extDir := filepath.Join(baseDir, appName)
 	if err := os.Mkdir(extDir, 0755); err != nil {
 		return "", errors.Wrapf(err, "failed to create the directory for %s", appName)
 	}

 	var iconJSON string
 	if iconDir != "" {
 		for _, iconFileName := range iconFileMap {
 			if err := os.Symlink(filepath.Join(iconDir, iconFileName), filepath.Join(extDir, iconFileName)); err != nil {
 				return "", errors.Wrapf(err, "failed to create link of icon %s", iconFileName)
 			}
 		}

 		iconJSONData, err := json.Marshal(iconFileMap)
 		if err != nil {
 			return "", errors.Wrap(err, "failed to turn the mapptings between icon sizes and icon names into a JSON string")
 		}
 		iconJSON = fmt.Sprintf(`"icons": %s,`, string(iconJSONData))
 	}

 	if err := ioutil.WriteFile(filepath.Join(extDir, "manifest.json"), []byte(fmt.Sprintf(manifestTmpl, appName, iconJSON)), 0644); err != nil {
 		return "", errors.Wrapf(err, "failed to prepare manifest.json for %s", appName)
 	}

 	return extDir, nil
 }

 // prepareFakeAppIcon creates icon images in different scales with the given
 // icon data. These images are stored in a directory created under baseDir.
 // iconFolder specifies the directory's name.
 func prepareFakeAppIcon(baseDir, iconFolder string, iconData []byte) (string, map[int]string, error) {
 	iconDir := filepath.Join(baseDir, iconFolder)
 	if err := os.Mkdir(iconDir, 0755); err != nil {
 		return "", nil, errors.Wrapf(err, "failed to create the icon directory %q", iconDir)
 	}

 	img, err := png.Decode(bytes.NewReader(iconData))
 	if err != nil {
 		return "", nil, errors.Wrap(err, "failed to decode icon data")
 	}

 	iconFiles := map[int]string{}
 	for _, siz := range []int{32, 48, 64, 96, 128, 192} {
 		var imgToSave image.Image
 		if siz == img.Bounds().Size().X {
 			imgToSave = img
 		} else {
 			imgToSave = scaleImage(img, siz)
 		}
 		iconFile := fmt.Sprintf("icon%d.png", siz)
 		iconFileFullPath := filepath.Join(iconDir, iconFile)
 		if err := saveImageAsPng(iconFileFullPath, imgToSave); err != nil {
 			return "", nil, errors.Wrapf(err, "failed to save the icon file to %q", iconFileFullPath)
 		}
 		iconFiles[siz] = iconFile
 	}

 	return iconDir, iconFiles, nil
 }

 // PrepareDefaultFakeApps creates directories for fake apps (hosted apps) under
 // the directory of baseDir and returns their path names. Fake app names are
 // specified by the parameter. hasIcon specifies whether a default icon should
 // be used. The intermediate data may remain even when an error is returned. It
 // is the caller's responsibility to clean up the contents under the baseDir.
 // This also may update the ownership of baseDir.
 func PrepareDefaultFakeApps(baseDir string, appNames []string, hasIcon bool) ([]string, error) {
 	if err := extension.ChownContentsToChrome(baseDir); err != nil {
 		return nil, errors.Wrapf(err, "failed to change ownership of %q", baseDir)
 	}

 	var iconDir string
 	var iconFiles map[int]string
 	var err error
 	if hasIcon {
 		iconDir, iconFiles, err = prepareFakeAppIcon(baseDir, "defaultIcons", fakeIconData)
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to parepare the shared icon for fake apps")
 		}
 	}

 	var dirs []string
 	for _, appName := range appNames {
 		dir, err := prepareFakeApp(baseDir, appName, iconDir, iconFiles)
 		if err != nil {
 			return nil, errors.Wrapf(err, "failed to prepare data for %q", appName)
 		}
 		dirs = append(dirs, dir)
 	}

 	return dirs, nil
 }

 // prepareFakeAppsWithIconData is similar with PrepareDefaultFakeApps, but with
 // the difference that app icons are specified by the parameter.
 func prepareFakeAppsWithIconData(baseDir string, appNames []string, iconData [][]byte) ([]string, error) {
 	if len(appNames) != len(iconData) {
 		return nil, errors.Errorf("unexpected count of icon data: got %d, expecting %d", len(iconData), len(appNames))
 	}

 	if err := extension.ChownContentsToChrome(baseDir); err != nil {
 		return nil, errors.Wrapf(err, "failed to change ownership of %q", baseDir)
 	}

 	var dirs []string
 	for index, appName := range appNames {
 		iconDir, iconFiles, err := prepareFakeAppIcon(baseDir, appName+"Icons", iconData[index])
 		if err != nil {
 			return nil, errors.Wrapf(err, "failed to parepare icons for the fake app %q", appName)
 		}

 		dir, err := prepareFakeApp(baseDir, appName, iconDir, iconFiles)
 		if err != nil {
 			return nil, errors.Wrapf(err, "failed to prepare data for %q", appName)
 		}
 		dirs = append(dirs, dir)
 	}

 	return dirs, nil
 }

 // The remaining definitions are needed only for faillog & CaptureCDP.
 // TODO(crbug.com/1271473): Get rid of them.
 // They expose cdputil types and values. See the cdputil package for details.

 // DebuggingPortPath is a file where Chrome writes debugging port.
 const DebuggingPortPath = cdputil.DebuggingPortPath

 // DevtoolsConn is the connection to a web content view, e.g. a tab.
 type DevtoolsConn = cdputil.Conn

 // Session maintains the connection to talk to the browser in Chrome DevTools Protocol
 // over WebSocket.
 type Session = cdputil.Session

 // PortWaitOption controls whether the NewSession should wait for the port file
 // to be created.
 type PortWaitOption = cdputil.PortWaitOption

 // PortWaitOption values.
 const (
 	NoWaitPort PortWaitOption = cdputil.NoWaitPort
 	WaitPort   PortWaitOption = cdputil.WaitPort
 )

 // NewDevtoolsSession establishes a Chrome DevTools Protocol WebSocket connection to the browser.
 func NewDevtoolsSession(ctx context.Context, debuggingPortPath string, portWait PortWaitOption) (sess *Session, retErr error) {
 	return cdputil.NewSession(ctx, debuggingPortPath, portWait)
 }
	// Copyright 2019 The Chromium OS Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	package ash

	import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"image"
	"image/png"
	"io/ioutil"
	"os"
	"path/filepath"
	"time"

	"chromiumos/tast/errors"
	"chromiumos/tast/local/chrome"
	"chromiumos/tast/local/chrome/internal/cdputil"
	"chromiumos/tast/local/chrome/internal/extension"
	)

	// AppListBubbleClassName is the automation API class name of the bubble launcher.
	const AppListBubbleClassName = "AppListBubbleView"

	// LauncherState represents the launcher (a.k.a AppList) state.
	type LauncherState string

	// LauncherState as defined in
	// https://cs.chromium.org/chromium/src/ash/public/cpp/app_list/app_list_types.h
	const (
	Peeking LauncherState = "Peeking"
	FullscreenAllApps LauncherState = "FullscreenAllApps"
	FullscreenSearch LauncherState = "FullscreenSearch"
	Half LauncherState = "Half"
	Closed LauncherState = "Closed"
	)

	// Accelerator represents the accelerator key to trigger certain actions.
	type Accelerator struct {
	KeyCode string `json:"keyCode"`
	Shift bool `json:"shift"`
	Control bool `json:"control"`
	Alt bool `json:"alt"`
	Search bool `json:"search"`
	}

	// Accelerator key used to trigger launcher state change.
	var (
	AccelSearch = Accelerator{KeyCode: "search", Shift: false, Control: false, Alt: false, Search: false}
	AccelShiftSearch = Accelerator{KeyCode: "search", Shift: true, Control: false, Alt: false, Search: false}
	)

	// WaitForLauncherState waits until the launcher state becomes state. It waits
	// up to 10 seconds and fail if the launcher doesn't have the desired state.
	// Expected to fail with "Not supported for bubble launcher" error when waiting
	// for state different from "Closed" if called for clamshell productivity (bubble)
	// launcher. Note that the autotest API is expected to return immediately, but still
	// asynchronously, in this case.
	// NOTE: Waiting for "Closed" state will always wait for the fullscreen launcher to
	// hide, even if one would otherwise expect bubble launcher to be used for the current
	// session state - this supports waiting for launcher UI hide animation to complete
	// after transitioning from tablet mode to clamshell.
	func WaitForLauncherState(ctx context.Context, tconn *chrome.TestConn, state LauncherState) error {
	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
	defer cancel()
	if err := tconn.Call(ctx, nil, "tast.promisify(chrome.autotestPrivate.waitForLauncherState)", state); err != nil {
	return errors.Wrap(err, "failed to wait for launcher state")
	}
	return nil
	}

	// TriggerLauncherStateChange will cause the launcher state change via accelerator.
	func TriggerLauncherStateChange(ctx context.Context, tconn *chrome.TestConn, accel Accelerator) error {
	// Send the press event to store it in the history. It'll not be handled, so ignore the result.
	if err := tconn.Call(ctx, nil, `async (acceleratorKey) => {
	acceleratorKey.pressed = true;
	chrome.autotestPrivate.activateAccelerator(acceleratorKey, () => {});
	acceleratorKey.pressed = false;
	await tast.promisify(chrome.autotestPrivate.activateAccelerator)(acceleratorKey);
	}`, accel); err != nil {
	return errors.Wrap(err, "failed to execute accelerator")
	}
	return nil
	}

	func scaleImage(src image.Image, siz int) image.Image {
	srcSize := src.Bounds().Size().X
	scaled := image.NewRGBA(image.Rect(0, 0, siz, siz))
	for x := 0; x < siz; x++ {
	for y := 0; y < siz; y++ {
	scaled.Set(x, y, src.At(xsrcSize/siz, ysrcSize/siz))
	}
	}
	return scaled
	}

	func saveImageAsPng(filename string, img image.Image) error {
	w, err := os.OpenFile(filename, os.O_WRONLY\|os.O_CREATE, 0644)
	if err != nil {
	return err
	}
	defer w.Close()
	return png.Encode(w, img)
	}

	// generateFakeAppNames generates default names for fake apps.
	func generateFakeAppNames(numFakeApps int) []string {
	fakeAppNames := make([]string, numFakeApps)
	for i := 0; i < numFakeApps; i++ {
	fakeAppNames[i] = fmt.Sprintf("fake app %d", i)
	}
	return fakeAppNames
	}

	// GeneratePrepareFakeAppsWithNamesOptions calls PrepareDefaultFakeApps() and
	// returns options to be used by chrome.New() for logging in with the newly
	// created fake apps. baseDir is the path to the directory for keeping app data.
	// The function caller should always clean baseDir regardless of function
	// execution results. names specify app names.
	func GeneratePrepareFakeAppsWithNamesOptions(baseDir string, names []string) ([]chrome.Option, error) {
	dirs, err := PrepareDefaultFakeApps(baseDir, names, true)
	if err != nil {
	return nil, errors.Wrap(err, "failed to create fake apps")
	}

	opts := make([]chrome.Option, 0, len(names))
	for _, dir := range dirs {
	opts = append(opts, chrome.UnpackedExtension(dir))
	}
	return opts, nil
	}

	// GeneratePrepareFakeAppsWithIconDataOptions is similar with GeneratePrepareFakeAppsWithNamesOptions,
	// with a difference that GeneratePrepareFakeAppsWithIconDataOptions allows the
	// caller to specify both app names and icon data. The caller has the duty to
	// clean baseDir.
	func GeneratePrepareFakeAppsWithIconDataOptions(baseDir string, names []string, iconData [][]byte) ([]chrome.Option, error) {
	if len(names) != len(iconData) {
	return nil, errors.Errorf("unexpected count of icon data: got %d, expecting %d", len(iconData), len(names))
	}

	dirs, err := prepareFakeAppsWithIconData(baseDir, names, iconData)
	if err != nil {
	return nil, errors.Wrap(err, "failed to prepare data for fake apps")
	}

	opts := make([]chrome.Option, 0, len(names))
	for _, dir := range dirs {
	opts = append(opts, chrome.UnpackedExtension(dir))
	}
	return opts, nil
	}

	// GeneratePrepareFakeAppsOptions is similar with GeneratePrepareFakeAppsWithNamesOptions,
	// with a difference that GeneratePrepareFakeAppsOptions accepts the fake app
	// count as the parameter.
	func GeneratePrepareFakeAppsOptions(baseDir string, numFakeApps int) ([]chrome.Option, error) {
	return GeneratePrepareFakeAppsWithNamesOptions(baseDir, generateFakeAppNames(numFakeApps))
	}

	// prepareFakeApp creates data for a fake app with the specified app name and
	// icon (if any).
	func prepareFakeApp(baseDir, appName, iconDir string, iconFileMap map[int]string) (string, error) {
	// The manifest.json data for the fake hosted app; it just opens google.com
	// page on launch.
	const manifestTmpl = `{
	"description": "fake",
	"name": "%s",
	"manifest_version": 2,
	"version": "0",
	%s
	"app": {
	"launch": {
	"web_url": "https://www.google.com/"
	}
	}
	}`

	extDir := filepath.Join(baseDir, appName)
	if err := os.Mkdir(extDir, 0755); err != nil {
	return "", errors.Wrapf(err, "failed to create the directory for %s", appName)
	}

	var iconJSON string
	if iconDir != "" {
	for _, iconFileName := range iconFileMap {
	if err := os.Symlink(filepath.Join(iconDir, iconFileName), filepath.Join(extDir, iconFileName)); err != nil {
	return "", errors.Wrapf(err, "failed to create link of icon %s", iconFileName)
	}
	}

	iconJSONData, err := json.Marshal(iconFileMap)
	if err != nil {
	return "", errors.Wrap(err, "failed to turn the mapptings between icon sizes and icon names into a JSON string")
	}
	iconJSON = fmt.Sprintf(`"icons": %s,`, string(iconJSONData))
	}

	if err := ioutil.WriteFile(filepath.Join(extDir, "manifest.json"), []byte(fmt.Sprintf(manifestTmpl, appName, iconJSON)), 0644); err != nil {
	return "", errors.Wrapf(err, "failed to prepare manifest.json for %s", appName)
	}

	return extDir, nil
	}

	// prepareFakeAppIcon creates icon images in different scales with the given
	// icon data. These images are stored in a directory created under baseDir.
	// iconFolder specifies the directory's name.
	func prepareFakeAppIcon(baseDir, iconFolder string, iconData []byte) (string, map[int]string, error) {
	iconDir := filepath.Join(baseDir, iconFolder)
	if err := os.Mkdir(iconDir, 0755); err != nil {
	return "", nil, errors.Wrapf(err, "failed to create the icon directory %q", iconDir)
	}

	img, err := png.Decode(bytes.NewReader(iconData))
	if err != nil {
	return "", nil, errors.Wrap(err, "failed to decode icon data")
	}

	iconFiles := map[int]string{}
	for _, siz := range []int{32, 48, 64, 96, 128, 192} {
	var imgToSave image.Image
	if siz == img.Bounds().Size().X {
	imgToSave = img
	} else {
	imgToSave = scaleImage(img, siz)
	}
	iconFile := fmt.Sprintf("icon%d.png", siz)
	iconFileFullPath := filepath.Join(iconDir, iconFile)
	if err := saveImageAsPng(iconFileFullPath, imgToSave); err != nil {
	return "", nil, errors.Wrapf(err, "failed to save the icon file to %q", iconFileFullPath)
	}
	iconFiles[siz] = iconFile
	}

	return iconDir, iconFiles, nil
	}

	// PrepareDefaultFakeApps creates directories for fake apps (hosted apps) under
	// the directory of baseDir and returns their path names. Fake app names are
	// specified by the parameter. hasIcon specifies whether a default icon should
	// be used. The intermediate data may remain even when an error is returned. It
	// is the caller's responsibility to clean up the contents under the baseDir.
	// This also may update the ownership of baseDir.
	func PrepareDefaultFakeApps(baseDir string, appNames []string, hasIcon bool) ([]string, error) {
	if err := extension.ChownContentsToChrome(baseDir); err != nil {
	return nil, errors.Wrapf(err, "failed to change ownership of %q", baseDir)
	}

	var iconDir string
	var iconFiles map[int]string
	var err error
	if hasIcon {
	iconDir, iconFiles, err = prepareFakeAppIcon(baseDir, "defaultIcons", fakeIconData)
	if err != nil {
	return nil, errors.Wrap(err, "failed to parepare the shared icon for fake apps")
	}
	}

	var dirs []string
	for _, appName := range appNames {
	dir, err := prepareFakeApp(baseDir, appName, iconDir, iconFiles)
	if err != nil {
	return nil, errors.Wrapf(err, "failed to prepare data for %q", appName)
	}
	dirs = append(dirs, dir)
	}

	return dirs, nil
	}

	// prepareFakeAppsWithIconData is similar with PrepareDefaultFakeApps, but with
	// the difference that app icons are specified by the parameter.
	func prepareFakeAppsWithIconData(baseDir string, appNames []string, iconData [][]byte) ([]string, error) {
	if len(appNames) != len(iconData) {
	return nil, errors.Errorf("unexpected count of icon data: got %d, expecting %d", len(iconData), len(appNames))
	}

	if err := extension.ChownContentsToChrome(baseDir); err != nil {
	return nil, errors.Wrapf(err, "failed to change ownership of %q", baseDir)
	}

	var dirs []string
	for index, appName := range appNames {
	iconDir, iconFiles, err := prepareFakeAppIcon(baseDir, appName+"Icons", iconData[index])
	if err != nil {
	return nil, errors.Wrapf(err, "failed to parepare icons for the fake app %q", appName)
	}

	dir, err := prepareFakeApp(baseDir, appName, iconDir, iconFiles)
	if err != nil {
	return nil, errors.Wrapf(err, "failed to prepare data for %q", appName)
	}
	dirs = append(dirs, dir)
	}

	return dirs, nil
	}

	// The remaining definitions are needed only for faillog & CaptureCDP.
	// TODO(crbug.com/1271473): Get rid of them.
	// They expose cdputil types and values. See the cdputil package for details.

	// DebuggingPortPath is a file where Chrome writes debugging port.
	const DebuggingPortPath = cdputil.DebuggingPortPath

	// DevtoolsConn is the connection to a web content view, e.g. a tab.
	type DevtoolsConn = cdputil.Conn

	// Session maintains the connection to talk to the browser in Chrome DevTools Protocol
	// over WebSocket.
	type Session = cdputil.Session

	// PortWaitOption controls whether the NewSession should wait for the port file
	// to be created.
	type PortWaitOption = cdputil.PortWaitOption

	// PortWaitOption values.
	const (
	NoWaitPort PortWaitOption = cdputil.NoWaitPort
	WaitPort PortWaitOption = cdputil.WaitPort
	)

	// NewDevtoolsSession establishes a Chrome DevTools Protocol WebSocket connection to the browser.
	func NewDevtoolsSession(ctx context.Context, debuggingPortPath string, portWait PortWaitOption) (sess *Session, retErr error) {
	return cdputil.NewSession(ctx, debuggingPortPath, portWait)
	}