sessionStore.js

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

'use strict'

// Session store in Brave works as follows:
// - Electron sends a ‘before-quit’ event
// - Brave sends REQUEST_WINDOW_STATE to each renderer process
// - Each renderer responds with its window state with a RESPONSE_WINDOW_STATE IPC message
// - When all state is collected save it to a JSON file and close the app
// - NODE_ENV of ‘test’ bypassing session state or else they all fail.

const fs = require('fs-extra')
const path = require('path')
const electron = require('electron')
const os = require('os')
const app = electron.app

// Constants
const UpdateStatus = require('../js/constants/updateStatus')
const settings = require('../js/constants/settings')
const siteTags = require('../js/constants/siteTags')
const downloadStates = require('../js/constants/downloadStates')

// State
const tabState = require('./common/state/tabState')
const windowState = require('./common/state/windowState')

// Utils
const locale = require('./locale')
const {pinnedTopSites} = require('../js/data/newTabData')
const {defaultSiteSettingsList} = require('../js/data/siteSettingsList')
const filtering = require('./filtering')
const autofill = require('./autofill')
const {navigatableTypes} = require('../js/lib/appUrlUtil')
const Channel = require('./channel')
const {makeImmutable} = require('./common/state/immutableUtil')
const {getSetting} = require('../js/settings')
const platformUtil = require('./common/lib/platformUtil')
const historyUtil = require('./common/lib/historyUtil')

const sessionStorageVersion = 1
const sessionStorageName = `session-store-${sessionStorageVersion}`

const getTempStoragePath = (filename) => {
  const epochTimestamp = (new Date()).getTime().toString()
  filename = filename || 'tmp'
  return process.env.NODE_ENV !== 'test'
    ? path.join(app.getPath('userData'), 'session-store-' + filename + '-' + epochTimestamp)
    : path.join(process.env.HOME, '.brave-test-session-store-' + filename + '-' + epochTimestamp)
}

const getStoragePath = () => {
  return path.join(app.getPath('userData'), sessionStorageName)
}
/**
 * Saves the specified immutable browser state to storage.
 *
 * @param {object} payload - Application state as per
 *   https://github.com/brave/browser/wiki/Application-State
 *   (not immutable data)
 * @return a promise which resolves when the state is saved
 */
module.exports.saveAppState = (payload, isShutdown) => {
  return new Promise((resolve, reject) => {
    // Don't persist private frames
    let startupModeSettingValue = getSetting(settings.STARTUP_MODE)
    const savePerWindowState = startupModeSettingValue == null ||
      startupModeSettingValue === 'lastTime'
    if (payload.perWindowState && savePerWindowState) {
      payload.perWindowState.forEach((wndPayload) => {
        wndPayload.frames = wndPayload.frames.filter((frame) => !frame.isPrivate)
      })
    } else {
      delete payload.perWindowState
    }

    try {
      payload = module.exports.cleanAppData(payload, isShutdown)
      payload.cleanedOnShutdown = isShutdown
    } catch (e) {
      payload.cleanedOnShutdown = false
    }
    payload.lastAppVersion = app.getVersion()

    if (isShutdown) {
      module.exports.cleanSessionDataOnShutdown()
    }

    muon.file.writeImportant(getStoragePath(), JSON.stringify(payload), (success) => {
      if (success) {
        resolve()
      } else {
        reject(new Error('Could not save app state to ' + getStoragePath()))
      }
    })
  })
}

/**
 * Cleans session data from unwanted values.
 */
