|
<# |
|
.SYNOPSIS |
|
Complete Google Chrome uninstaller for Windows with comprehensive cleanup. |
|
|
|
.DESCRIPTION |
|
This script completely removes Google Chrome from Windows systems including: |
|
- Chrome application files |
|
- User data (bookmarks, history, passwords, extensions) |
|
- Registry keys and policies |
|
- Scheduled tasks |
|
- Google Update services |
|
- Shortcuts and temporary files |
|
|
|
The script automatically elevates to administrator privileges and uses multiple |
|
uninstall methods with automatic fallback: |
|
1. winget (Windows Package Manager) - Modern, recommended |
|
2. Native Chrome setup.exe - Direct Chrome uninstaller |
|
3. Registry UninstallString - Alternative approach |
|
4. WMI/CIM - Last resort programmatic method |
|
5. Manual cleanup - Always performed to ensure complete removal |
|
|
|
.PARAMETER WhatIf |
|
Dry-run mode. Scans and reports what would be removed without making any changes. |
|
SAFE for testing on systems where Chrome needs to remain installed. |
|
|
|
.PARAMETER Verbose |
|
Enable detailed output showing every operation and file/registry key being processed. |
|
|
|
.PARAMETER Silent |
|
Silent mode with minimal console output (errors only). Useful for automation. |
|
Logging to file still occurs unless -NoLog is specified. |
|
|
|
.PARAMETER KeepUserData |
|
Preserve user data directory (bookmarks, passwords, history, extensions). |
|
Only removes the Chrome application and system-level components. |
|
|
|
.PARAMETER LogPath |
|
Custom path for the log file. Default: $env:TEMP\ChromeUninstall_yyyyMMdd_HHmmss.log |
|
|
|
.PARAMETER NoLog |
|
Disable logging to file. All operations will still be shown on console (unless -Silent). |
|
|
|
.EXAMPLE |
|
.\Uninstall-GoogleChrome.ps1 -WhatIf |
|
Scan and report what would be removed without making any changes (SAFE for testing). |
|
|
|
.EXAMPLE |
|
.\Uninstall-GoogleChrome.ps1 -WhatIf -Verbose |
|
Detailed scan with verbose output showing all detected components. |
|
|
|
.EXAMPLE |
|
.\Uninstall-GoogleChrome.ps1 |
|
Uninstall Chrome completely with default settings. |
|
|
|
.EXAMPLE |
|
.\Uninstall-GoogleChrome.ps1 -KeepUserData |
|
Uninstall Chrome but preserve bookmarks, passwords, and other user data. |
|
|
|
.EXAMPLE |
|
.\Uninstall-GoogleChrome.ps1 -Silent -LogPath "C:\Logs\chrome_removal.log" |
|
Silent uninstall with custom log file location (for automation). |
|
|
|
.EXAMPLE |
|
irm https://gist.githubusercontent.com/emilwojcik93/[GIST_ID]/raw/Uninstall-GoogleChrome.ps1 | iex |
|
Remote execution via Invoke-RestMethod (simple, no parameters). |
|
|
|
.EXAMPLE |
|
&([ScriptBlock]::Create((irm https://gist.githubusercontent.com/emilwojcik93/[GIST_ID]/raw/Uninstall-GoogleChrome.ps1))) -WhatIf -Verbose |
|
Remote execution with parameters using ScriptBlock pattern. |
|
|
|
.NOTES |
|
File Name : Uninstall-GoogleChrome.ps1 |
|
Author : Emil Wojcik (emilwojcik93) |
|
Prerequisite : PowerShell 5.1 or higher |
|
Version : 1.0 |
|
Date : 2025-12-29 |
|
|
|
Exit Codes: |
|
0 - Success (Chrome removed or not installed) |
|
1 - Chrome found but removal failed |
|
2 - Admin elevation failed or denied |
|
3 - Chrome processes locked and couldn't be stopped |
|
|
|
.LINK |
|
https://gist.github.com/emilwojcik93 |
|
#> |
|
|
|
[CmdletBinding(SupportsShouldProcess=$true)] |
|
param( |
|
[Parameter(Mandatory=$false)] |
|
[switch]$Silent, |
|
|
|
[Parameter(Mandatory=$false)] |
|
[switch]$KeepUserData, |
|
|
|
[Parameter(Mandatory=$false)] |
|
[ValidateScript({ |
|
$parentDir = Split-Path $_ -Parent |
|
if ($parentDir -and !(Test-Path $parentDir)) { |
|
throw "Directory does not exist: $parentDir" |
|
} |
|
$true |
|
})] |
|
[string]$LogPath, |
|
|
|
[Parameter(Mandatory=$false)] |
|
[switch]$NoLog |
|
) |
|
|
|
# Script version |
|
$script:ScriptVersion = "1.0" |
|
$script:ScriptName = "Chrome Uninstaller" |
|
|
|
# Global variables |
|
$script:LogFile = $null |
|
$script:ChromeDetected = $false |
|
$script:ChromeVersion = $null |
|
$script:ChromePath = $null |
|
$script:IsWhatIfMode = $false |
|
$script:IsVerboseMode = $false |
|
$script:IsSilentMode = $Silent.IsPresent |
|
$script:ComponentsFound = @{ |
|
Processes = @() |
|
Services = @() |
|
Directories = @() |
|
RegistryKeys = @() |
|
ScheduledTasks = @() |
|
Shortcuts = @() |
|
} |
|
|
|
#region Helper Functions |
|
|
|
function Write-Log { |
|
<# |
|
.SYNOPSIS |
|
Dual-output logging function (console + file) |
|
#> |
|
[CmdletBinding()] |
|
param( |
|
[Parameter(Mandatory=$true)] |
|
[string]$Message, |
|
|
|
[Parameter(Mandatory=$false)] |
|
[ValidateSet('INFO', 'SUCCESS', 'WARNING', 'ERROR', 'VERBOSE')] |
|
[string]$Level = 'INFO', |
|
|
|
[Parameter(Mandatory=$false)] |
|
[ConsoleColor]$Color |
|
) |
|
|
|
$timestamp = Get-Date -Format 'yyyy-MM-dd HH:mm:ss' |
|
$logMessage = "[$timestamp] [$Level] $Message" |
|
|
|
# Write to log file if enabled |
|
if (-not $NoLog -and $script:LogFile) { |
|
try { |
|
Add-Content -Path $script:LogFile -Value $logMessage -ErrorAction SilentlyContinue |
|
} catch { |
|
# Silently ignore log file errors |
|
} |
|
} |
|
|
|
# Write to console unless Silent mode (except for errors) |
|
if (-not $IsSilentMode -or $Level -eq 'ERROR') { |
|
# Skip verbose messages unless in verbose mode |
|
if ($Level -eq 'VERBOSE' -and -not $IsVerboseMode) { |
|
return |
|
} |
|
|
|
# Set color based on level |
|
if (-not $Color) { |
|
$Color = switch ($Level) { |
|
'SUCCESS' { 'Green' } |
|
'WARNING' { 'Yellow' } |
|
'ERROR' { 'Red' } |
|
'VERBOSE' { 'Gray' } |
|
default { 'White' } |
|
} |
|
} |
|
|
|
Write-Host "[$Level] $Message" -ForegroundColor $Color |
|
} |
|
} |
|
|
|
function Initialize-Logging { |
|
<# |
|
.SYNOPSIS |
|
Initialize the logging system |
|
#> |
|
if ($NoLog) { |
|
Write-Log "Logging to file is disabled" -Level INFO |
|
return |
|
} |
|
|
|
if ($LogPath) { |
|
$script:LogFile = $LogPath |
|
} else { |
|
$timestamp = Get-Date -Format 'yyyyMMdd_HHmmss' |
|
$script:LogFile = Join-Path $env:TEMP "ChromeUninstall_$timestamp.log" |
|
} |
|
|
|
try { |
|
# Create log file |
|
$null = New-Item -Path $script:LogFile -ItemType File -Force -ErrorAction Stop |
|
|
|
# Write header |
|
$header = @" |
|
================================================================================ |
|
$script:ScriptName v$script:ScriptVersion |
|
Started: $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') |
|
User: $env:USERNAME |
|
Computer: $env:COMPUTERNAME |
|
OS: $(Get-WmiObject Win32_OperatingSystem | Select-Object -ExpandProperty Caption) |
|
PowerShell: $($PSVersionTable.PSVersion) |
|
Mode: $(if($IsWhatIfMode){'WhatIf (Dry-Run)'}else{'Execute'}) |
|
================================================================================ |
|
|
|
"@ |
|
Add-Content -Path $script:LogFile -Value $header |
|
|
|
if (-not $IsSilentMode) { |
|
Write-Host "Logging to: $script:LogFile" -ForegroundColor Cyan |
|
} |
|
} catch { |
|
Write-Host "[WARNING] Could not create log file: $_" -ForegroundColor Yellow |
|
$script:LogFile = $null |
|
} |
|
} |
|
|
|
function Test-AdminRights { |
|
<# |
|
.SYNOPSIS |
|
Check if running with administrator privileges |
|
#> |
|
$currentPrincipal = New-Object Security.Principal.WindowsPrincipal([Security.Principal.WindowsIdentity]::GetCurrent()) |
|
return $currentPrincipal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator) |
|
} |
|
|
|
function Invoke-Elevate { |
|
<# |
|
.SYNOPSIS |
|
Elevate the script to administrator privileges |
|
#> |
|
Write-Log "This script requires administrator privileges" -Level WARNING |
|
Write-Log "Attempting to relaunch with elevation..." -Level INFO |
|
|
|
# Build argument list from bound parameters |
|
$argList = @() |
|
$PSBoundParameters.GetEnumerator() | ForEach-Object { |
|
$argList += if ($_.Value -is [switch] -and $_.Value) { |
|
"-$($_.Key)" |
|
} elseif ($_.Value) { |
|
"-$($_.Key) `"$($_.Value)`"" |
|
} |
|
} |
|
|
|
# Detect execution context |
|
$script = if ($PSCommandPath) { |
|
# Local file execution |
|
"& { & `"$($PSCommandPath)`" $argList }" |
|
} else { |
|
# Remote execution via irm - reconstruct ScriptBlock |
|
# Note: This will work if the script was called via ScriptBlock pattern |
|
Write-Log "Remote execution detected - parameters will be preserved" -Level VERBOSE |
|
# For remote elevation, we need to embed the URL or pass it through |
|
# Since we can't determine the original URL, user needs to run with admin from the start |
|
# or we can try to re-execute with parameters |
|
Write-Log "For remote execution, please run PowerShell as Administrator first" -Level ERROR |
|
exit 2 |
|
} |
|
|
|
# Determine PowerShell command |
|
$powershellcmd = if (Get-Command pwsh -ErrorAction SilentlyContinue) { "pwsh" } else { "powershell" } |
|
|
|
# Determine terminal/console to use |
|
$processCmd = if (Get-Command wt.exe -ErrorAction SilentlyContinue) { "wt.exe" } else { $powershellcmd } |
|
|
|
try { |
|
$process = Start-Process $processCmd -ArgumentList "$powershellcmd -ExecutionPolicy Bypass -NoProfile -Command $script" -Verb RunAs -PassThru |
|
Write-Log "Script relaunched with elevation" -Level INFO |
|
exit 0 |
|
} catch { |
|
Write-Log "Failed to elevate privileges: $($_.Exception.Message)" -Level ERROR |
|
exit 2 |
|
} |
|
} |
|
|
|
function Find-ChromeInstallation { |
|
<# |
|
.SYNOPSIS |
|
Detect Chrome installation using multiple methods |
|
#> |
|
Write-Log "Detecting Chrome installation..." -Level INFO |
|
|
|
$chromeInfo = @{ |
|
Installed = $false |
|
Version = $null |
|
InstallPath = $null |
|
RegistryPath = $null |
|
UninstallString = $null |
|
} |
|
|
|
# Method 1: Check registry (most reliable) |
|
$registryPaths = @( |
|
'HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\Google Chrome', |
|
'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\Google Chrome', |
|
'HKCU:\Software\Microsoft\Windows\CurrentVersion\Uninstall\Google Chrome' |
|
) |
|
|
|
foreach ($regPath in $registryPaths) { |
|
if (Test-Path $regPath) { |
|
Write-Log "Found Chrome registry entry: $regPath" -Level VERBOSE |
|
try { |
|
$regKey = Get-ItemProperty -Path $regPath -ErrorAction Stop |
|
$chromeInfo.Installed = $true |
|
$chromeInfo.Version = $regKey.Version |
|
$chromeInfo.RegistryPath = $regPath |
|
$chromeInfo.UninstallString = $regKey.UninstallString |
|
|
|
# Try to determine install path from DisplayIcon or InstallLocation |
|
if ($regKey.DisplayIcon) { |
|
$chromeInfo.InstallPath = Split-Path (Split-Path $regKey.DisplayIcon -Parent) -Parent |
|
} elseif ($regKey.InstallLocation) { |
|
$chromeInfo.InstallPath = $regKey.InstallLocation |
|
} |
|
|
|
Write-Log "Chrome detected: Version $($chromeInfo.Version)" -Level SUCCESS |
|
break |
|
} catch { |
|
$errMsg = $_.Exception.Message |
|
Write-Log "Error reading registry: $errMsg" -Level VERBOSE |
|
} |
|
} |
|
} |
|
|
|
# Method 2: Check file system |
|
if (-not $chromeInfo.Installed) { |
|
$installPaths = @( |
|
"${env:ProgramFiles(x86)}\Google\Chrome\Application", |
|
"$env:ProgramFiles\Google\Chrome\Application", |
|
"$env:LOCALAPPDATA\Google\Chrome\Application" |
|
) |
|
|
|
foreach ($path in $installPaths) { |
|
if (Test-Path $path) { |
|
Write-Log "Found Chrome installation directory: $path" -Level VERBOSE |
|
$chromeInfo.Installed = $true |
|
$chromeInfo.InstallPath = $path |
|
|
|
# Try to get version from chrome.exe |
|
$chromeExe = Join-Path $path "chrome.exe" |
|
if (Test-Path $chromeExe) { |
|
try { |
|
$versionInfo = (Get-Item $chromeExe).VersionInfo |
|
$chromeInfo.Version = $versionInfo.FileVersion |
|
Write-Log "Chrome detected: Version $($chromeInfo.Version)" -Level SUCCESS |
|
} catch { |
|
Write-Log "Found Chrome but couldn't determine version" -Level WARNING |
|
} |
|
} |
|
break |
|
} |
|
} |
|
} |
|
|
|
if (-not $chromeInfo.Installed) { |
|
Write-Log "Chrome is not installed on this system" -Level INFO |
|
} else { |
|
Write-Log "Installation path: $($chromeInfo.InstallPath)" -Level VERBOSE |
|
} |
|
|
|
return $chromeInfo |
|
} |
|
|
|
function Get-ChromeComponents { |
|
<# |
|
.SYNOPSIS |
|
Scan all Chrome-related components on the system |
|
#> |
|
Write-Log "Scanning for Chrome components..." -Level INFO |
|
|
|
# Check for running processes |
|
$processes = Get-Process -Name chrome -ErrorAction SilentlyContinue |
|
if ($processes) { |
|
$script:ComponentsFound.Processes = $processes |
|
Write-Log "Found $($processes.Count) Chrome process(es) running" -Level VERBOSE |
|
} |
|
|
|
# Check for services |
|
$services = @('gupdate', 'gupdatem') | ForEach-Object { |
|
Get-Service -Name $_ -ErrorAction SilentlyContinue |
|
} | Where-Object { $_ } |
|
|
|
if ($services) { |
|
$script:ComponentsFound.Services = $services |
|
Write-Log "Found $($services.Count) Google Update service(s)" -Level VERBOSE |
|
} |
|
|
|
# Check for directories |
|
$directories = @( |
|
"$env:LOCALAPPDATA\Google\Chrome", |
|
"$env:LOCALAPPDATA\Google\CrashReports", |
|
"$env:LOCALAPPDATA\Google\Update", |
|
"$env:ProgramFiles\Google\Chrome", |
|
"${env:ProgramFiles(x86)}\Google\Chrome", |
|
"$env:APPDATA\Google", |
|
"$env:ProgramData\Google\Chrome", |
|
"$env:ProgramData\Google\CrashReports" |
|
) |
|
|
|
foreach ($dir in $directories) { |
|
if (Test-Path $dir) { |
|
try { |
|
$size = (Get-ChildItem $dir -Recurse -ErrorAction SilentlyContinue | |
|
Measure-Object -Property Length -Sum -ErrorAction SilentlyContinue).Sum / 1MB |
|
$script:ComponentsFound.Directories += @{ |
|
Path = $dir |
|
SizeMB = [math]::Round($size, 2) |
|
} |
|
Write-Log "Found directory: $dir ($([math]::Round($size, 2)) MB)" -Level VERBOSE |
|
} catch { |
|
$script:ComponentsFound.Directories += @{ |
|
Path = $dir |
|
SizeMB = 0 |
|
} |
|
Write-Log "Found directory: $dir (size unknown)" -Level VERBOSE |
|
} |
|
} |
|
} |
|
|
|
# Check for registry keys |
|
$registryKeys = @( |
|
'HKCU:\Software\Google\Chrome', |
|
'HKCU:\Software\Google\Update', |
|
'HKLM:\SOFTWARE\Google\Chrome', |
|
'HKLM:\SOFTWARE\Google\Update', |
|
'HKLM:\SOFTWARE\WOW6432Node\Google\Chrome', |
|
'HKLM:\SOFTWARE\WOW6432Node\Google\Update', |
|
'HKLM:\SOFTWARE\Policies\Google\Chrome', |
|
'HKCU:\Software\Policies\Google\Chrome', |
|
'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\Google Chrome', |
|
'HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\Google Chrome', |
|
'HKCU:\Software\Microsoft\Windows\CurrentVersion\Uninstall\Google Chrome' |
|
) |
|
|
|
foreach ($key in $registryKeys) { |
|
if (Test-Path $key) { |
|
$script:ComponentsFound.RegistryKeys += $key |
|
Write-Log "Found registry key: $key" -Level VERBOSE |
|
} |
|
} |
|
|
|
# Check for scheduled tasks |
|
try { |
|
$tasks = Get-ScheduledTask -ErrorAction SilentlyContinue | |
|
Where-Object { $_.TaskPath -like "*Google*" -or $_.TaskName -like "*Chrome*" -or $_.TaskName -like "*Google*" } |
|
|
|
if ($tasks) { |
|
$script:ComponentsFound.ScheduledTasks = $tasks |
|
Write-Log "Found $($tasks.Count) Google/Chrome scheduled task(s)" -Level VERBOSE |
|
} |
|
} catch { |
|
$errMsg = $_.Exception.Message |
|
Write-Log "Could not scan scheduled tasks: $errMsg" -Level VERBOSE |
|
} |
|
|
|
# Check for shortcuts |
|
$shortcutLocations = @( |
|
"$env:USERPROFILE\Desktop", |
|
"$env:APPDATA\Microsoft\Windows\Start Menu\Programs", |
|
"$env:ProgramData\Microsoft\Windows\Start Menu\Programs", |
|
"$env:PUBLIC\Desktop" |
|
) |
|
|
|
foreach ($location in $shortcutLocations) { |
|
if (Test-Path $location) { |
|
$shortcuts = Get-ChildItem -Path $location -Filter "*Chrome*.lnk" -Recurse -ErrorAction SilentlyContinue |
|
if ($shortcuts) { |
|
$script:ComponentsFound.Shortcuts += $shortcuts |
|
Write-Log "Found $($shortcuts.Count) shortcut(s) in $location" -Level VERBOSE |
|
} |
|
} |
|
} |
|
|
|
# Summary |
|
$totalComponents = $script:ComponentsFound.Processes.Count + |
|
$script:ComponentsFound.Services.Count + |
|
$script:ComponentsFound.Directories.Count + |
|
$script:ComponentsFound.RegistryKeys.Count + |
|
$script:ComponentsFound.ScheduledTasks.Count + |
|
$script:ComponentsFound.Shortcuts.Count |
|
|
|
Write-Log "Component scan complete: $totalComponents item(s) found" -Level INFO |
|
|
|
return $totalComponents -gt 0 |
|
} |
|
|
|
function Stop-ChromeProcesses { |
|
<# |
|
.SYNOPSIS |
|
Stop all running Chrome processes |
|
#> |
|
$processes = Get-Process -Name chrome -ErrorAction SilentlyContinue |
|
|
|
if (-not $processes) { |
|
Write-Log "No Chrome processes running" -Level VERBOSE |
|
return $true |
|
} |
|
|
|
if ($IsWhatIfMode) { |
|
Write-Log "Would stop $($processes.Count) Chrome process(es)" -Level INFO |
|
return $true |
|
} |
|
|
|
Write-Log "Stopping $($processes.Count) Chrome process(es)..." -Level INFO |
|
|
|
try { |
|
$processes | Stop-Process -Force -ErrorAction Stop |
|
Start-Sleep -Seconds 2 |
|
|
|
# Verify processes stopped |
|
$remainingProcesses = Get-Process -Name chrome -ErrorAction SilentlyContinue |
|
if ($remainingProcesses) { |
|
Write-Log "Warning: $($remainingProcesses.Count) Chrome process(es) could not be stopped" -Level WARNING |
|
return $false |
|
} |
|
|
|
Write-Log "All Chrome processes stopped successfully" -Level SUCCESS |
|
return $true |
|
} catch { |
|
$errMsg = $_.Exception.Message |
|
Write-Log "Error stopping Chrome processes: $errMsg" -Level ERROR |
|
return $false |
|
} |
|
} |
|
|
|
function Stop-GoogleServices { |
|
<# |
|
.SYNOPSIS |
|
Stop Google Update services |
|
#> |
|
$serviceNames = @('gupdate', 'gupdatem') |
|
$stoppedCount = 0 |
|
|
|
foreach ($serviceName in $serviceNames) { |
|
$service = Get-Service -Name $serviceName -ErrorAction SilentlyContinue |
|
|
|
if ($service) { |
|
if ($IsWhatIfMode) { |
|
Write-Log "Would stop service: $serviceName" -Level INFO |
|
$stoppedCount++ |
|
} else { |
|
try { |
|
if ($service.Status -eq 'Running') { |
|
Write-Log "Stopping service: $serviceName" -Level VERBOSE |
|
Stop-Service -Name $serviceName -Force -ErrorAction Stop |
|
$stoppedCount++ |
|
} else { |
|
Write-Log "Service $serviceName is already stopped" -Level VERBOSE |
|
} |
|
} catch { |
|
$errMsg = $_.Exception.Message |
|
Write-Log "Could not stop service ${serviceName}: $errMsg" -Level WARNING |
|
} |
|
} |
|
} |
|
} |
|
|
|
if ($stoppedCount -gt 0) { |
|
Write-Log "Stopped $stoppedCount Google Update service(s)" -Level SUCCESS |
|
} |
|
|
|
return $true |
|
} |
|
|
|
function Invoke-WingetUninstall { |
|
<# |
|
.SYNOPSIS |
|
Try to uninstall Chrome using winget |
|
#> |
|
Write-Log "Attempting uninstall via winget..." -Level INFO |
|
|
|
# Check if winget is available |
|
$winget = Get-Command winget -ErrorAction SilentlyContinue |
|
if (-not $winget) { |
|
Write-Log "winget is not available on this system" -Level VERBOSE |
|
return $false |
|
} |
|
|
|
Write-Log "winget detected: $($winget.Version)" -Level VERBOSE |
|
|
|
if ($IsWhatIfMode) { |
|
Write-Log "Would execute: winget uninstall --id Google.Chrome --silent --force" -Level INFO |
|
return $true |
|
} |
|
|
|
try { |
|
Write-Log "Executing: winget uninstall --id Google.Chrome --silent --force --accept-source-agreements" -Level VERBOSE |
|
$output = & winget uninstall --id Google.Chrome --silent --force --accept-source-agreements 2>&1 |
|
|
|
if ($LASTEXITCODE -eq 0) { |
|
Write-Log "Chrome uninstalled successfully via winget" -Level SUCCESS |
|
return $true |
|
} else { |
|
Write-Log "winget uninstall failed with exit code: $LASTEXITCODE" -Level WARNING |
|
Write-Log "Output: $output" -Level VERBOSE |
|
return $false |
|
} |
|
} catch { |
|
$errMsg = $_.Exception.Message |
|
Write-Log "Error during winget uninstall: $errMsg" -Level WARNING |
|
return $false |
|
} |
|
} |
|
|
|
function Invoke-NativeUninstall { |
|
<# |
|
.SYNOPSIS |
|
Try to uninstall Chrome using native setup.exe |
|
#> |
|
param( |
|
[Parameter(Mandatory=$true)] |
|
[hashtable]$ChromeInfo |
|
) |
|
|
|
Write-Log "Attempting uninstall via native setup.exe..." -Level INFO |
|
|
|
# Try to get version from registry |
|
try { |
|
$version = (Get-ItemProperty -Path 'HKLM:\SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\Google Chrome' -ErrorAction Stop).Version |
|
|
|
if ($version) { |
|
$uninstallerPath = "${env:ProgramFiles(x86)}\Google\Chrome\Application\$version\Installer\setup.exe" |
|
|
|
if (Test-Path $uninstallerPath) { |
|
Write-Log "Found native uninstaller: $uninstallerPath" -Level VERBOSE |
|
|
|
if ($IsWhatIfMode) { |
|
Write-Log "Would execute: $uninstallerPath --uninstall --multi-install --chrome --system-level --force-uninstall" -Level INFO |
|
return $true |
|
} |
|
|
|
try { |
|
Write-Log "Executing native uninstaller..." -Level VERBOSE |
|
$process = Start-Process -FilePath $uninstallerPath -ArgumentList "--uninstall --multi-install --chrome --system-level --force-uninstall" -Wait -PassThru -NoNewWindow |
|
|
|
if ($process.ExitCode -eq 0 -or $process.ExitCode -eq 19) { |
|
# Exit code 19 means "already uninstalled" which is OK |
|
Write-Log "Chrome uninstalled successfully via native setup.exe" -Level SUCCESS |
|
return $true |
|
} else { |
|
Write-Log "Native uninstaller failed with exit code: $($process.ExitCode)" -Level WARNING |
|
return $false |
|
} |
|
} catch { |
|
$errMsg = $_.Exception.Message |
|
Write-Log "Error executing native uninstaller: $errMsg" -Level WARNING |
|
return $false |
|
} |
|
} |
|
} |
|
} catch { |
|
$errMsg = $_.Exception.Message |
|
Write-Log "Could not locate native uninstaller: $errMsg" -Level VERBOSE |
|
} |
|
|
|
return $false |
|
} |
|
|
|
function Invoke-RegistryUninstall { |
|
<# |
|
.SYNOPSIS |
|
Try to uninstall Chrome using registry UninstallString |
|
#> |
|
param( |
|
[Parameter(Mandatory=$true)] |
|
[hashtable]$ChromeInfo |
|
) |
|
|
|
Write-Log "Attempting uninstall via registry UninstallString..." -Level INFO |
|
|
|
if ($ChromeInfo.UninstallString) { |
|
Write-Log "Found UninstallString: $($ChromeInfo.UninstallString)" -Level VERBOSE |
|
|
|
if ($IsWhatIfMode) { |
|
Write-Log "Would execute: $($ChromeInfo.UninstallString) --force-uninstall" -Level INFO |
|
return $true |
|
} |
|
|
|
try { |
|
# Parse the uninstall string |
|
$uninstallCmd = $ChromeInfo.UninstallString |
|
if ($uninstallCmd -match '"([^"]+)"') { |
|
$exePath = $matches[1] |
|
$args = "--force-uninstall" |
|
|
|
Write-Log "Executing registry uninstaller..." -Level VERBOSE |
|
$process = Start-Process -FilePath $exePath -ArgumentList $args -Wait -PassThru -NoNewWindow |
|
|
|
if ($process.ExitCode -eq 0 -or $process.ExitCode -eq 19) { |
|
Write-Log "Chrome uninstalled successfully via registry method" -Level SUCCESS |
|
return $true |
|
} else { |
|
Write-Log "Registry uninstaller failed with exit code: $($process.ExitCode)" -Level WARNING |
|
return $false |
|
} |
|
} |
|
} catch { |
|
$errMsg = $_.Exception.Message |
|
Write-Log "Error executing registry uninstaller: $errMsg" -Level WARNING |
|
return $false |
|
} |
|
} |
|
|
|
Write-Log "No registry UninstallString found" -Level VERBOSE |
|
return $false |
|
} |
|
|
|
function Invoke-WMIUninstall { |
|
<# |
|
.SYNOPSIS |
|
Try to uninstall Chrome using WMI/CIM |
|
#> |
|
Write-Log "Attempting uninstall via WMI/CIM..." -Level INFO |
|
|
|
try { |
|
$chrome = Get-CimInstance -ClassName Win32_Product -ErrorAction Stop | |
|
Where-Object { $_.Name -eq 'Google Chrome' } |
|
|
|
if ($chrome) { |
|
Write-Log "Found Chrome via WMI" -Level VERBOSE |
|
|
|
if ($IsWhatIfMode) { |
|
Write-Log "Would invoke WMI Uninstall method" -Level INFO |
|
return $true |
|
} |
|
|
|
Write-Log "Invoking WMI Uninstall method (this may take a while)..." -Level VERBOSE |
|
$result = Invoke-CimMethod -InputObject $chrome -MethodName Uninstall |
|
|
|
if ($result.ReturnValue -eq 0) { |
|
Write-Log "Chrome uninstalled successfully via WMI" -Level SUCCESS |
|
return $true |
|
} else { |
|
Write-Log "WMI uninstall failed with return value: $($result.ReturnValue)" -Level WARNING |
|
return $false |
|
} |
|
} else { |
|
Write-Log "Chrome not found in WMI" -Level VERBOSE |
|
return $false |
|
} |
|
} catch { |
|
$errMsg = $_.Exception.Message |
|
Write-Log "Error during WMI uninstall: $errMsg" -Level WARNING |
|
return $false |
|
} |
|
} |
|
|
|
function Invoke-ChromeUninstall { |
|
<# |
|
.SYNOPSIS |
|
Main uninstall function with fallback chain |
|
#> |
|
param( |
|
[Parameter(Mandatory=$true)] |
|
[hashtable]$ChromeInfo |
|
) |
|
|
|
Write-Log "Starting Chrome uninstall process..." -Level INFO |
|
Write-Log "Uninstall method priority: winget -> native setup.exe -> registry -> WMI -> manual" -Level INFO |
|
|
|
# Stop processes and services first |
|
if (-not (Stop-ChromeProcesses)) { |
|
if (-not $IsWhatIfMode) { |
|
Write-Log "Warning: Some Chrome processes could not be stopped" -Level WARNING |
|
Write-Log "Uninstall may fail or require a system restart" -Level WARNING |
|
} |
|
} |
|
|
|
Stop-GoogleServices |
|
|
|
# Try each uninstall method in order |
|
$uninstallMethods = @( |
|
@{ Name = "winget"; Function = { Invoke-WingetUninstall } }, |
|
@{ Name = "Native setup.exe"; Function = { Invoke-NativeUninstall -ChromeInfo $ChromeInfo } }, |
|
@{ Name = "Registry UninstallString"; Function = { Invoke-RegistryUninstall -ChromeInfo $ChromeInfo } }, |
|
@{ Name = "WMI/CIM"; Function = { Invoke-WMIUninstall } } |
|
) |
|
|
|
$uninstallSuccessful = $false |
|
|
|
foreach ($method in $uninstallMethods) { |
|
Write-Log "Trying method: $($method.Name)" -Level VERBOSE |
|
|
|
if (& $method.Function) { |
|
Write-Log "Uninstall successful using: $($method.Name)" -Level SUCCESS |
|
$uninstallSuccessful = $true |
|
break |
|
} else { |
|
Write-Log "Method failed: $($method.Name), trying next method..." -Level VERBOSE |
|
} |
|
} |
|
|
|
if (-not $uninstallSuccessful -and -not $IsWhatIfMode) { |
|
Write-Log "All uninstall methods failed, proceeding with manual cleanup only" -Level WARNING |
|
} |
|
|
|
return $uninstallSuccessful |
|
} |
|
|
|
function Remove-ChromeDirectories { |
|
<# |
|
.SYNOPSIS |
|
Remove all Chrome-related directories |
|
#> |
|
Write-Log "Removing Chrome directories..." -Level INFO |
|
|
|
$directories = @( |
|
"$env:LOCALAPPDATA\Google\CrashReports", |
|
"$env:LOCALAPPDATA\Google\Update", |
|
"$env:ProgramFiles\Google\Chrome", |
|
"${env:ProgramFiles(x86)}\Google\Chrome", |
|
"$env:APPDATA\Google", |
|
"$env:ProgramData\Google\Chrome", |
|
"$env:ProgramData\Google\CrashReports", |
|
"${env:ProgramFiles(x86)}\Google\Update", |
|
"$env:ProgramFiles\Google\Update" |
|
) |
|
|
|
# Add user data directory unless KeepUserData is specified |
|
if (-not $KeepUserData) { |
|
$directories = @("$env:LOCALAPPDATA\Google\Chrome") + $directories |
|
} else { |
|
Write-Log "Preserving user data directory (KeepUserData flag set)" -Level INFO |
|
} |
|
|
|
$removedCount = 0 |
|
|
|
foreach ($dir in $directories) { |
|
if (Test-Path $dir) { |
|
if ($IsWhatIfMode) { |
|
try { |
|
$size = (Get-ChildItem $dir -Recurse -ErrorAction SilentlyContinue | |
|
Measure-Object -Property Length -Sum -ErrorAction SilentlyContinue).Sum / 1MB |
|
Write-Log "Would remove: $dir ($([math]::Round($size, 2)) MB)" -Level INFO |
|
} catch { |
|
Write-Log "Would remove: $dir" -Level INFO |
|
} |
|
$removedCount++ |
|
} else { |
|
try { |
|
Write-Log "Removing: $dir" -Level VERBOSE |
|
Remove-Item -Path $dir -Recurse -Force -ErrorAction Stop |
|
Write-Log "Removed: $dir" -Level SUCCESS |
|
$removedCount++ |
|
} catch { |
|
$errMsg = $_.Exception.Message |
|
Write-Log "Could not remove $dir : $errMsg" -Level WARNING |
|
} |
|
} |
|
} else { |
|
Write-Log "Directory not found: $dir" -Level VERBOSE |
|
} |
|
} |
|
|
|
Write-Log "Removed $removedCount director(ies)" -Level SUCCESS |
|
} |
|
|
|
function Remove-ChromeRegistry { |
|
<# |
|
.SYNOPSIS |
|
Remove all Chrome-related registry keys |
|
#> |
|
Write-Log "Removing Chrome registry keys..." -Level INFO |
|
|
|
$registryKeys = @( |
|
'HKCU:\Software\Google\Chrome', |
|
'HKCU:\Software\Google\Update', |
|
'HKLM:\SOFTWARE\Google\Chrome', |
|
'HKLM:\SOFTWARE\Google\Update', |
|
'HKLM:\SOFTWARE\WOW6432Node\Google\Chrome', |
|
'HKLM:\SOFTWARE\WOW6432Node\Google\Update', |
|
'HKLM:\SOFTWARE\Policies\Google\Chrome', |
|
'HKCU:\Software\Policies\Google\Chrome', |
|
'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\Google Chrome', |
|
'HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\Google Chrome', |
|
'HKCU:\Software\Microsoft\Windows\CurrentVersion\Uninstall\Google Chrome' |
|
) |
|
|
|
$removedCount = 0 |
|
|
|
foreach ($key in $registryKeys) { |
|
if (Test-Path $key) { |
|
if ($IsWhatIfMode) { |
|
Write-Log "Would remove registry key: $key" -Level INFO |
|
$removedCount++ |
|
} else { |
|
try { |
|
Write-Log "Removing registry key: $key" -Level VERBOSE |
|
Remove-Item -Path $key -Recurse -Force -ErrorAction Stop |
|
Write-Log "Removed: $key" -Level SUCCESS |
|
$removedCount++ |
|
} catch { |
|
$errMsg = $_.Exception.Message |
|
Write-Log "Could not remove $key : $errMsg" -Level WARNING |
|
} |
|
} |
|
} else { |
|
Write-Log "Registry key not found: $key" -Level VERBOSE |
|
} |
|
} |
|
|
|
Write-Log "Removed $removedCount registry key(s)" -Level SUCCESS |
|
} |
|
|
|
function Remove-ChromeScheduledTasks { |
|
<# |
|
.SYNOPSIS |
|
Remove Chrome/Google scheduled tasks |
|
#> |
|
Write-Log "Removing scheduled tasks..." -Level INFO |
|
|
|
try { |
|
$tasks = Get-ScheduledTask -ErrorAction SilentlyContinue | |
|
Where-Object { $_.TaskPath -like "*Google*" -or $_.TaskName -like "*Chrome*" -or $_.TaskName -like "*Google*" } |
|
|
|
if (-not $tasks) { |
|
Write-Log "No Chrome/Google scheduled tasks found" -Level VERBOSE |
|
return |
|
} |
|
|
|
$removedCount = 0 |
|
|
|
foreach ($task in $tasks) { |
|
if ($IsWhatIfMode) { |
|
Write-Log "Would remove scheduled task: $($task.TaskName)" -Level INFO |
|
$removedCount++ |
|
} else { |
|
try { |
|
Write-Log "Removing scheduled task: $($task.TaskName)" -Level VERBOSE |
|
Unregister-ScheduledTask -TaskName $task.TaskName -TaskPath $task.TaskPath -Confirm:$false -ErrorAction Stop |
|
Write-Log "Removed: $($task.TaskName)" -Level SUCCESS |
|
$removedCount++ |
|
} catch { |
|
$errMsg = $_.Exception.Message |
|
Write-Log "Could not remove task $($task.TaskName): $errMsg" -Level WARNING |
|
} |
|
} |
|
} |
|
|
|
Write-Log "Removed $removedCount scheduled task(s)" -Level SUCCESS |
|
} catch { |
|
$errMsg = $_.Exception.Message |
|
Write-Log "Error scanning scheduled tasks: $errMsg" -Level WARNING |
|
} |
|
} |
|
|
|
function Remove-ChromeShortcuts { |
|
<# |
|
.SYNOPSIS |
|
Remove Chrome desktop and start menu shortcuts |
|
#> |
|
Write-Log "Removing shortcuts..." -Level INFO |
|
|
|
$shortcutLocations = @( |
|
"$env:USERPROFILE\Desktop", |
|
"$env:APPDATA\Microsoft\Windows\Start Menu\Programs", |
|
"$env:ProgramData\Microsoft\Windows\Start Menu\Programs", |
|
"$env:PUBLIC\Desktop" |
|
) |
|
|
|
$removedCount = 0 |
|
|
|
foreach ($location in $shortcutLocations) { |
|
if (Test-Path $location) { |
|
$shortcuts = Get-ChildItem -Path $location -Filter "*Chrome*.lnk" -Recurse -ErrorAction SilentlyContinue |
|
|
|
foreach ($shortcut in $shortcuts) { |
|
if ($IsWhatIfMode) { |
|
Write-Log "Would remove shortcut: $($shortcut.FullName)" -Level INFO |
|
$removedCount++ |
|
} else { |
|
try { |
|
Write-Log "Removing shortcut: $($shortcut.FullName)" -Level VERBOSE |
|
Remove-Item -Path $shortcut.FullName -Force -ErrorAction Stop |
|
Write-Log "Removed: $($shortcut.Name)" -Level SUCCESS |
|
$removedCount++ |
|
} catch { |
|
$errMsg = $_.Exception.Message |
|
Write-Log "Could not remove $($shortcut.Name): $errMsg" -Level WARNING |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
Write-Log "Removed $removedCount shortcut(s)" -Level SUCCESS |
|
} |
|
|
|
function Remove-ChromeTempFiles { |
|
<# |
|
.SYNOPSIS |
|
Remove Chrome temporary files |
|
#> |
|
Write-Log "Cleaning temporary files..." -Level INFO |
|
|
|
$tempPatterns = @( |
|
"$env:TEMP\chrome*", |
|
"$env:TEMP\scoped*" |
|
) |
|
|
|
$removedCount = 0 |
|
|
|
foreach ($pattern in $tempPatterns) { |
|
$items = Get-ChildItem -Path (Split-Path $pattern -Parent) -Filter (Split-Path $pattern -Leaf) -ErrorAction SilentlyContinue |
|
|
|
foreach ($item in $items) { |
|
if ($IsWhatIfMode) { |
|
Write-Log "Would remove: $($item.FullName)" -Level VERBOSE |
|
$removedCount++ |
|
} else { |
|
try { |
|
Remove-Item -Path $item.FullName -Recurse -Force -ErrorAction Stop |
|
Write-Log "Removed: $($item.Name)" -Level VERBOSE |
|
$removedCount++ |
|
} catch { |
|
$errMsg = $_.Exception.Message |
|
Write-Log "Could not remove $($item.Name): $errMsg" -Level VERBOSE |
|
} |
|
} |
|
} |
|
} |
|
|
|
if ($removedCount -gt 0) { |
|
Write-Log "Cleaned $removedCount temporary file(s)" -Level SUCCESS |
|
} else { |
|
Write-Log "No temporary files to clean" -Level VERBOSE |
|
} |
|
} |
|
|
|
function Remove-GoogleUpdateServices { |
|
<# |
|
.SYNOPSIS |
|
Remove Google Update services |
|
#> |
|
Write-Log "Removing Google Update services..." -Level INFO |
|
|
|
$serviceNames = @('gupdate', 'gupdatem') |
|
$removedCount = 0 |
|
|
|
foreach ($serviceName in $serviceNames) { |
|
$service = Get-Service -Name $serviceName -ErrorAction SilentlyContinue |
|
|
|
if ($service) { |
|
if ($IsWhatIfMode) { |
|
Write-Log "Would remove service: $serviceName" -Level INFO |
|
$removedCount++ |
|
} else { |
|
try { |
|
# Stop service first if running |
|
if ($service.Status -eq 'Running') { |
|
Stop-Service -Name $serviceName -Force -ErrorAction SilentlyContinue |
|
} |
|
|
|
Write-Log "Removing service: $serviceName" -Level VERBOSE |
|
$output = sc.exe delete $serviceName 2>&1 |
|
|
|
if ($LASTEXITCODE -eq 0) { |
|
Write-Log "Removed service: $serviceName" -Level SUCCESS |
|
$removedCount++ |
|
} else { |
|
Write-Log "Could not remove service $serviceName : $output" -Level WARNING |
|
} |
|
} catch { |
|
$errMsg = $_.Exception.Message |
|
Write-Log "Error removing service $serviceName : $errMsg" -Level WARNING |
|
} |
|
} |
|
} else { |
|
Write-Log "Service not found: $serviceName" -Level VERBOSE |
|
} |
|
} |
|
|
|
if ($removedCount -gt 0) { |
|
Write-Log "Removed $removedCount service(s)" -Level SUCCESS |
|
} |
|
} |
|
|
|
function Invoke-ComprehensiveCleanup { |
|
<# |
|
.SYNOPSIS |
|
Perform comprehensive cleanup of all Chrome components |
|
#> |
|
Write-Log "Starting comprehensive cleanup..." -Level INFO |
|
|
|
Remove-ChromeDirectories |
|
Remove-ChromeRegistry |
|
Remove-ChromeScheduledTasks |
|
Remove-ChromeShortcuts |
|
Remove-ChromeTempFiles |
|
Remove-GoogleUpdateServices |
|
|
|
Write-Log "Comprehensive cleanup complete" -Level SUCCESS |
|
} |
|
|
|
function Test-ChromeRemoval { |
|
<# |
|
.SYNOPSIS |
|
Verify that Chrome has been completely removed |
|
#> |
|
Write-Log "Verifying Chrome removal..." -Level INFO |
|
|
|
$issuesFound = @() |
|
|
|
# Check for running processes |
|
$processes = Get-Process -Name chrome -ErrorAction SilentlyContinue |
|
if ($processes) { |
|
$issuesFound += "Chrome processes still running: $($processes.Count)" |
|
Write-Log "WARNING: $($processes.Count) Chrome process(es) still running" -Level WARNING |
|
} else { |
|
Write-Log "✓ No Chrome processes running" -Level SUCCESS |
|
} |
|
|
|
# Check key directories |
|
$keyDirs = @( |
|
"$env:LOCALAPPDATA\Google\Chrome", |
|
"$env:ProgramFiles\Google\Chrome", |
|
"${env:ProgramFiles(x86)}\Google\Chrome" |
|
) |
|
|
|
$remainingDirs = @() |
|
foreach ($dir in $keyDirs) { |
|
if (Test-Path $dir) { |
|
$remainingDirs += $dir |
|
$issuesFound += "Directory still exists: $dir" |
|
} |
|
} |
|
|
|
if ($remainingDirs.Count -eq 0) { |
|
Write-Log "✓ All Chrome directories removed" -Level SUCCESS |
|
} else { |
|
Write-Log "WARNING: $($remainingDirs.Count) director(ies) still exist" -Level WARNING |
|
foreach ($dir in $remainingDirs) { |
|
Write-Log " - $dir" -Level WARNING |
|
} |
|
} |
|
|
|
# Check key registry entries |
|
$keyRegKeys = @( |
|
'HKCU:\Software\Google\Chrome', |
|
'HKLM:\SOFTWARE\Google\Chrome', |
|
'HKLM:\SOFTWARE\WOW6432Node\Google\Chrome' |
|
) |
|
|
|
$remainingKeys = @() |
|
foreach ($key in $keyRegKeys) { |
|
if (Test-Path $key) { |
|
$remainingKeys += $key |
|
$issuesFound += "Registry key still exists: $key" |
|
} |
|
} |
|
|
|
if ($remainingKeys.Count -eq 0) { |
|
Write-Log "✓ All Chrome registry keys removed" -Level SUCCESS |
|
} else { |
|
Write-Log "WARNING: $($remainingKeys.Count) registry key(s) still exist" -Level WARNING |
|
foreach ($key in $remainingKeys) { |
|
Write-Log " - $key" -Level WARNING |
|
} |
|
} |
|
|
|
# Check for services |
|
$services = @('gupdate', 'gupdatem') | ForEach-Object { |
|
Get-Service -Name $_ -ErrorAction SilentlyContinue |
|
} | Where-Object { $_ } |
|
|
|
if ($services) { |
|
Write-Log "WARNING: $($services.Count) Google Update service(s) still exist" -Level WARNING |
|
$issuesFound += "Services still exist: $($services.Count)" |
|
} else { |
|
Write-Log "✓ No Google Update services found" -Level SUCCESS |
|
} |
|
|
|
return $issuesFound |
|
} |
|
|
|
function Show-WhatIfReport { |
|
<# |
|
.SYNOPSIS |
|
Display comprehensive WhatIf report |
|
#> |
|
Write-Host "" |
|
Write-Host "═══════════════════════════════════════════════════════════════" -ForegroundColor Cyan |
|
Write-Host " WhatIf Mode - Summary Report" -ForegroundColor White |
|
Write-Host "═══════════════════════════════════════════════════════════════" -ForegroundColor Cyan |
|
Write-Host "" |
|
|
|
Write-Host "Chrome Installation:" -ForegroundColor Yellow |
|
Write-Host " Version: $script:ChromeVersion" -ForegroundColor White |
|
Write-Host " Path: $script:ChromePath" -ForegroundColor White |
|
Write-Host "" |
|
|
|
if ($script:ComponentsFound.Processes.Count -gt 0) { |
|
Write-Host "Running Processes: $($script:ComponentsFound.Processes.Count)" -ForegroundColor Yellow |
|
} |
|
|
|
if ($script:ComponentsFound.Services.Count -gt 0) { |
|
Write-Host "Services: $($script:ComponentsFound.Services.Count)" -ForegroundColor Yellow |
|
foreach ($svc in $script:ComponentsFound.Services) { |
|
Write-Host " - $($svc.Name) ($($svc.Status))" -ForegroundColor Gray |
|
} |
|
} |
|
|
|
if ($script:ComponentsFound.Directories.Count -gt 0) { |
|
Write-Host "" |
|
Write-Host "Directories to Remove: $($script:ComponentsFound.Directories.Count)" -ForegroundColor Yellow |
|
$totalSize = 0 |
|
foreach ($dir in $script:ComponentsFound.Directories) { |
|
$totalSize += $dir.SizeMB |
|
Write-Host " - $($dir.Path) ($($dir.SizeMB) MB)" -ForegroundColor Gray |
|
} |
|
Write-Host " Total size: $([math]::Round($totalSize, 2)) MB" -ForegroundColor White |
|
} |
|
|
|
if ($script:ComponentsFound.RegistryKeys.Count -gt 0) { |
|
Write-Host "" |
|
Write-Host "Registry Keys to Remove: $($script:ComponentsFound.RegistryKeys.Count)" -ForegroundColor Yellow |
|
if ($IsVerboseMode) { |
|
foreach ($key in $script:ComponentsFound.RegistryKeys) { |
|
Write-Host " - $key" -ForegroundColor Gray |
|
} |
|
} |
|
} |
|
|
|
if ($script:ComponentsFound.ScheduledTasks.Count -gt 0) { |
|
Write-Host "" |
|
Write-Host "Scheduled Tasks to Remove: $($script:ComponentsFound.ScheduledTasks.Count)" -ForegroundColor Yellow |
|
foreach ($task in $script:ComponentsFound.ScheduledTasks) { |
|
Write-Host " - $($task.TaskName)" -ForegroundColor Gray |
|
} |
|
} |
|
|
|
if ($script:ComponentsFound.Shortcuts.Count -gt 0) { |
|
Write-Host "" |
|
Write-Host "Shortcuts to Remove: $($script:ComponentsFound.Shortcuts.Count)" -ForegroundColor Yellow |
|
if ($IsVerboseMode) { |
|
foreach ($shortcut in $script:ComponentsFound.Shortcuts) { |
|
Write-Host " - $($shortcut.Name)" -ForegroundColor Gray |
|
} |
|
} |
|
} |
|
|
|
Write-Host "" |
|
Write-Host "═══════════════════════════════════════════════════════════════" -ForegroundColor Cyan |
|
Write-Host " No changes were made (WhatIf mode)" -ForegroundColor Green |
|
Write-Host "═══════════════════════════════════════════════════════════════" -ForegroundColor Cyan |
|
Write-Host "" |
|
} |
|
|
|
function Show-FinalReport { |
|
<# |
|
.SYNOPSIS |
|
Display final execution report |
|
#> |
|
param( |
|
[Parameter(Mandatory=$false)] |
|
[array]$VerificationIssues = @() |
|
) |
|
|
|
Write-Host "" |
|
Write-Host "═══════════════════════════════════════════════════════════════" -ForegroundColor Cyan |
|
Write-Host " Chrome Uninstall Complete" -ForegroundColor White |
|
Write-Host "═══════════════════════════════════════════════════════════════" -ForegroundColor Cyan |
|
Write-Host "" |
|
|
|
if ($VerificationIssues.Count -eq 0) { |
|
Write-Host " ✓ Chrome has been completely removed" -ForegroundColor Green |
|
Write-Host " ✓ All components cleaned successfully" -ForegroundColor Green |
|
} else { |
|
Write-Host " ⚠ Chrome has been removed with warnings:" -ForegroundColor Yellow |
|
foreach ($issue in $VerificationIssues) { |
|
Write-Host " - $issue" -ForegroundColor Yellow |
|
} |
|
Write-Host "" |
|
Write-Host " Note: Some items may require a system restart to complete removal" -ForegroundColor Yellow |
|
} |
|
|
|
Write-Host "" |
|
Write-Host "═══════════════════════════════════════════════════════════════" -ForegroundColor Cyan |
|
Write-Host "" |
|
} |
|
|
|
#endregion |
|
|
|
#region Main Script |
|
|
|
# Initialize logging |
|
Initialize-Logging |
|
|
|
# Set WhatIf and Verbose modes from bound parameters |
|
$script:IsWhatIfMode = $PSBoundParameters.ContainsKey('WhatIf') -and $PSBoundParameters['WhatIf'] |
|
$script:IsVerboseMode = $PSBoundParameters.ContainsKey('Verbose') -and $PSBoundParameters['Verbose'] |
|
|
|
# Display banner |
|
if (-not $IsSilentMode) { |
|
Write-Host "" |
|
Write-Host "═══════════════════════════════════════════════════════════════" -ForegroundColor Cyan |
|
Write-Host " $script:ScriptName v$script:ScriptVersion" -ForegroundColor White |
|
if ($IsWhatIfMode) { |
|
Write-Host " WhatIf Mode: No changes will be made" -ForegroundColor Yellow |
|
} |
|
Write-Host "═══════════════════════════════════════════════════════════════" -ForegroundColor Cyan |
|
Write-Host "" |
|
} |
|
|
|
Write-Log "$script:ScriptName v$script:ScriptVersion started" -Level INFO |
|
|
|
if ($IsWhatIfMode) { |
|
Write-Log "Running in WhatIf mode - no changes will be made" -Level WARNING |
|
} |
|
|
|
# Check for admin rights (skip for WhatIf mode) |
|
if (-not $IsWhatIfMode) { |
|
if (-not (Test-AdminRights)) { |
|
Invoke-Elevate |
|
} else { |
|
Write-Log "Running with administrator privileges" -Level SUCCESS |
|
} |
|
} else { |
|
if (Test-AdminRights) { |
|
Write-Log "Running with administrator privileges" -Level VERBOSE |
|
} else { |
|
Write-Log "Running without administrator privileges (WhatIf mode)" -Level VERBOSE |
|
} |
|
} |
|
|
|
# Detect Chrome installation |
|
$chromeInfo = Find-ChromeInstallation |
|
$script:ChromeDetected = $chromeInfo.Installed |
|
$script:ChromeVersion = $chromeInfo.Version |
|
$script:ChromePath = $chromeInfo.InstallPath |
|
|
|
if (-not $script:ChromeDetected) { |
|
Write-Log "Google Chrome is not installed on this system" -Level INFO |
|
Write-Log "Nothing to uninstall" -Level SUCCESS |
|
Write-Log "Script completed successfully" -Level SUCCESS |
|
exit 0 |
|
} |
|
|
|
# Scan for all Chrome components |
|
Write-Log "Chrome installation detected" -Level SUCCESS |
|
$componentsExist = Get-ChromeComponents |
|
|
|
if (-not $componentsExist) { |
|
Write-Log "No Chrome components found to remove" -Level WARNING |
|
exit 0 |
|
} |
|
|
|
Write-Log "Detection complete" -Level SUCCESS |
|
|
|
# If WhatIf mode, show report and exit |
|
if ($IsWhatIfMode) { |
|
Show-WhatIfReport |
|
Write-Log "WhatIf scan complete - no changes were made" -Level SUCCESS |
|
|
|
if ($script:LogFile) { |
|
Write-Log "Log saved to: $script:LogFile" -Level INFO |
|
} |
|
|
|
exit 0 |
|
} |
|
|
|
# Execute uninstall |
|
Write-Host "" |
|
Write-Host "═══════════════════════════════════════════════════════════════" -ForegroundColor Cyan |
|
Write-Host " Starting Chrome Uninstall" -ForegroundColor White |
|
Write-Host "═══════════════════════════════════════════════════════════════" -ForegroundColor Cyan |
|
Write-Host "" |
|
|
|
# Uninstall Chrome |
|
$uninstallResult = Invoke-ChromeUninstall -ChromeInfo $chromeInfo |
|
|
|
# Perform comprehensive cleanup |
|
Invoke-ComprehensiveCleanup |
|
|
|
# Verify removal |
|
$verificationIssues = Test-ChromeRemoval |
|
|
|
# Show final report |
|
Show-FinalReport -VerificationIssues $verificationIssues |
|
|
|
# Log completion |
|
if ($script:LogFile) { |
|
Write-Log "Uninstall process complete" -Level SUCCESS |
|
Write-Log "Log saved to: $script:LogFile" -Level INFO |
|
|
|
$endTime = Get-Date |
|
Write-Log "Script ended at: $endTime" -Level INFO |
|
} |
|
|
|
# Determine exit code |
|
if ($verificationIssues.Count -eq 0) { |
|
Write-Log "Exiting with code 0 (Success)" -Level SUCCESS |
|
exit 0 |
|
} else { |
|
Write-Log "Exiting with code 1 (Completed with warnings)" -Level WARNING |
|
exit 1 |
|
} |
|
|
|
#endregion |
|
|
|
|
