How to determine what is causing Chrome to show the "Aw, Snap" dialogue

Does anybody know if there is a practical way to determine the cause of the "Aw Snap!" message that occasionally appears on Google Chrome? Does Chrome have an error log I can refer to? I'm suspecting this issue is caused by a recursive loop in the code which is then swallowing up all the memory? Is there any way I can confirm this?

Solution 1:

There is, see explanations here: for ordinary logging in Chrome, you could try:

Use Chrome's logging feature:

To enable logging, launch Chrome with these command line flags:

--enable-logging --v=1

The output will be saved to the file chrome_debug.log in Chrome's user data directory.

The location of the log file can be overridden by CHROME_LOG_FILE environment variable.

For full list of flags, check: Google Chrome command line switches.
Or use the javascript console:

Press Ctrl + Shift + J (Windows / Linux) or Cmd + Option+ J (Mac).

Solution 2:

The offical Chrome Developers Twitter account linked to a website which helps you to debug the "Aw snap" pages: http://www.chromium.org/for-testers/enable-logging

The recommendation is to launch Chrome with these flags:

--enable-logging --v=1

If you do that, then you can grab a crash log from the file chrome_debug.log in Chrome's user data directory (in the parent directory of Default/) or in the binary build folder (out\Debug) if you are using a debug build.

Solution 3:

The Aw, Snap! page is usually related to process segmentation fault crash which could be related to the software bug. To determine the cause, you can enable logging (as suggested in other answers) or analyse the backtrace of the core dump file (on macOS, Linux, e.g. Ubuntu).

If you don't know the cause (e.g. stack trace consist only memory addresses), you can create a new support ticket at the Chrome bug tracking system (or double-check whether there is one already). While reporting, you should upload and include Crash ID by going to chrome://crashes/ page, so memory addresses can be translated into debug symbols by the Chrome maintainers.

Alternatively you can decode crash dumps yourself.

See also: Where is Google Chrome Crash Dump Located?

To simplify above, here are the main reasons why the page can crash:

You have found the bug (either on the website or with the web browser it-self).
- Website bug
  - Example: JavaScript VM reached the maximum allocated memory (out-of-memory crash).
    
    To check that, run DevTools and check the Memory tab. If that's the case, the code should automatically pause just before the potential out-of-memory crash (e.g. Issue 810015). If so, report the problem to the website owner, or profile the JS code to find the bug.
- Browser bug
  - Consider disabling extensions or run in Incognito mode.
  - Consider removing cached files.
  - Report a bug.
  - Re-install the browser.
  - Use a different version of Chrome such as Chromium, Dev or Canary channel.
  - Use different browser such as Epic, Firefox, Opera, Brave, Waterfox, Torch or other.
  - If issue is repeatable, you can try to re-compile Chrome sources with debug symbols and analyse the stack trace or report it.
You've reached the maximum open files in your system (see: #787381).

On Linux/Unix/macOS, to verify that, run:
```
sysctl -a | grep files
```
and check whether kern.num_files reached the limit of kern.maxfiles.

If that's the case, increase the limit by running the following commands:
```
sysctl -w kern.maxfiles=20480
which launchctl && launchctl limit maxfiles 65536 unlimited
which ulimit && ulimit -c unlimited
```
You could have some malware/virus which alters your Chrome files causing the crash.
You could have some hardware memory-related issue. So run some test (such as memtest).

macOS

To display logs from Chrome, run:

log stream --level debug --predicate 'processImagePath contains "Google"'

or by running Console app, where you can also check for any crash dumps (or check in ~/Library/Logs/DiagnosticReports). See: Debug “Aw, Snap!” error in Chrome

Debugging

If none of above helps, you can consider compiling Chrome from the source (takes a long time), then run directly from the Terminal. After that, each “Aw, Snap!” error should be followed by the full stack trace including functions and line in the source code file where it happened.

Solution 4:

On an Android where I did not have the startup logging flag option I found it useful to record a Performance Profile in the DevTools.

It showed me the last javascript function call made before the Aw Snap.

It turned out document.innerHtml threw an uncaught string allocation error of some sorts on a large div...