module.exports.cleanPerWindowData = (perWindowData, isShutdown) => {
  if (!perWindowData) {
    perWindowData = {}
  }
  // delete the frame index because tabId is per-session
  delete perWindowData.framesInternal
  // Hide the context menu when we restore.
  delete perWindowData.contextMenuDetail
  // Don't save preview frame since they are only related to hovering on a tab
  delete perWindowData.previewFrameKey
  // Don't save widevine panel detail
  delete perWindowData.widevinePanelDetail
  // Don't save preview tab pages
  if (perWindowData.ui && perWindowData.ui.tabs) {
    delete perWindowData.ui.tabs.previewTabPageIndex
  }
  // Don't restore add/edit dialog
  delete perWindowData.bookmarkDetail
  // Don't restore bravery panel
  delete perWindowData.braveryPanelDetail
  // Don't restore drag data and clearBrowsingDataPanel's visibility
  if (perWindowData.ui) {
    // This is no longer stored, we can remove this line eventually
    delete perWindowData.ui.isFocused
    delete perWindowData.ui.mouseInTitlebar
    delete perWindowData.ui.mouseInFrame
    delete perWindowData.ui.dragging
    delete perWindowData.ui.isClearBrowsingDataPanelVisible
  }
  perWindowData.frames = perWindowData.frames || []
  let newKey = 0
  const cleanFrame = (frame) => {
    newKey++
    // Reset the ids back to sequential numbers
    if (frame.key === perWindowData.activeFrameKey) {
      perWindowData.activeFrameKey = newKey
    } else {
      // For now just set everything to unloaded unless it's the active frame
      frame.unloaded = true
    }
    frame.key = newKey

    // Set the frame src to the last visited location
    // or else users will see the first visited URL.
    // Pinned location always get reset to what they are
    frame.src = frame.pinnedLocation || frame.location

    // If a blob is present for the thumbnail, create the object URL
    if (frame.thumbnailBlob) {
      try {
        frame.thumbnailUrl = window.URL.createObjectURL(frame.thumbnailBlob)
      } catch (e) {
        delete frame.thumbnailUrl
      }
    }

    // Delete lists of blocked sites
    delete frame.trackingProtection
    delete frame.httpsEverywhere
    delete frame.adblock
    delete frame.noScript

    // clean up any legacy frame opening props
    delete frame.openInForeground
    delete frame.disposition

    // Guest instance ID's are not valid after restarting.
    // Electron won't know about them.
    delete frame.guestInstanceId

    // Tab ids are per-session and should not be persisted
    delete frame.tabId

    // Do not show the audio indicator until audio starts playing
    delete frame.audioMuted
    delete frame.audioPlaybackActive
    // Let's not assume wknow anything about loading
    delete frame.loading
    // Always re-determine the security data
    delete frame.security
    // Value is only used for local storage
    delete frame.isActive
    // Hide modal prompts.
    delete frame.modalPromptDetail
    // Remove HTTP basic authentication requests.
    delete frame.basicAuthDetail
    // Remove open search details
    delete frame.searchDetail
    // Remove find in page details
    if (frame.findDetail) {
      delete frame.findDetail.numberOfMatches
      delete frame.findDetail.activeMatchOrdinal
      delete frame.findDetail.internalFindStatePresent
    }
    delete frame.findbarShown
    // Don't restore full screen state
    delete frame.isFullScreen
    delete frame.showFullScreenWarning
    // Don't store child tab open ordering since keys
    // currently get re-generated when session store is
    // restored.  We will be able to keep this once we
    // don't regenerate new frame keys when opening storage.
    delete frame.parentFrameKey
    // Delete the active shortcut details
    delete frame.activeShortcut
    delete frame.activeShortcutDetails

    if (frame.navbar && frame.navbar.urlbar) {
      if (frame.navbar.urlbar.suggestions) {
        frame.navbar.urlbar.suggestions.selectedIndex = null
        frame.navbar.urlbar.suggestions.suggestionList = null
      }
      delete frame.navbar.urlbar.searchDetail
    }
  }
  const clearHistory = isShutdown && getSetting(settings.SHUTDOWN_CLEAR_HISTORY) === true
  if (clearHistory) {
    perWindowData.closedFrames = []
  }

  // Clean closed frame data before frames because the keys are re-ordered
  // and the new next key is calculated in windowStore.js based on
  // the max frame key ID.
  if (perWindowData.closedFrames) {
    perWindowData.closedFrames.forEach(cleanFrame)
  }
  if (perWindowData.frames) {
    // Don't restore pinned locations because they will be auto created by the app state change event
    perWindowData.frames = perWindowData.frames
      .filter((frame) => !frame.pinnedLocation)
    perWindowData.frames.forEach(cleanFrame)
  }
}

/**
 * Cleans app data before it's written to disk.
 * @param {Object} data - top-level app data
 * @param {Object} isShutdown - true if the data is being cleared for a shutdown
 * WARNING: getPrefs is only available in this function when isShutdown is true
 */
