Property renaming

amaitland · amaitland · commit e19de45bfdb2 · 2022-06-21T13:51:51.000+10:00
diff --git a/CefSharp.OutOfProcess.BrowserProcess/OutOfProcessChromiumWebBrowser.cs b/CefSharp.OutOfProcess.BrowserProcess/OutOfProcessChromiumWebBrowser.cs
@@ -30,48 +30,48 @@ public partial class OutOfProcessChromiumWebBrowser : IWebBrowserInternal
         /// <summary>
         /// The managed cef browser adapter
         /// </summary>
-        private IBrowserAdapter managedCefBrowserAdapter;
+        private IBrowserAdapter _managedCefBrowserAdapter;
 
         /// <summary>
         /// JSON RPC used for IPC with host
         /// </summary>
-        private IOutOfProcessHostRpc outOfProcessServer;
+        private IOutOfProcessHostRpc _outofProcessHostRpc;
 
         /// <summary>
         /// Flag to guard the creation of the underlying browser - only one instance can be created
         /// </summary>
-        private bool browserCreated;
+        private bool _browserCreated;
 
         /// <summary>
         /// Used as workaround for issue https://github.com/cefsharp/CefSharp/issues/3021
         /// </summary>
-        private long canExecuteJavascriptInMainFrameId;
+        private long _canExecuteJavascriptInMainFrameId;
 
         /// <summary>
         /// The browser initialized - boolean represented as 0 (false) and 1(true) as we use Interlocker to increment/reset
         /// </summary>
-        private int browserInitialized;
+        private int _browserInitialized;
 
         /// <summary>
         /// The value for disposal, if it's 1 (one) then this instance is either disposed
         /// or in the process of getting disposed
         /// </summary>
-        private int disposeSignaled;
+        private int _disposeSignaled;
 
         /// <summary>
         /// The browser
         /// </summary>
-        private IBrowser browser;
+        private IBrowser _browser;
 
         /// <summary>
         /// Initial browser load task complection source
         /// </summary>
-        private TaskCompletionSource<LoadUrlAsyncResponse> initialLoadTaskCompletionSource = new TaskCompletionSource<LoadUrlAsyncResponse>();
+        private TaskCompletionSource<LoadUrlAsyncResponse> _initialLoadTaskCompletionSource = new TaskCompletionSource<LoadUrlAsyncResponse>();
 
         /// <summary>
         /// Initial browser load action
         /// </summary>
-        private Action<bool?, CefErrorCode?> initialLoadAction;
+        private Action<bool?, CefErrorCode?> _initialLoadAction;
 
         /// <summary>
         /// Id
@@ -254,12 +254,12 @@ void IWebBrowserInternal.SetCanExecuteJavascriptOnMainFrame(long frameId, bool c
             //incorrectly overrides the value
             //https://github.com/cefsharp/CefSharp/issues/3021
 
-            if (frameId > canExecuteJavascriptInMainFrameId && !canExecute)
+            if (frameId > _canExecuteJavascriptInMainFrameId && !canExecute)
             {
                 return;
             }
 
-            canExecuteJavascriptInMainFrameId = frameId;
+            _canExecuteJavascriptInMainFrameId = frameId;
             CanExecuteJavascriptInMainFrame = canExecute;
         }
 
@@ -304,7 +304,7 @@ void IWebBrowserInternal.OnStatusMessage(StatusMessageEventArgs args)
         {
             StatusMessage?.Invoke(this, args);
 
-            outOfProcessServer.NotifyStatusMessage(_id, args.Value);
+            _outofProcessHostRpc.NotifyStatusMessage(_id, args.Value);
         }
 
         /// <summary>
@@ -315,7 +315,7 @@ void IWebBrowserInternal.OnLoadError(LoadErrorEventArgs args)
         {
             LoadError?.Invoke(this, args);
 
-            initialLoadAction?.Invoke(null, args.ErrorCode);
+            _initialLoadAction?.Invoke(null, args.ErrorCode);
         }
 
         /// <summary>
@@ -335,7 +335,7 @@ void IWebBrowserInternal.OnLoadError(LoadErrorEventArgs args)
         /// <value>The browser adapter.</value>
         IBrowserAdapter IWebBrowserInternal.BrowserAdapter
         {
-            get { return managedCefBrowserAdapter; }
+            get { return _managedCefBrowserAdapter; }
         }
 
         void IWebBrowserInternal.OnAfterBrowserCreated(IBrowser browser)
@@ -345,25 +345,25 @@ void IWebBrowserInternal.OnAfterBrowserCreated(IBrowser browser)
                 return;
             }
 
