Remove manual ref()-deref() in DatabaseContext.

Source/modules/webdatabase/DatabaseContext.cpp

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  * Copyright (C) 2011 Google, Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 72 matching lines @@
 // while the Databases are shutting down on the DatabaseThread. Hence, there can be
 // a race condition as to whether the ExecutionContext or the Databases
 // destruct first.
 //
 // The RefPtrs in the Databases and ExecutionContext will ensure that the
 // DatabaseContext will outlive both regardless of which of the 2 destructs first.
 
 PassRefPtr<DatabaseContext> DatabaseContext::create(ExecutionContext* context)
 {
     RefPtr<DatabaseContext> self = adoptRef(new DatabaseContext(context));
-    self->ref(); // Is deref()-ed on contextDestroyed().
+    DatabaseManager::manager().registerDatabaseContext(self.get());
     return self.release();
 }
 
 DatabaseContext::DatabaseContext(ExecutionContext* context)
     : ActiveDOMObject(context)
     , m_hasOpenDatabases(false)
-    , m_isRegistered(true) // will register on construction below.
     , m_hasRequestedTermination(false)
 {
     // ActiveDOMObject expects this to be called to set internal flags.
     suspendIfNeeded();
 
     // For debug accounting only. We must do this before we register the
     // instance. The assertions assume this.
     DatabaseManager::manager().didConstructDatabaseContext();
-
-    DatabaseManager::manager().registerDatabaseContext(this);
 }
 
 DatabaseContext::~DatabaseContext()
 {
     ASSERT(!m_databaseThread || m_databaseThread->terminationRequested());
 
     // For debug accounting only. We must call this last. The assertions assume
     // this.
     DatabaseManager::manager().didDestructDatabaseContext();
 }
 
 // This is called if the associated ExecutionContext is destructing while
 // we're still associated with it. That's our cue to disassociate and shutdown.
 // To do this, we stop the database and let everything shutdown naturally
 // because the database closing process may still make use of this context.
 // It is not safe to just delete the context here.
 void DatabaseContext::contextDestroyed()
 {
+    RefPtr<DatabaseContext> protector(this);
     stopDatabases();
+    DatabaseManager::manager().unregisterDatabaseContext(this);
     ActiveDOMObject::contextDestroyed();
-    deref(); // paired with the ref() call on create().
 }
 
 void DatabaseContext::willStop()
 {
     DatabaseManager::manager().interruptAllDatabasesForContext(this);
 }
 
 // stop() is from stopActiveDOMObjects() which indicates that the owner LocalFrame
 // or WorkerThread is shutting down. Initiate the orderly shutdown by stopping
 // the associated databases.
@@ skipping 54 matching lines @@
     Vector<DatabaseBackendBase*> syncDatabases;
     copyToVector(m_openSyncDatabases, syncDatabases);
     m_openSyncDatabases.clear();
     for (size_t i = 0; i < syncDatabases.size(); ++i)
         syncDatabases[i]->closeImmediately();
 }
 
 void DatabaseContext::stopDatabases()
 {
     stopSyncDatabases();
-    if (m_isRegistered) {
-        DatabaseManager::manager().unregisterDatabaseContext(this);
-        m_isRegistered = false;
-    }
 
     // Though we initiate termination of the DatabaseThread here in
     // stopDatabases(), we can't clear the m_databaseThread ref till we get to
     // the destructor. This is because the Databases that are managed by
     // DatabaseThread still rely on this ref between the context and the thread
     // to execute the task for closing the database. By the time we get to the
     // destructor, we're guaranteed that the databases are destructed (which is
     // why our ref count is 0 then and we're destructing). Then, the
     // m_databaseThread RefPtr destructor will deref and delete the
     // DatabaseThread.
@@ skipping 19 matching lines @@
 {
     return executionContext()->securityOrigin();
 }
 
 bool DatabaseContext::isContextThread() const
 {
     return executionContext()->isContextThread();
 }
 
 } // namespace WebCore