module.exports.cleanAppData = (data, isShutdown) => {
  // make a copy
  // TODO(bridiver) use immutable
  data = makeImmutable(data).toJS()

  // Don't show notifications from the last session
  data.notifications = []
  // Delete temp site settings
  data.temporarySiteSettings = {}

  if (data.settings && data.settings[settings.CHECK_DEFAULT_ON_STARTUP] === true) {
    // Delete defaultBrowserCheckComplete state since this is checked on startup
    delete data.defaultBrowserCheckComplete
  }
  // Delete Recovery status on shut down
  try {
    delete data.ui.about.preferences.recoverySucceeded
  } catch (e) {}

  if (data.perWindowState) {
    data.perWindowState.forEach((perWindowState) =>
      module.exports.cleanPerWindowData(perWindowState, isShutdown))
  }
  const clearAutocompleteData = isShutdown && getSetting(settings.SHUTDOWN_CLEAR_AUTOCOMPLETE_DATA) === true
  if (clearAutocompleteData) {
    try {
      autofill.clearAutocompleteData()
    } catch (e) {
      console.log('cleanAppData: error calling autofill.clearAutocompleteData: ', e)
    }
  }
  const clearAutofillData = isShutdown && getSetting(settings.SHUTDOWN_CLEAR_AUTOFILL_DATA) === true
  if (clearAutofillData) {
    autofill.clearAutofillData()
    const date = new Date().getTime()
    data.autofill = {
      addresses: {
        guid: [],
        timestamp: date
      },
      creditCards: {
        guid: [],
        timestamp: date
      }
    }
  }
  if (data.dragData) {
    delete data.dragData
  }
  if (data.sync) {
    // clear sync site cache
    data.sync.objectsById = {}
  }
  const clearSiteSettings = isShutdown && getSetting(settings.SHUTDOWN_CLEAR_SITE_SETTINGS) === true
  if (clearSiteSettings) {
    data.siteSettings = {}
  }
  // Delete expired Flash and NoScript allow-once approvals
  let now = Date.now()
  for (var host in data.siteSettings) {
    let expireTime = data.siteSettings[host].flash
    if (typeof expireTime === 'number' && expireTime < now) {
      delete data.siteSettings[host].flash
    }
    let noScript = data.siteSettings[host].noScript
    if (typeof noScript === 'number') {
      delete data.siteSettings[host].noScript
    }
    // Don't persist any noScript exceptions
    delete data.siteSettings[host].noScriptExceptions
    // Don't write runInsecureContent to session
    delete data.siteSettings[host].runInsecureContent
    // If the site setting is empty, delete it for privacy
    if (Object.keys(data.siteSettings[host]).length === 0) {
      delete data.siteSettings[host]
    }
  }
  if (data.sites) {
    const clearHistory = isShutdown && getSetting(settings.SHUTDOWN_CLEAR_HISTORY) === true
    if (clearHistory) {
      data.historySites = {}
      if (data.about) {
        delete data.about.history
        delete data.about.newtab
      }
    }
  }
  if (data.downloads) {
    const clearDownloads = isShutdown && getSetting(settings.SHUTDOWN_CLEAR_DOWNLOADS) === true
    if (clearDownloads) {
      delete data.downloads
    } else {
      // Always at least delete downloaded items older than a week
      const dateOffset = 7 * 24 * 60 * 60 * 1000
      const lastWeek = new Date().getTime() - dateOffset
      Object.keys(data.downloads).forEach((downloadId) => {
        if (data.downloads[downloadId].startTime < lastWeek) {
          delete data.downloads[downloadId]
        } else {
          const state = data.downloads[downloadId].state
          if (state === downloadStates.IN_PROGRESS || state === downloadStates.PAUSED) {
            data.downloads[downloadId].state = downloadStates.INTERRUPTED
          }
        }
      })
    }
  }

  if (data.menu) {
    delete data.menu
  }

  try {
    data = tabState.getPersistentState(data).toJS()
  } catch (e) {
    delete data.tabs
    console.log('cleanAppData: error calling tabState.getPersistentState: ', e)
  }

  try {
    data = windowState.getPersistentState(data).toJS()
  } catch (e) {
    delete data.windows
    console.log('cleanAppData: error calling windowState.getPersistentState: ', e)
  }

  if (data.extensions) {
    Object.keys(data.extensions).forEach((extensionId) => {
      delete data.extensions[extensionId].tabs
    })
  }
  return data
}

/**
 * Cleans session data on shutdown if the prefs are on.
 * @return a promise which resolve when the work is done.
 */
module.exports.cleanSessionDataOnShutdown = () => {
  if (getSetting(settings.SHUTDOWN_CLEAR_ALL_SITE_COOKIES) === true) {
    filtering.clearStorageData()
  }
  if (getSetting(settings.SHUTDOWN_CLEAR_CACHE) === true) {
    filtering.clearCache()
  }
  if (getSetting(settings.SHUTDOWN_CLEAR_HISTORY) === true) {
    filtering.clearHistory()
  }
}

