Avoid using a disposed connection in HistoryRepository

EntityFramework.sln.DotSettings

@@ -68,4 +68,5 @@
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateThisQualifierSettings/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002EJavaScript_002ECodeStyle_002ESettingsUpgrade_002EJsCodeFormatterSettingsUpgrader/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002EJavaScript_002ECodeStyle_002ESettingsUpgrade_002EJsParsFormattingSettingsUpgrader/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002EJavaScript_002ECodeStyle_002ESettingsUpgrade_002EJsWrapperSettingsUpgrader/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
+	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002EJavaScript_002ECodeStyle_002ESettingsUpgrade_002EJsWrapperSettingsUpgrader/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002EXml_002ECodeStyle_002EFormatSettingsUpgrade_002EXmlMoveToCommonFormatterSettingsUpgrade/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

src/EntityFramework/Internal/RepositoryBase.cs

@@ -9,7 +9,7 @@ namespace System.Data.Entity.Internal
 
     internal abstract class RepositoryBase
     {
-        private readonly DbConnection _existingConnection;
+        private readonly InternalContext _usersContext;
         private readonly string _connectionString;
         private readonly DbProviderFactory _providerFactory;
 
@@ -19,27 +19,30 @@ protected RepositoryBase(InternalContext usersContext, string connectionString,
             DebugCheck.NotEmpty(connectionString);
             DebugCheck.NotNull(providerFactory);
 
-            var existingConnection = usersContext.Connection;
-            if (existingConnection != null)
-            {
-                _existingConnection = existingConnection;
-            }
-
+            _usersContext = usersContext;
             _connectionString = connectionString;
             _providerFactory = providerFactory;
         }
 
         protected DbConnection CreateConnection()
         {
-            if (_existingConnection != null
-                && _existingConnection.State == ConnectionState.Open)
+            DbConnection connection;
+            if (!_usersContext.IsDisposed
+                && (connection = _usersContext.Connection) != null)
+            {
+                if (connection.State == ConnectionState.Open)
+                {
+                    return connection;
+                }
+
+                connection = DbProviderServices.GetProviderServices(connection)
+                    .CloneDbConnection(connection, _providerFactory);
+            }
+            else
             {
-                return _existingConnection;
+                connection = _providerFactory.CreateConnection();
             }
 
-            var connection = _existingConnection == null
-                ? _providerFactory.CreateConnection()
-                : DbProviderServices.GetProviderServices(_existingConnection).CloneDbConnection(_existingConnection, _providerFactory);
             DbInterception.Dispatch.Connection.SetConnectionString(connection,
                 new DbConnectionPropertyInterceptionContext<string>().WithValue(_connectionString));
 
@@ -48,7 +51,8 @@ protected DbConnection CreateConnection()
 
         protected void DisposeConnection(DbConnection connection)
         {
-            if (connection != null && _existingConnection == null)
+            if (connection != null
+                && (_usersContext.IsDisposed || connection != _usersContext.Connection))
             {
                 DbInterception.Dispatch.Connection.Dispose(connection, new DbInterceptionContext());
             }

src/EntityFramework/Migrations/DbMigrator.cs

@@ -210,6 +210,7 @@ var modelBuilder
                 if (usersContext == null)
                 {
                     _usersContext = null;
+                    _connection = null;
                     context.Dispose();
                 }
             }

test/EntityFramework/FunctionalTests/WrappingProvider/WrappingConnection.cs

@@ -6,7 +6,7 @@ namespace System.Data.Entity.WrappingProvider
 
     public class WrappingConnection<TBase> : DbConnection, IDisposable where TBase : DbProviderFactory
     {
-        private readonly DbConnection _baseConnection;
+        private DbConnection _baseConnection;
 
         public WrappingConnection(DbConnection baseConnection)
         {
@@ -89,6 +89,7 @@ public DbConnection BaseConnection
         public new void Dispose()
         {
             _baseConnection.Dispose();
+            _baseConnection = null;
         }
     }
 }

test/EntityFramework/FunctionalTests/WrappingProvider/WrappingProviderTests.cs

@@ -9,12 +9,14 @@ namespace System.Data.Entity.WrappingProvider
     using System.Data.Entity.Functionals.Utilities;
     using System.Data.Entity.Infrastructure;
     using System.Data.Entity.Infrastructure.DependencyResolution;
+    using System.Data.Entity.Migrations;
     using System.Data.Entity.Migrations.Sql;
     using System.Data.Entity.SqlServer;
     using System.Data.Entity.TestHelpers;
     using System.Data.SqlClient;
     using System.Linq;
     using System.Reflection;
+    using FunctionalTests.SimpleMigrationsModel;
     using Xunit;
 
     public class WrappingProviderTests : FunctionalTestBase, IDisposable
@@ -200,6 +202,38 @@ public void Simple_query_and_update_works_with_wrapping_provider_setup_at_EF_lev
             Assert.Contains("Generate", methods);
         }
 
+        [Fact]
+        [UseDefaultExecutionStrategy]
+        public void Migrations_work_with_wrapping_provider_setup_by_replacing_ADO_NET_provider()
+        {
+            RegisterAdoNetProvider(typeof(WrappingAdoNetProvider<SqlClientFactory>));
+            MutableResolver.AddResolver<DbProviderServices>(k => WrappingEfProvider<SqlClientFactory, SqlProviderServices>.Instance);
+            MutableResolver.AddResolver<Func<MigrationSqlGenerator>>(WrappingEfProvider<SqlClientFactory, SqlProviderServices>.Instance);
+
+            var log = WrappingAdoNetProvider<SqlClientFactory>.Instance.Log;
+            log.Clear();
+
+            using (var context = new MigrationsBlogContext())
+            {
+                context.Database.Delete();
+            }
+
+            using (var context = new MigrationsBlogContext())
+            {
+                Assert.False(context.Database.Exists());
+            }
+
+            var migrator = new DbMigrator(new MigrateInitializerConfiguration());
+            var appliedMigrations = migrator.GetDatabaseMigrations();
+            Assert.Equal(2, appliedMigrations.Count());
+
+            // Sanity check that the wrapping provider really did get used
+            var methods = log.Select(i => i.Method).ToList();
+            Assert.Contains("ExecuteReader", methods);
+            Assert.Contains("Open", methods);
+            Assert.Contains("Close", methods);
+        }
+
         [Fact] // CodePlex 2320
         public void Model_is_available_in_DatabaseExists()
         {
@@ -254,6 +288,22 @@ static EfLevelBlogContext()
             }
         }
 
+        public class MigrationsBlogContext : BlogContext
+        {
+            static MigrationsBlogContext()
+            {
+                Database.SetInitializer(new MigrateDatabaseToLatestVersion<MigrationsBlogContext, MigrationsBlogConfiguration>());
+            }
+        }
+
+        public class MigrationsBlogConfiguration : DbMigrationsConfiguration<MigrationsBlogContext>
+        {
+            public MigrationsBlogConfiguration()
+            {
+                MigrationsNamespace = "FunctionalTests.MigrationsBlogContext";
+            }
+        }
+
         public abstract class BlogContext : DbContext
         {
             public DbSet<Blog> Blogs { get; set; }