-            this.browser = browser;
+            this._browser = browser;
             BrowserCore = browser;
-            initialLoadAction = InitialLoad;
-            Interlocked.Exchange(ref browserInitialized, 1);
+            _initialLoadAction = InitialLoad;
+            Interlocked.Exchange(ref _browserInitialized, 1);
 
             var host = browser.GetHost();
-            outOfProcessServer.NotifyBrowserCreated(_id, browser.GetHost().GetWindowHandle());
+            _outofProcessHostRpc.NotifyBrowserCreated(_id, browser.GetHost().GetWindowHandle());
 
             var observer = new CefSharpDevMessageObserver();
             observer.OnDevToolsAgentDetached((b) =>
             {
-                outOfProcessServer.NotifyDevToolsAgentDetached(_id);
+                _outofProcessHostRpc.NotifyDevToolsAgentDetached(_id);
             });
             observer.OnDevToolsMessage((b, m) =>
             {
                 using var reader = new StreamReader(m);
                 var msg = reader.ReadToEnd();
 
-                outOfProcessServer.NotifyDevToolsMessage(_id, msg);
+                _outofProcessHostRpc.NotifyDevToolsMessage(_id, msg);
             });
 
             _devtoolsMessageObserver = observer;
@@ -384,7 +384,7 @@ void IWebBrowserInternal.OnAfterBrowserCreated(IBrowser browser)
             {
                 ((IDisposable)devToolsClient).Dispose();
 
-                outOfProcessServer.NotifyDevToolsReady(_id);
+                _outofProcessHostRpc.NotifyDevToolsReady(_id);
 
             }, TaskScheduler.Default);            
         }
@@ -399,7 +399,7 @@ void IWebBrowserInternal.SetLoadingStateChange(LoadingStateChangedEventArgs args
 
             LoadingStateChanged?.Invoke(this, args);
 
-            initialLoadAction?.Invoke(args.IsLoading, null);
+            _initialLoadAction?.Invoke(args.IsLoading, null);
         }
 
         /// <inheritdoc/>
@@ -425,13 +425,13 @@ public Task<WaitForNavigationAsyncResponse> WaitForNavigationAsync(TimeSpan? tim
         /// <inheritdoc/>
         public Task<LoadUrlAsyncResponse> WaitForInitialLoadAsync()
         {
-            return initialLoadTaskCompletionSource.Task;
+            return _initialLoadTaskCompletionSource.Task;
         }
 
         /// <inheritdoc/>
         public bool TryGetBrowserCoreById(int browserId, out IBrowser browser)
         {
-            var browserAdapter = managedCefBrowserAdapter;
+            var browserAdapter = _managedCefBrowserAdapter;
 
             if (IsDisposed || browserAdapter == null || browserAdapter.IsDisposed)
             {
@@ -451,7 +451,7 @@ public bool TryGetBrowserCoreById(int browserId, out IBrowser browser)
             ThrowExceptionIfDisposed();
             ThrowExceptionIfBrowserNotInitialized();
 
-            using (var devToolsClient = browser.GetDevToolsClient())
+            using (var devToolsClient = _browser.GetDevToolsClient())
             {
                 //Get the content size
                 var layoutMetricsResponse = await devToolsClient.Page.GetLayoutMetricsAsync().ConfigureAwait(continueOnCapturedContext: false);
@@ -464,9 +464,9 @@ private void InitialLoad(bool? isLoading, CefErrorCode? errorCode)
         {
             if (IsDisposed)
             {
-                initialLoadAction = null;
+                _initialLoadAction = null;
 
-                initialLoadTaskCompletionSource.TrySetCanceled();
+                _initialLoadTaskCompletionSource.TrySetCanceled();
 
                 return;
             }
@@ -478,9 +478,9 @@ private void InitialLoad(bool? isLoading, CefErrorCode? errorCode)
                     return;
                 }
 
-                initialLoadAction = null;
+                _initialLoadAction = null;
 
-                var host = browser?.GetHost();
+                var host = _browser?.GetHost();
 
                 var navEntry = host?.GetVisibleNavigationEntry();
 
@@ -493,7 +493,7 @@ private void InitialLoad(bool? isLoading, CefErrorCode? errorCode)
                     statusCode = -1;
                 }
 
-                initialLoadTaskCompletionSource.TrySetResultAsync(new LoadUrlAsyncResponse(CefErrorCode.None, statusCode));
+                _initialLoadTaskCompletionSource.TrySetResultAsync(new LoadUrlAsyncResponse(CefErrorCode.None, statusCode));
             }
             else if (errorCode.HasValue)
             {
@@ -504,9 +504,9 @@ private void InitialLoad(bool? isLoading, CefErrorCode? errorCode)
                     return;
                 }
 
-                initialLoadAction = null;
+                _initialLoadAction = null;
 
-                initialLoadTaskCompletionSource.TrySetResultAsync(new LoadUrlAsyncResponse(errorCode.Value, -1));
+                _initialLoadTaskCompletionSource.TrySetResultAsync(new LoadUrlAsyncResponse(errorCode.Value, -1));
             }
         }
 