const safeGetVersion = (fieldName, getFieldVersion) => {
  const versionField = {
    name: fieldName,
    version: undefined
  }
  try {
    if (typeof getFieldVersion === 'function') {
      versionField.version = getFieldVersion()
      return versionField
    }
    console.log('ERROR getting value for field ' + fieldName + ' in sessionStore::setVersionInformation(): ', getFieldVersion, ' is not a function')
  } catch (e) {
    console.log('ERROR getting value for field ' + fieldName + ' in sessionStore::setVersionInformation(): ', e)
  }
  return versionField
}

/**
 * version information (shown on about:brave)
 */
const setVersionInformation = (data) => {
  const versionFields = [
    ['Brave', app.getVersion],
    ['rev', Channel.browserLaptopRev],
    ['Muon', () => { return process.versions['atom-shell'] }],
    ['libchromiumcontent', () => { return process.versions['chrome'] }],
    ['V8', () => { return process.versions.v8 }],
    ['Node.js', () => { return process.versions.node }],
    ['Update Channel', Channel.channel],
    ['OS Platform', () => platformUtil.formatOsPlatform(os.platform())],
    ['OS Release', os.release],
    ['OS Architecture', os.arch]
  ]
  const versionInformation = {}

  versionFields.forEach((field) => {
    const versionField = safeGetVersion(field[0], field[1])
    versionInformation[versionField.name] = versionField.version
  })

  data.about = data.about || {}
  data.about.brave = {
    versionInformation: versionInformation
  }
  return data
}

const sortBookmarkOrder = (bookmarkOrder) => {
  const newOrder = {}
  for (let key of Object.keys(bookmarkOrder)) {
    let i = 0
    const order = bookmarkOrder[key].sort((x, y) => {
      if (x.order < y.order) {
        return -1
      } else if (x.order > y.order) {
        return 1
      } else {
        return 0
      }
    }).map(item => {
      item.order = i
      i++
      return item
    })

    newOrder[key] = order
  }

  return newOrder
}

