Oilpan: DatabaseThread::m_thread should not get destructed during sweeping

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 164 matching lines @@
     // 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.
 
     if (m_databaseThread && !m_hasRequestedTermination) {
         TaskSynchronizer sync;
         m_databaseThread->requestTermination(&sync);
         m_hasRequestedTermination = true;
         sync.waitForTaskCompletion();
+        m_databaseThread->dispose();

[wibling-chromium, 2014/09/23 08:40:59]

It would be nice with a comment explaining why it is safe to dispose of the
webthread at this point. Ie. something like the sync.waitForTaskCompletion will
not return until the cleanupDatabaseThreadCompleted method has been called at
which point the webthread should no longer be reused.

That said I am not that familiar with the code to say there cannot be a new
scheduleTask call before the context is destructed?

[zerny-chromium, 2014/09/23 08:46:29]

Alternatively we could encapsulate this in the database thread abstraction, ala:

DatabaseThread::terminate(bool* terminating)
{
    TaskSynchronizer sync;
    requestTermination(&sync);
    *terminating = true;
    sync.waitForTaskCompletion();
    // Oilpan: comment about waiting before clearing goes here.
    m_thread.clear();
}

That would avoid a public dispose and some out-of-context reasoning.

     }
 }
 
 bool DatabaseContext::allowDatabaseAccess() const
 {
     return toDocument(executionContext())->isActive();
 }
 
 SecurityOrigin* DatabaseContext::securityOrigin() const
 {
     return executionContext()->securityOrigin();
 }
 
 bool DatabaseContext::isContextThread() const
 {
     return executionContext()->isContextThread();
 }
 
 } // namespace blink