Core - CefSettings no longer implements IDisposable

**This is a breaking change**

- CefSharp.Core.CefSettingsBase is now disposed when calling Cef.Initialize
- CefSharpApp was refactored to no longer need a reference to CefSettingsBase so it can be disposed

Resolves #3220

Author: amaitland

CefSharp.Core.Runtime/Cef.h

@@ -246,7 +246,11 @@ namespace CefSharp
                 //To allow FolderSchemeHandlerFactory to access GetMimeType we pass in a Func
                 CefSharp::SchemeHandler::FolderSchemeHandlerFactory::GetMimeTypeDelegate = gcnew Func<String^, String^>(&GetMimeType);
 
-                CefRefPtr<CefSharpApp> app(new CefSharpApp(cefSettings, cefApp));
+                CefRefPtr<CefSharpApp> app(new CefSharpApp(cefSettings->ExternalMessagePump,
+                                                           cefSettings->CommandLineArgsDisabled,
+                                                           cefSettings->CefCommandLineArgs,
+                                                           cefSettings->CefCustomSchemes,
+                                                           cefApp));
                 CefMainArgs main_args;
 
                 auto success = CefInitialize(main_args, *(cefSettings->_cefSettings), app.get(), NULL);

CefSharp.Core.Runtime/Internals/CefSharpApp.h

@@ -22,24 +22,66 @@ namespace CefSharp
         private class CefSharpApp : public CefApp,
             public CefBrowserProcessHandler
         {
-            gcroot<CefSettingsBase^> _cefSettings;
+            gcroot<IEnumerable<CefCustomScheme^>^> _customSchemes;
+            gcroot<CommandLineArgDictionary^> _commandLineArgs;
             gcroot<IApp^> _app;
+            bool _commandLineDisabled;
+            bool _hasCustomScheme;
+            gcroot<String^> _customSchemeArg;
 
         public:
-            CefSharpApp(CefSettingsBase^ cefSettings, IApp^ app) :
-                _cefSettings(cefSettings),
-                _app(app)
+            CefSharpApp(bool externalMessagePump, bool commandLineDisabled, CommandLineArgDictionary^ commandLineArgs, IEnumerable<CefCustomScheme^>^ customSchemes, IApp^ app) :
+                _commandLineDisabled(commandLineDisabled),
+                _commandLineArgs(commandLineArgs),
+                _customSchemes(customSchemes),
+                _app(app),
+                _hasCustomScheme(false)
             {
                 auto isMissingHandler = Object::ReferenceEquals(app, nullptr) || Object::ReferenceEquals(app->BrowserProcessHandler, nullptr);
-                if (cefSettings->ExternalMessagePump && isMissingHandler)
+                if (externalMessagePump && isMissingHandler)
                 {
                     throw gcnew Exception("browserProcessHandler cannot be null when using cefSettings.ExternalMessagePump");
                 }
+
+                if (System::Linq::Enumerable::Count(customSchemes) > 0)
+                {
+                    String^ argument = "=";
+                    auto registeredSchemes = gcnew List<String^>();
+
+                    for each (CefCustomScheme ^ scheme in customSchemes)
+                    {
+                        //We don't need to register http or https in the render process
+                        if (scheme->SchemeName == "http" ||
+                            scheme->SchemeName == "https")
+                        {
+                            continue;
+                        }
+
+                        //We've already registered this scheme name
+                        if (registeredSchemes->Contains(scheme->SchemeName))
+                        {
+                            continue;
+                        }
+
+                        _hasCustomScheme = true;
+
+                        registeredSchemes->Add(scheme->SchemeName);
+
+                        argument += scheme->SchemeName + "|";
+                        argument += ((int)scheme->Options).ToString() + ";";
+                    }
+
+                    if (_hasCustomScheme)
+                    {
+                        _customSchemeArg = argument->TrimEnd(';');
+                    }
+                }
             }
 
             ~CefSharpApp()
             {
-                _cefSettings = nullptr;
+                _customSchemes = nullptr;
+                _commandLineArgs = nullptr;
                 delete _app;
                 _app = nullptr;
             }
@@ -56,8 +98,10 @@ namespace CefSharp
                     _app->BrowserProcessHandler->OnContextInitialized();
                 }
 
+                auto customSchemes = (IEnumerable<CefCustomScheme^>^)_customSchemes;
+
                 //CefRegisterSchemeHandlerFactory requires access to the Global CefRequestContext