module.exports.runPreMigrations = (data) => {
  // autofill data migration
  if (data.autofill) {
    if (Array.isArray(data.autofill.addresses)) {
      let addresses = exports.defaultAppState().autofill.addresses
      data.autofill.addresses.forEach((guid) => {
        addresses.guid.push(guid)
        addresses.timestamp = new Date().getTime()
      })
      data.autofill.addresses = addresses
    }
    if (Array.isArray(data.autofill.creditCards)) {
      let creditCards = exports.defaultAppState().autofill.creditCards
      data.autofill.creditCards.forEach((guid) => {
        creditCards.guid.push(guid)
        creditCards.timestamp = new Date().getTime()
      })
      data.autofill.creditCards = creditCards
    }
    if (data.autofill.addresses.guid) {
      let guids = []
      data.autofill.addresses.guid.forEach((guid) => {
        if (typeof guid === 'object') {
          guids.push(guid['persist:default'])
        } else {
          guids.push(guid)
        }
      })
      data.autofill.addresses.guid = guids
    }
    if (data.autofill.creditCards.guid) {
      let guids = []
      data.autofill.creditCards.guid.forEach((guid) => {
        if (typeof guid === 'object') {
          guids.push(guid['persist:default'])
        } else {
          guids.push(guid)
        }
      })
      data.autofill.creditCards.guid = guids
    }
  }
  // xml migration
  if (data.settings) {
    if (data.settings[settings.DEFAULT_SEARCH_ENGINE] === 'content/search/google.xml') {
      data.settings[settings.DEFAULT_SEARCH_ENGINE] = 'Google'
    }
    if (data.settings[settings.DEFAULT_SEARCH_ENGINE] === 'content/search/duckduckgo.xml') {
      data.settings[settings.DEFAULT_SEARCH_ENGINE] = 'DuckDuckGo'
    }
  }

  if (data.sites) {
    // pinned sites
    if (!data.pinnedSites) {
      data.pinnedSites = {}
      for (let key of Object.keys(data.sites)) {
        const site = data.sites[key]
        if (site.tags && site.tags.includes('pinned')) {
          delete site.tags
          data.pinnedSites[key] = site
        }
      }
    }

    // default sites
    let newTab = data.about.newtab

    if (newTab) {
      const ignoredSites = []
      const pinnedSites = []

      if (newTab.ignoredTopSites) {
        for (let site of newTab.ignoredTopSites) {
          if (site) {
            ignoredSites.push(`${site.location}|0|0`)
          }
        }
        data.about.newtab.ignoredTopSites = ignoredSites
      }

      if (newTab.pinnedTopSites) {
        for (let site of newTab.pinnedTopSites) {
          if (site) {
            site.key = `${site.location}|0|0`
            pinnedSites.push(site)
          }
        }
        data.about.newtab.pinnedTopSites = pinnedSites
      }

      data.about.newtab.sites = []
    }

    // bookmark order
    let bookmarkOrder = {}

    // bookmark folders
    if (!data.bookmarkFolders) {
      data.bookmarkFolders = {}

      for (let key of Object.keys(data.sites)) {
        const oldFolder = data.sites[key]
        if (oldFolder.tags && oldFolder.tags.includes(siteTags.BOOKMARK_FOLDER)) {
          let folder = {}
          key = key.toString()

          if (oldFolder.customTitle) {
            folder.title = oldFolder.customTitle
          } else {
            folder.title = oldFolder.title
          }

          if (oldFolder.parentFolderId == null) {
            folder.parentFolderId = 0
          } else {
            folder.parentFolderId = oldFolder.parentFolderId
          }

          folder.folderId = oldFolder.folderId
          folder.partitionNumber = oldFolder.partitionNumber
          folder.objectId = oldFolder.objectId
          folder.type = siteTags.BOOKMARK_FOLDER
          folder.key = key
          data.bookmarkFolders[key] = folder

          // bookmark order
          const id = folder.parentFolderId.toString()
          if (!bookmarkOrder[id]) {
            bookmarkOrder[id] = []
          }

          bookmarkOrder[id].push({
            key: key,
            order: oldFolder.order,
            type: siteTags.BOOKMARK_FOLDER
          })
        }
      }
    }

    // bookmarks
    if (!data.bookmarks) {
      data.bookmarks = {}

      for (let key of Object.keys(data.sites)) {
        const oldBookmark = data.sites[key]
        if (oldBookmark.tags && oldBookmark.tags.includes(siteTags.BOOKMARK)) {
          let bookmark = {}

          if (oldBookmark.customTitle && oldBookmark.customTitle.length > 0) {
            bookmark.title = oldBookmark.customTitle
          } else {
            bookmark.title = oldBookmark.title
          }

          if (oldBookmark.parentFolderId == null) {
            bookmark.parentFolderId = 0
          } else {
            bookmark.parentFolderId = oldBookmark.parentFolderId
          }

          bookmark.location = oldBookmark.location
          bookmark.partitionNumber = oldBookmark.partitionNumber
          bookmark.objectId = oldBookmark.objectId
          bookmark.favicon = oldBookmark.favicon
          bookmark.themeColor = oldBookmark.themeColor
          bookmark.type = siteTags.BOOKMARK
          bookmark.key = key
          data.bookmarks[key] = bookmark

          // bookmark order
          const id = bookmark.parentFolderId.toString()
          if (!bookmarkOrder[id]) {
            bookmarkOrder[id] = []
          }

          bookmarkOrder[id].push({
            key: key,
            order: oldBookmark.order,
            type: siteTags.BOOKMARK
          })
        }
      }
    }

    // Add cache to the state
    if (!data.cache) {
      data.cache = {}
      data.cache.bookmarkLocation = data.locationSiteKeysCache
      data.cache.bookmarkOrder = sortBookmarkOrder(bookmarkOrder)
    }

    // history
    if (!data.historySites) {
      data.historySites = {}

      for (let key of Object.keys(data.sites)) {
        const site = data.sites[key]
        const newKey = historyUtil.getKey(makeImmutable(site))
        if (site.lastAccessedTime || !site.tags || site.tags.length === 0) {
          data.historySites[newKey] = site
        }
      }
    }

    delete data.sites
  }

  return data
}

module.exports.runPostMigrations = (data) => {
  return data
}

module.exports.runImportDefaultSettings = (data) => {
  // import default site settings list
  if (!data.defaultSiteSettingsListImported) {
    for (var i = 0; i < defaultSiteSettingsList.length; ++i) {
      let setting = defaultSiteSettingsList[i]
      if (!data.siteSettings[setting.pattern]) {
        data.siteSettings[setting.pattern] = {}
      }
      let targetSetting = data.siteSettings[setting.pattern]
      if (!targetSetting.hasOwnProperty[setting.name]) {
        targetSetting[setting.name] = setting.value
      }
    }
    data.defaultSiteSettingsListImported = true
  }

  return data
}