@@ -544,7 +544,7 @@ private bool InternalIsBrowserInitialized()
         {
             // Use CompareExchange to read the current value - if disposeCount is 1, we set it to 1, effectively a no-op
             // Volatile.Read would likely use a memory barrier which I believe is unnecessary in this scenario
-            return Interlocked.CompareExchange(ref browserInitialized, 0, 0) == 1;
+            return Interlocked.CompareExchange(ref _browserInitialized, 0, 0) == 1;
         }
 
         /// <summary>
@@ -579,7 +579,7 @@ public bool IsDisposed
         {
             get
             {
-                return Interlocked.CompareExchange(ref disposeSignaled, 1, 1) == 1;
+                return Interlocked.CompareExchange(ref _disposeSignaled, 1, 1) == 1;
             }
         }
 
@@ -675,12 +675,12 @@ public OutOfProcessChromiumWebBrowser(IOutOfProcessHostRpc outOfProcessServer, i
         {
             _id = id;
             RequestContext = requestContext;
-            this.outOfProcessServer = outOfProcessServer;
+            this._outofProcessHostRpc = outOfProcessServer;
 
             Cef.AddDisposable(this);
             Address = address;
 
-            managedCefBrowserAdapter = ManagedCefBrowserAdapter.Create(this, false);
+            _managedCefBrowserAdapter = ManagedCefBrowserAdapter.Create(this, false);
         }
 
         /// <summary>
@@ -708,7 +708,7 @@ protected virtual void Dispose(bool disposing)
         {
             // Attempt to move the disposeSignaled state from 0 to 1. If successful, we can be assured that
             // this thread is the first thread to do so, and can safely dispose of the object.
-            if (Interlocked.CompareExchange(ref disposeSignaled, 1, 0) != 0)
+            if (Interlocked.CompareExchange(ref _disposeSignaled, 1, 0) != 0)
             {
                 return;
             }
@@ -721,7 +721,7 @@ protected virtual void Dispose(bool disposing)
                 _devtoolsMessageObserver = null;
 
                 CanExecuteJavascriptInMainFrame = false;
-                Interlocked.Exchange(ref browserInitialized, 0);
+                Interlocked.Exchange(ref _browserInitialized, 0);
 
                 // Don't reference event listeners any longer:
                 AddressChanged = null;
@@ -742,11 +742,11 @@ protected virtual void Dispose(bool disposing)
 
                 FocusHandler = new NoFocusHandler();
 
-                browser = null;
+                _browser = null;
                 BrowserCore = null;
 
-                managedCefBrowserAdapter?.Dispose();
-                managedCefBrowserAdapter = null;
+                _managedCefBrowserAdapter?.Dispose();
+                _managedCefBrowserAdapter = null;
 
                 // LifeSpanHandler is set to null after managedCefBrowserAdapter.Dispose so ILifeSpanHandler.DoClose
                 // is called.
@@ -764,12 +764,12 @@ protected virtual void Dispose(bool disposing)
         /// <exception cref="System.Exception">An instance of the underlying browser has already been created, this method can only be called once.</exception>
         public void CreateBrowser(IWindowInfo windowInfo = null, IBrowserSettings browserSettings = null)
         {
-            if (browserCreated)
+            if (_browserCreated)
             {
                 throw new Exception("An instance of the underlying browser has already been created, this method can only be called once.");
             }
 
-            browserCreated = true;
+            _browserCreated = true;
 
             if (browserSettings == null)
             {
@@ -792,7 +792,7 @@ public void CreateBrowser(IWindowInfo windowInfo = null, IBrowserSettings browse
                     return;
                 }
 
-                managedCefBrowserAdapter.CreateBrowser(windowInfo, browserSettings, RequestContext, Address);
+                _managedCefBrowserAdapter.CreateBrowser(windowInfo, browserSettings, RequestContext, Address);
 
                 //Dispose of BrowserSettings if we created it, if user created then they're responsible
                 if (browserSettings.AutoDispose)
@@ -834,7 +834,7 @@ public void Load(string url)
         /// </summary>
         public IJavascriptObjectRepository JavascriptObjectRepository
         {
-            get { return managedCefBrowserAdapter?.JavascriptObjectRepository; }
+            get { return _managedCefBrowserAdapter?.JavascriptObjectRepository; }
         }
 
         /// <summary>
@@ -861,7 +861,7 @@ public IBrowser GetBrowser()
             ThrowExceptionIfDisposed();
             ThrowExceptionIfBrowserNotInitialized();
 
-            return browser;
+            return _browser;
         }
 
         /// <summary>
@@ -874,7 +874,7 @@ void IWebBrowserInternal.SetAddress(AddressChangedEventArgs args)
 
             AddressChanged?.Invoke(this, args);
 
-            outOfProcessServer.NotifyAddressChanged(_id, args.Address);
+            _outofProcessHostRpc.NotifyAddressChanged(_id, args.Address);
         }
 
         /// <summary>
@@ -887,7 +887,7 @@ partial void SetLoadingStateChange(LoadingStateChangedEventArgs args)
             CanGoForward = args.CanGoForward;
             IsLoading = args.IsLoading;
 
-            outOfProcessServer.NotifyLoadingStateChange(_id, args.CanGoBack, args.CanGoForward, args.IsLoading);
+            _outofProcessHostRpc.NotifyLoadingStateChange(_id, args.CanGoBack, args.CanGoForward, args.IsLoading);
         }
 
         /// <summary>
@@ -898,7 +898,7 @@ void IWebBrowserInternal.SetTitle(TitleChangedEventArgs args)
         {
             TitleChanged?.Invoke(this, args);
 
-            outOfProcessServer.NotifyTitleChanged(_id, args.Title);
+            _outofProcessHostRpc.NotifyTitleChanged(_id, args.Title);
         }
 
         /// <summary>

Original file line number	Diff line number	Diff line change
`@@ -30,48 +30,48 @@ public partial class OutOfProcessChromiumWebBrowser : IWebBrowserInternal`
`30`	`30`	`/// <summary>`
`31`	`31`	`/// The managed cef browser adapter`
`32`	`32`	`/// </summary>`
`33`		`- private IBrowserAdapter managedCefBrowserAdapter;`
	`33`	`+ private IBrowserAdapter _managedCefBrowserAdapter;`
`34`	`34`
`35`	`35`	`/// <summary>`
`36`	`36`	`/// JSON RPC used for IPC with host`
`37`	`37`	`/// </summary>`
`38`		`- private IOutOfProcessHostRpc outOfProcessServer;`
	`38`	`+ private IOutOfProcessHostRpc _outofProcessHostRpc;`
`39`	`39`
`40`	`40`	`/// <summary>`
`41`	`41`	`/// Flag to guard the creation of the underlying browser - only one instance can be created`
`42`	`42`	`/// </summary>`
`43`		`- private bool browserCreated;`
	`43`	`+ private bool _browserCreated;`
`44`	`44`
`45`	`45`	`/// <summary>`
`46`	`46`	`/// Used as workaround for issue https://github.com/cefsharp/CefSharp/issues/3021`
`47`	`47`	`/// </summary>`
`48`		`- private long canExecuteJavascriptInMainFrameId;`
	`48`	`+ private long _canExecuteJavascriptInMainFrameId;`
`49`	`49`
`50`	`50`	`/// <summary>`
`51`	`51`	`/// The browser initialized - boolean represented as 0 (false) and 1(true) as we use Interlocker to increment/reset`
`52`	`52`	`/// </summary>`
`53`		`- private int browserInitialized;`
	`53`	`+ private int _browserInitialized;`
`54`	`54`
`55`	`55`	`/// <summary>`
`56`	`56`	`/// The value for disposal, if it's 1 (one) then this instance is either disposed`
`57`	`57`	`/// or in the process of getting disposed`
`58`	`58`	`/// </summary>`
`59`		`- private int disposeSignaled;`
	`59`	`+ private int _disposeSignaled;`
`60`	`60`
`61`	`61`	`/// <summary>`
`62`	`62`	`/// The browser`
`63`	`63`	`/// </summary>`
`64`		`- private IBrowser browser;`
	`64`	`+ private IBrowser _browser;`
`65`	`65`
`66`	`66`	`/// <summary>`
`67`	`67`	`/// Initial browser load task complection source`
`68`	`68`	`/// </summary>`
`69`		`- private TaskCompletionSource<LoadUrlAsyncResponse> initialLoadTaskCompletionSource = new TaskCompletionSource<LoadUrlAsyncResponse>();`
	`69`	`+ private TaskCompletionSource<LoadUrlAsyncResponse> _initialLoadTaskCompletionSource = new TaskCompletionSource<LoadUrlAsyncResponse>();`
`70`	`70`
`71`	`71`	`/// <summary>`
`72`	`72`	`/// Initial browser load action`
`73`	`73`	`/// </summary>`
`74`		`- private Action<bool?, CefErrorCode?> initialLoadAction;`
	`74`	`+ private Action<bool?, CefErrorCode?> _initialLoadAction;`
`75`	`75`
`76`	`76`	`/// <summary>`
`77`	`77`	`/// Id`
`@@ -254,12 +254,12 @@ void IWebBrowserInternal.SetCanExecuteJavascriptOnMainFrame(long frameId, bool c`
`254`	`254`	`//incorrectly overrides the value`
`255`	`255`	`//https://github.com/cefsharp/CefSharp/issues/3021`
`256`	`256`
`257`		`- if (frameId > canExecuteJavascriptInMainFrameId && !canExecute)`
	`257`	`+ if (frameId > _canExecuteJavascriptInMainFrameId && !canExecute)`
`258`	`258`	`{`
`259`	`259`	`return;`
`260`	`260`	`}`
`261`	`261`
`262`		`- canExecuteJavascriptInMainFrameId = frameId;`
	`262`	`+ _canExecuteJavascriptInMainFrameId = frameId;`
`263`	`263`	`CanExecuteJavascriptInMainFrame = canExecute;`
`264`	`264`	`}`
`265`	`265`
`@@ -304,7 +304,7 @@ void IWebBrowserInternal.OnStatusMessage(StatusMessageEventArgs args)`
`304`	`304`	`{`
`305`	`305`	`StatusMessage?.Invoke(this, args);`
`306`	`306`
`307`		`- outOfProcessServer.NotifyStatusMessage(_id, args.Value);`
	`307`	`+ _outofProcessHostRpc.NotifyStatusMessage(_id, args.Value);`
`308`	`308`	`}`
`309`	`309`
`310`	`310`	`/// <summary>`
`@@ -315,7 +315,7 @@ void IWebBrowserInternal.OnLoadError(LoadErrorEventArgs args)`
`315`	`315`	`{`
`316`	`316`	`LoadError?.Invoke(this, args);`
`317`	`317`
`318`		`- initialLoadAction?.Invoke(null, args.ErrorCode);`
	`318`	`+ _initialLoadAction?.Invoke(null, args.ErrorCode);`
`319`	`319`	`}`
`320`	`320`
`321`	`321`	`/// <summary>`
`@@ -335,7 +335,7 @@ void IWebBrowserInternal.OnLoadError(LoadErrorEventArgs args)`
`335`	`335`	`/// <value>The browser adapter.</value>`
`336`	`336`	`IBrowserAdapter IWebBrowserInternal.BrowserAdapter`
`337`	`337`	`{`
`338`		`- get { return managedCefBrowserAdapter; }`
	`338`	`+ get { return _managedCefBrowserAdapter; }`
`339`	`339`	`}`
`340`	`340`
`341`	`341`	`void IWebBrowserInternal.OnAfterBrowserCreated(IBrowser browser)`
`@@ -345,25 +345,25 @@ void IWebBrowserInternal.OnAfterBrowserCreated(IBrowser browser)`
`345`	`345`	`return;`
`346`	`346`	`}`
`347`	`347`
`348`		`- this.browser = browser;`
	`348`	`+ this._browser = browser;`
`349`	`349`	`BrowserCore = browser;`
`350`		`- initialLoadAction = InitialLoad;`
`351`		`- Interlocked.Exchange(ref browserInitialized, 1);`
	`350`	`+ _initialLoadAction = InitialLoad;`
	`351`	`+ Interlocked.Exchange(ref _browserInitialized, 1);`
`352`	`352`
`353`	`353`	`var host = browser.GetHost();`
`354`		`- outOfProcessServer.NotifyBrowserCreated(_id, browser.GetHost().GetWindowHandle());`
	`354`	`+ _outofProcessHostRpc.NotifyBrowserCreated(_id, browser.GetHost().GetWindowHandle());`
`355`	`355`
`356`	`356`	`var observer = new CefSharpDevMessageObserver();`
`357`	`357`	`observer.OnDevToolsAgentDetached((b) =>`
`358`	`358`	`{`
`359`		`- outOfProcessServer.NotifyDevToolsAgentDetached(_id);`
	`359`	`+ _outofProcessHostRpc.NotifyDevToolsAgentDetached(_id);`
`360`	`360`	`});`
`361`	`361`	`observer.OnDevToolsMessage((b, m) =>`
`362`	`362`	`{`
`363`	`363`	`using var reader = new StreamReader(m);`
`364`	`364`	`var msg = reader.ReadToEnd();`
`365`	`365`
`366`		`- outOfProcessServer.NotifyDevToolsMessage(_id, msg);`
	`366`	`+ _outofProcessHostRpc.NotifyDevToolsMessage(_id, msg);`
`367`	`367`	`});`
`368`	`368`
`369`	`369`	`_devtoolsMessageObserver = observer;`
`@@ -384,7 +384,7 @@ void IWebBrowserInternal.OnAfterBrowserCreated(IBrowser browser)`
`384`	`384`	`{`
`385`	`385`	`((IDisposable)devToolsClient).Dispose();`
`386`	`386`
`387`		`- outOfProcessServer.NotifyDevToolsReady(_id);`
	`387`	`+ _outofProcessHostRpc.NotifyDevToolsReady(_id);`
`388`	`388`
`389`	`389`	`}, TaskScheduler.Default);`
`390`	`390`	`}`
`@@ -399,7 +399,7 @@ void IWebBrowserInternal.SetLoadingStateChange(LoadingStateChangedEventArgs args`
`399`	`399`
`400`	`400`	`LoadingStateChanged?.Invoke(this, args);`
`401`	`401`
`402`		`- initialLoadAction?.Invoke(args.IsLoading, null);`
	`402`	`+ _initialLoadAction?.Invoke(args.IsLoading, null);`
`403`	`403`	`}`
`404`	`404`
`405`	`405`	`/// <inheritdoc/>`
`@@ -425,13 +425,13 @@ public Task<WaitForNavigationAsyncResponse> WaitForNavigationAsync(TimeSpan? tim`
`425`	`425`	`/// <inheritdoc/>`
`426`	`426`	`public Task<LoadUrlAsyncResponse> WaitForInitialLoadAsync()`
`427`	`427`	`{`
`428`		`- return initialLoadTaskCompletionSource.Task;`
	`428`	`+ return _initialLoadTaskCompletionSource.Task;`
`429`	`429`	`}`
`430`	`430`
`431`	`431`	`/// <inheritdoc/>`
`432`	`432`	`public bool TryGetBrowserCoreById(int browserId, out IBrowser browser)`
`433`	`433`	`{`
`434`		`- var browserAdapter = managedCefBrowserAdapter;`
	`434`	`+ var browserAdapter = _managedCefBrowserAdapter;`
`435`	`435`
`436`	`436`	`if (IsDisposed \|\| browserAdapter == null \|\| browserAdapter.IsDisposed)`
`437`	`437`	`{`
`@@ -451,7 +451,7 @@ public bool TryGetBrowserCoreById(int browserId, out IBrowser browser)`
`451`	`451`	`ThrowExceptionIfDisposed();`
`452`	`452`	`ThrowExceptionIfBrowserNotInitialized();`
`453`	`453`
`454`		`- using (var devToolsClient = browser.GetDevToolsClient())`
	`454`	`+ using (var devToolsClient = _browser.GetDevToolsClient())`
`455`	`455`	`{`
`456`	`456`	`//Get the content size`
`457`	`457`	`var layoutMetricsResponse = await devToolsClient.Page.GetLayoutMetricsAsync().ConfigureAwait(continueOnCapturedContext: false);`
`@@ -464,9 +464,9 @@ private void InitialLoad(bool? isLoading, CefErrorCode? errorCode)`
`464`	`464`	`{`
`465`	`465`	`if (IsDisposed)`
`466`	`466`	`{`
`467`		`- initialLoadAction = null;`
	`467`	`+ _initialLoadAction = null;`
`468`	`468`
`469`		`- initialLoadTaskCompletionSource.TrySetCanceled();`
	`469`	`+ _initialLoadTaskCompletionSource.TrySetCanceled();`
`470`	`470`
`471`	`471`	`return;`
`472`	`472`	`}`
`@@ -478,9 +478,9 @@ private void InitialLoad(bool? isLoading, CefErrorCode? errorCode)`
`478`	`478`	`return;`
`479`	`479`	`}`
`480`	`480`
`481`		`- initialLoadAction = null;`
	`481`	`+ _initialLoadAction = null;`
`482`	`482`
`483`		`- var host = browser?.GetHost();`
	`483`	`+ var host = _browser?.GetHost();`
`484`	`484`
`485`	`485`	`var navEntry = host?.GetVisibleNavigationEntry();`
`486`	`486`
`@@ -493,7 +493,7 @@ private void InitialLoad(bool? isLoading, CefErrorCode? errorCode)`
`493`	`493`	`statusCode = -1;`
`494`	`494`	`}`
`495`	`495`
`496`		`- initialLoadTaskCompletionSource.TrySetResultAsync(new LoadUrlAsyncResponse(CefErrorCode.None, statusCode));`
	`496`	`+ _initialLoadTaskCompletionSource.TrySetResultAsync(new LoadUrlAsyncResponse(CefErrorCode.None, statusCode));`
`497`	`497`	`}`
`498`	`498`	`else if (errorCode.HasValue)`
`499`	`499`	`{`
`@@ -504,9 +504,9 @@ private void InitialLoad(bool? isLoading, CefErrorCode? errorCode)`
`504`	`504`	`return;`
`505`	`505`	`}`
`506`	`506`
`507`		`- initialLoadAction = null;`
	`507`	`+ _initialLoadAction = null;`
`508`	`508`
`509`		`- initialLoadTaskCompletionSource.TrySetResultAsync(new LoadUrlAsyncResponse(errorCode.Value, -1));`
	`509`	`+ _initialLoadTaskCompletionSource.TrySetResultAsync(new LoadUrlAsyncResponse(errorCode.Value, -1));`
`510`	`510`	`}`
`511`	`511`	`}`
`512`	`512`
`@@ -544,7 +544,7 @@ private bool InternalIsBrowserInitialized()`
`544`	`544`	`{`
`545`	`545`	`// Use CompareExchange to read the current value - if disposeCount is 1, we set it to 1, effectively a no-op`
`546`	`546`	`// Volatile.Read would likely use a memory barrier which I believe is unnecessary in this scenario`
`547`		`- return Interlocked.CompareExchange(ref browserInitialized, 0, 0) == 1;`
	`547`	`+ return Interlocked.CompareExchange(ref _browserInitialized, 0, 0) == 1;`
`548`	`548`	`}`
`549`	`549`
`550`	`550`	`/// <summary>`
`@@ -579,7 +579,7 @@ public bool IsDisposed`
`579`	`579`	`{`
`580`	`580`	`get`
`581`	`581`	`{`
`582`		`- return Interlocked.CompareExchange(ref disposeSignaled, 1, 1) == 1;`
	`582`	`+ return Interlocked.CompareExchange(ref _disposeSignaled, 1, 1) == 1;`
`583`	`583`	`}`
`584`	`584`	`}`
`585`	`585`
`@@ -675,12 +675,12 @@ public OutOfProcessChromiumWebBrowser(IOutOfProcessHostRpc outOfProcessServer, i`
`675`	`675`	`{`
`676`	`676`	`_id = id;`
`677`	`677`	`RequestContext = requestContext;`
`678`		`- this.outOfProcessServer = outOfProcessServer;`
	`678`	`+ this._outofProcessHostRpc = outOfProcessServer;`
`679`	`679`
`680`	`680`	`Cef.AddDisposable(this);`
`681`	`681`	`Address = address;`
`682`	`682`
`683`		`- managedCefBrowserAdapter = ManagedCefBrowserAdapter.Create(this, false);`
	`683`	`+ _managedCefBrowserAdapter = ManagedCefBrowserAdapter.Create(this, false);`
`684`	`684`	`}`
`685`	`685`
`686`	`686`	`/// <summary>`
`@@ -708,7 +708,7 @@ protected virtual void Dispose(bool disposing)`
`708`	`708`	`{`
`709`	`709`	`// Attempt to move the disposeSignaled state from 0 to 1. If successful, we can be assured that`
`710`	`710`	`// this thread is the first thread to do so, and can safely dispose of the object.`
`711`		`- if (Interlocked.CompareExchange(ref disposeSignaled, 1, 0) != 0)`
	`711`	`+ if (Interlocked.CompareExchange(ref _disposeSignaled, 1, 0) != 0)`
`712`	`712`	`{`
`713`	`713`	`return;`
`714`	`714`	`}`
`@@ -721,7 +721,7 @@ protected virtual void Dispose(bool disposing)`
`721`	`721`	`_devtoolsMessageObserver = null;`
`722`	`722`
`723`	`723`	`CanExecuteJavascriptInMainFrame = false;`
`724`		`- Interlocked.Exchange(ref browserInitialized, 0);`
	`724`	`+ Interlocked.Exchange(ref _browserInitialized, 0);`
`725`	`725`
`726`	`726`	`// Don't reference event listeners any longer:`
`727`	`727`	`AddressChanged = null;`
`@@ -742,11 +742,11 @@ protected virtual void Dispose(bool disposing)`
`742`	`742`
`743`	`743`	`FocusHandler = new NoFocusHandler();`
`744`	`744`
`745`		`- browser = null;`
	`745`	`+ _browser = null;`
`746`	`746`	`BrowserCore = null;`
`747`	`747`
`748`		`- managedCefBrowserAdapter?.Dispose();`
`749`		`- managedCefBrowserAdapter = null;`
	`748`	`+ _managedCefBrowserAdapter?.Dispose();`
	`749`	`+ _managedCefBrowserAdapter = null;`
`750`	`750`
`751`	`751`	`// LifeSpanHandler is set to null after managedCefBrowserAdapter.Dispose so ILifeSpanHandler.DoClose`
`752`	`752`	`// is called.`
`@@ -764,12 +764,12 @@ protected virtual void Dispose(bool disposing)`
`764`	`764`	`/// <exception cref="System.Exception">An instance of the underlying browser has already been created, this method can only be called once.</exception>`
`765`	`765`	`public void CreateBrowser(IWindowInfo windowInfo = null, IBrowserSettings browserSettings = null)`
`766`	`766`	`{`
`767`		`- if (browserCreated)`
	`767`	`+ if (_browserCreated)`
`768`	`768`	`{`
`769`	`769`	`throw new Exception("An instance of the underlying browser has already been created, this method can only be called once.");`
`770`	`770`	`}`
`771`	`771`
`772`		`- browserCreated = true;`
	`772`	`+ _browserCreated = true;`
`773`	`773`
`774`	`774`	`if (browserSettings == null)`
`775`	`775`	`{`
`@@ -792,7 +792,7 @@ public void CreateBrowser(IWindowInfo windowInfo = null, IBrowserSettings browse`
`792`	`792`	`return;`
`793`	`793`	`}`
`794`	`794`
`795`		`- managedCefBrowserAdapter.CreateBrowser(windowInfo, browserSettings, RequestContext, Address);`
	`795`	`+ _managedCefBrowserAdapter.CreateBrowser(windowInfo, browserSettings, RequestContext, Address);`
`796`	`796`
`797`	`797`	`//Dispose of BrowserSettings if we created it, if user created then they're responsible`
`798`	`798`	`if (browserSettings.AutoDispose)`
`@@ -834,7 +834,7 @@ public void Load(string url)`
`834`	`834`	`/// </summary>`
`835`	`835`	`public IJavascriptObjectRepository JavascriptObjectRepository`
`836`	`836`	`{`
`837`		`- get { return managedCefBrowserAdapter?.JavascriptObjectRepository; }`
	`837`	`+ get { return _managedCefBrowserAdapter?.JavascriptObjectRepository; }`
`838`	`838`	`}`
`839`	`839`
`840`	`840`	`/// <summary>`
`@@ -861,7 +861,7 @@ public IBrowser GetBrowser()`
`861`	`861`	`ThrowExceptionIfDisposed();`
`862`	`862`	`ThrowExceptionIfBrowserNotInitialized();`
`863`	`863`
`864`		`- return browser;`
	`864`	`+ return _browser;`
`865`	`865`	`}`
`866`	`866`
`867`	`867`	`/// <summary>`
`@@ -874,7 +874,7 @@ void IWebBrowserInternal.SetAddress(AddressChangedEventArgs args)`
`874`	`874`
`875`	`875`	`AddressChanged?.Invoke(this, args);`
`876`	`876`
`877`		`- outOfProcessServer.NotifyAddressChanged(_id, args.Address);`
	`877`	`+ _outofProcessHostRpc.NotifyAddressChanged(_id, args.Address);`
`878`	`878`	`}`
`879`	`879`
`880`	`880`	`/// <summary>`
`@@ -887,7 +887,7 @@ partial void SetLoadingStateChange(LoadingStateChangedEventArgs args)`
`887`	`887`	`CanGoForward = args.CanGoForward;`
`888`	`888`	`IsLoading = args.IsLoading;`
`889`	`889`
`890`		`- outOfProcessServer.NotifyLoadingStateChange(_id, args.CanGoBack, args.CanGoForward, args.IsLoading);`
	`890`	`+ _outofProcessHostRpc.NotifyLoadingStateChange(_id, args.CanGoBack, args.CanGoForward, args.IsLoading);`
`891`	`891`	`}`
`892`	`892`
`893`	`893`	`/// <summary>`
`@@ -898,7 +898,7 @@ void IWebBrowserInternal.SetTitle(TitleChangedEventArgs args)`
`898`	`898`	`{`
`899`	`899`	`TitleChanged?.Invoke(this, args);`
`900`	`900`
`901`		`- outOfProcessServer.NotifyTitleChanged(_id, args.Title);`
	`901`	`+ _outofProcessHostRpc.NotifyTitleChanged(_id, args.Title);`
`902`	`902`	`}`
`903`	`903`
`904`	`904`	`/// <summary>`