-                for each (CefCustomScheme^ cefCustomScheme in _cefSettings->CefCustomSchemes)
+                for each (CefCustomScheme^ cefCustomScheme in customSchemes)
                 {
                     if (!Object::ReferenceEquals(cefCustomScheme->SchemeHandlerFactory, nullptr))
                     {
@@ -93,41 +137,9 @@ namespace CefSharp
                 //We need to know the process Id to establish WCF communication and for monitoring of parent process exit
                 commandLine->AppendArgument(StringUtils::ToNative(CefSharpArguments::HostProcessIdArgument + "=" + Process::GetCurrentProcess()->Id));
 
-                if (_cefSettings->_cefCustomSchemes->Count > 0)
+                if (_hasCustomScheme)
                 {
-                    String^ argument = "=";
-                    bool hasCustomScheme = false;
-                    auto registeredSchemes = gcnew List<String^>();
-
-                    for each(CefCustomScheme^ scheme in _cefSettings->CefCustomSchemes)
-                    {
-                        //We don't need to register http or https in the render process
-                        if (scheme->SchemeName == "http" ||
-                            scheme->SchemeName == "https")
-                        {
-                            continue;
-                        }
-
-                        //We've already registered this scheme name
-                        if (registeredSchemes->Contains(scheme->SchemeName))
-                        {
-                            continue;
-                        }
-
-                        hasCustomScheme = true;
-
-                        registeredSchemes->Add(scheme->SchemeName);
-
-                        argument += scheme->SchemeName + "|";
-                        argument += ((int)scheme->Options).ToString() + ";";
-                    }
-
-                    if (hasCustomScheme)
-                    {
-                        argument = argument->TrimEnd(';');
-
-                        commandLine->AppendArgument(StringUtils::ToNative(CefSharpArguments::CustomSchemeArgument + argument));
-                    }
+                    commandLine->AppendArgument(StringUtils::ToNative(CefSharpArguments::CustomSchemeArgument + _customSchemeArg));
                 }
 
                 if (CefSharpSettings::FocusedNodeChangedEnabled)
@@ -138,7 +150,7 @@ namespace CefSharp
 
             virtual void OnBeforeCommandLineProcessing(const CefString& process_type, CefRefPtr<CefCommandLine> command_line) OVERRIDE
             {
-                if (CefSharpSettings::Proxy != nullptr && !_cefSettings->CommandLineArgsDisabled)
+                if (CefSharpSettings::Proxy != nullptr && !_commandLineDisabled)
                 {
                     command_line->AppendSwitchWithValue("proxy-server", StringUtils::ToNative(CefSharpSettings::Proxy->IP + ":" + CefSharpSettings::Proxy->Port));
 
@@ -148,15 +160,17 @@ namespace CefSharp
                     }
                 }
 
-                if (_cefSettings->CefCommandLineArgs->Count > 0)
+                if (_commandLineArgs->Count > 0)
                 {
                     auto commandLine = command_line.get();
 
                     // Not clear what should happen if we 
                     // * already have some command line flags given (is this possible? Perhaps from globalCommandLine)
                     // * have no flags given (-> call SetProgramm() with first argument?)
 
-                    for each(KeyValuePair<String^, String^>^ kvp in _cefSettings->CefCommandLineArgs)
+                    auto args = (CommandLineArgDictionary^)_commandLineArgs;
+
+                    for each(KeyValuePair<String^, String^>^ kvp in args)
                     {
                         CefString name = StringUtils::ToNative(kvp->Key);
                         CefString value = StringUtils::ToNative(kvp->Value);

CefSharp.Core/PublicApi.cs

@@ -220,11 +220,14 @@ public static string CefCommitHash
         /// application thread (typically the UI thread). If you call them on different
         /// threads, your application will hang. See the documentation for Cef.Shutdown() for more details.
         /// </summary>
-        /// <param name="cefSettings">CefSharp configuration settings.</param>
+        /// <param name="settings">CefSharp configuration settings.</param>
         /// <returns>true if successful; otherwise, false.</returns>
-        public static bool Initialize(CefSettingsBase cefSettings)
+        public static bool Initialize(CefSettingsBase settings)
         {
-            return Core.Cef.Initialize((CefSharp.Core.CefSettingsBase)cefSettings);
+            using (settings.settings)
+            {
+                return Core.Cef.Initialize(settings.settings);
+            }
         }
 
         /// <summary>
@@ -233,12 +236,15 @@ public static bool Initialize(CefSettingsBase cefSettings)
         /// application thread (typically the UI thread). If you call them on different
         /// threads, your application will hang. See the documentation for Cef.Shutdown() for more details.
         /// </summary>
-        /// <param name="cefSettings">CefSharp configuration settings.</param>
+        /// <param name="settings">CefSharp configuration settings.</param>
         /// <param name="performDependencyCheck">Check that all relevant dependencies available, throws exception if any are missing</param>
         /// <returns>true if successful; otherwise, false.</returns>
-        public static bool Initialize(CefSettingsBase cefSettings, bool performDependencyCheck)
+        public static bool Initialize(CefSettingsBase settings, bool performDependencyCheck)
         {
-            return Core.Cef.Initialize((CefSharp.Core.CefSettingsBase)cefSettings, performDependencyCheck);
+            using (settings.settings)
+            {
+                return Core.Cef.Initialize(settings.settings, performDependencyCheck);
+            }
         }
 
         /// <summary>
@@ -247,13 +253,16 @@ public static bool Initialize(CefSettingsBase cefSettings, bool performDependenc
         /// application thread (typically the UI thread). If you call them on different
         /// threads, your application will hang. See the documentation for Cef.Shutdown() for more details.
         /// </summary>
-        /// <param name="cefSettings">CefSharp configuration settings.</param>
+        /// <param name="settings">CefSharp configuration settings.</param>
         /// <param name="performDependencyCheck">Check that all relevant dependencies available, throws exception if any are missing</param>
         /// <param name="browserProcessHandler">The handler for functionality specific to the browser process. Null if you don't wish to handle these events</param>
         /// <returns>true if successful; otherwise, false.</returns>
-        public static bool Initialize(CefSettingsBase cefSettings, bool performDependencyCheck, IBrowserProcessHandler browserProcessHandler)
+        public static bool Initialize(CefSettingsBase settings, bool performDependencyCheck, IBrowserProcessHandler browserProcessHandler)
         {
-            return Core.Cef.Initialize((CefSharp.Core.CefSettingsBase)cefSettings, performDependencyCheck, browserProcessHandler);
+            using (settings.settings)
+            {
+                return Core.Cef.Initialize(settings.settings, performDependencyCheck, browserProcessHandler);
+            }
         }
 
         /// <summary>
@@ -262,13 +271,16 @@ public static bool Initialize(CefSettingsBase cefSettings, bool performDependenc
         /// application thread (typically the UI thread). If you call them on different
         /// threads, your application will hang. See the documentation for Cef.Shutdown() for more details.
         /// </summary>
-        /// <param name="cefSettings">CefSharp configuration settings.</param>
+        /// <param name="settings">CefSharp configuration settings.</param>
         /// <param name="performDependencyCheck">Check that all relevant dependencies available, throws exception if any are missing</param>
         /// <param name="cefApp">Implement this interface to provide handler implementations. Null if you don't wish to handle these events</param>
         /// <returns>true if successful; otherwise, false.</returns>
-        public static bool Initialize(CefSettingsBase cefSettings, bool performDependencyCheck, IApp cefApp)
+        public static bool Initialize(CefSettingsBase settings, bool performDependencyCheck, IApp cefApp)
         {
-            return Core.Cef.Initialize((CefSharp.Core.CefSettingsBase)cefSettings, performDependencyCheck, cefApp);
+            using (settings.settings)
+            {
+                return Core.Cef.Initialize(settings.settings, performDependencyCheck, cefApp);
+            }
         }
 
         /// <summary>
@@ -746,7 +758,11 @@ public static void WaitForBrowsersToClose()
         }
     }
 
-    /// <inheritdoc/>
+    /// <summary>
+    /// Initialization settings. Many of these and other settings can also configured using command-line switches.
+    /// WPF/WinForms/OffScreen each have their own CefSettings implementation that sets
+    /// relevant settings e.g. OffScreen starts with audio muted.
+    /// </summary>
     public abstract class CefSettingsBase
     {
         internal Core.CefSettingsBase settings = new Core.CefSettingsBase();
@@ -763,10 +779,15 @@ public CefSettingsBase() : base()
             }
         }
 #endif
-
-        public static explicit operator CefSharp.Core.CefSettingsBase(CefSettingsBase s)
+        /// <summary>
+        /// Free the unmanaged CefSettingsBase instance.
+        /// Under normal circumstances you shouldn't need to call this
+        /// The unmanaged resource will be freed after <see cref="Cef.Initialize(CefSettingsBase)"/> (or one of the overloads) is called.
+        /// </summary>
+        public void Dispose()
         {
-            return s.settings;
+            settings?.Dispose();
+            settings = null;
         }
 
         /// <summary>