/**
 * Loads the browser state from storage.
 *
 * @return a promise which resolves with the immutable browser state or
 * rejects if the state cannot be loaded.
 */
module.exports.loadAppState = () => {
  return new Promise((resolve, reject) => {
    let data
    try {
      data = fs.readFileSync(getStoragePath())
    } catch (e) {}

    let loaded = false
    try {
      data = JSON.parse(data)
      loaded = true
    } catch (e) {
      // Session state might be corrupted; let's backup this
      // corrupted value for people to report into support.
      module.exports.backupSession()
      if (data) {
        console.log('could not parse data: ', data, e)
      }
      data = exports.defaultAppState()
      data = module.exports.runImportDefaultSettings(data)
    }

    if (loaded) {
      data = module.exports.runPreMigrations(data)

      // Clean app data here if it wasn't cleared on shutdown
      if (data.cleanedOnShutdown !== true || data.lastAppVersion !== app.getVersion()) {
        data = module.exports.cleanAppData(data, false)
      }
      data = Object.assign(module.exports.defaultAppState(), data)
      data.cleanedOnShutdown = false

      // Always recalculate the update status
      if (data.updates) {
        const updateStatus = data.updates.status
        delete data.updates.status
        // The process always restarts after an update so if the state
        // indicates that a restart isn't wanted, close right away.
        if (updateStatus === UpdateStatus.UPDATE_APPLYING_NO_RESTART) {
          module.exports.saveAppState(data, true).then(() => {
            // Exit immediately without doing the session store saving stuff
            // since we want the same state saved except for the update status
            app.exit(0)
          })
          return
        }
      }

      data = module.exports.runPostMigrations(data)
      data = module.exports.runImportDefaultSettings(data)
    }

    data = setVersionInformation(data)

    locale.init(data.settings[settings.LANGUAGE]).then((locale) => {
      app.setLocale(locale)
      resolve(data)
    })
  })
}

/**
 * Called when session is suspected for corruption; this will move it out of the way
 */
module.exports.backupSession = () => {
  const src = getStoragePath()
  const dest = getTempStoragePath('backup')

  if (fs.existsSync(src)) {
    try {
      fs.copySync(src, dest)
      console.log('An error occurred. For support purposes, file "' + src + '" has been copied to "' + dest + '".')
    } catch (e) {
      console.log('backupSession: error making copy of session file: ', e)
    }
  }
}

/**
 * Obtains the default application level state
 */
module.exports.defaultAppState = () => {
  return {
    firstRunTimestamp: new Date().getTime(),
    sync: {
      devices: {},
      lastFetchTimestamp: 0,
      objectsById: {},
      pendingRecords: {},
      lastConfirmedRecordTimestamp: 0
    },
    cache: {
      bookmarkLocation: undefined,
      bookmarkOrder: {}
    },
    pinnedSites: {},
    bookmarks: {},
    bookmarkFolders: {},
    historySites: {},
    tabs: [],
    windows: [],
    extensions: {},
    visits: [],
    settings: {},
    siteSettings: {},
    passwords: [],
    notifications: [],
    temporarySiteSettings: {},
    autofill: {
      addresses: {
        guid: [],
        timestamp: 0
      },
      creditCards: {
        guid: [],
        timestamp: 0
      }
    },
    menubar: {},
    about: {
      newtab: {
        gridLayoutSize: 'small',
        sites: [],
        ignoredTopSites: [],
        pinnedTopSites: pinnedTopSites
      },
      welcome: {
        showOnLoad: !['test', 'development'].includes(process.env.NODE_ENV)
      }
    },
    trackingProtection: {
      count: 0
    },
    adblock: {
      count: 0
    },
    httpsEverywhere: {
      count: 0
    },
    defaultWindowParams: {},
    searchDetail: null
  }
}

/**
 * Determines if a protocol is handled.
 * app.on('ready') must have been fired before this is called.
 */
module.exports.isProtocolHandled = (protocol) => {
  protocol = (protocol || '').split(':')[0]
  return navigatableTypes.includes(`${protocol}:`) ||
      electron.session.defaultSession.protocol.isNavigatorProtocolHandled(protocol)
}