Changeset 109716 in webkit


Ignore:
Timestamp:
Mar 5, 2012 12:13:42 AM (12 years ago)
Author:
abarth@webkit.org
Message:

allowDatabaseAccess and databaseExceededQuota should be part of DatabaseContext not ScriptExecutionContext
https://bugs.webkit.org/show_bug.cgi?id=80178

Reviewed by Eric Seidel.

These functions are only used by SQLDatabase, which means we can move
them to DatabaseContext, removing one more tendril of the SQLDatabase
code.

  • dom/Document.cpp:

(WebCore):

  • dom/Document.h:

(Document):

  • dom/ScriptExecutionContext.h:

(ScriptExecutionContext):

  • storage/DatabaseContext.cpp:

(WebCore::DatabaseContext::DatabaseContext):
(WebCore::DatabaseContext::from):
(WebCore::DatabaseContext::allowDatabaseAccess):
(WebCore):
(WebCore::DatabaseContext::databaseExceededQuota):

  • storage/DatabaseContext.h:

(DatabaseContext):

  • storage/DatabaseTracker.cpp:

(WebCore::DatabaseTracker::canEstablishDatabase):

  • storage/SQLTransaction.cpp:

(WebCore::SQLTransaction::executeSQL):

  • storage/SQLTransactionClient.cpp:

(WebCore::SQLTransactionClient::didExceedQuota):

  • storage/SQLTransactionSync.cpp:

(WebCore::SQLTransactionSync::executeSQL):

  • workers/WorkerContext.cpp:

(WebCore):

  • workers/WorkerContext.h:

(WorkerContext):

Location:
trunk/Source/WebCore
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r109709 r109716  
     12012-03-05  Adam Barth  <abarth@webkit.org>
     2
     3        allowDatabaseAccess and databaseExceededQuota should be part of DatabaseContext not ScriptExecutionContext
     4        https://bugs.webkit.org/show_bug.cgi?id=80178
     5
     6        Reviewed by Eric Seidel.
     7
     8        These functions are only used by SQLDatabase, which means we can move
     9        them to DatabaseContext, removing one more tendril of the SQLDatabase
     10        code.
     11
     12        * dom/Document.cpp:
     13        (WebCore):
     14        * dom/Document.h:
     15        (Document):
     16        * dom/ScriptExecutionContext.h:
     17        (ScriptExecutionContext):
     18        * storage/DatabaseContext.cpp:
     19        (WebCore::DatabaseContext::DatabaseContext):
     20        (WebCore::DatabaseContext::from):
     21        (WebCore::DatabaseContext::allowDatabaseAccess):
     22        (WebCore):
     23        (WebCore::DatabaseContext::databaseExceededQuota):
     24        * storage/DatabaseContext.h:
     25        (DatabaseContext):
     26        * storage/DatabaseTracker.cpp:
     27        (WebCore::DatabaseTracker::canEstablishDatabase):
     28        * storage/SQLTransaction.cpp:
     29        (WebCore::SQLTransaction::executeSQL):
     30        * storage/SQLTransactionClient.cpp:
     31        (WebCore::SQLTransactionClient::didExceedQuota):
     32        * storage/SQLTransactionSync.cpp:
     33        (WebCore::SQLTransactionSync::executeSQL):
     34        * workers/WorkerContext.cpp:
     35        (WebCore):
     36        * workers/WorkerContext.h:
     37        (WorkerContext):
     38
    1392012-03-04  Sheriff Bot  <webkit.review.bot@gmail.com>
    240
  • trunk/Source/WebCore/dom/Document.cpp

    r109656 r109716  
    47394739}
    47404740
    4741 #if ENABLE(SQL_DATABASE)
    4742 
    4743 bool Document::allowDatabaseAccess() const
    4744 {
    4745     if (!page() || (page()->settings()->privateBrowsingEnabled() && !SchemeRegistry::allowsDatabaseAccessInPrivateBrowsing(securityOrigin()->protocol())))
    4746         return false;
    4747     return true;
    4748 }
    4749 
    4750 void Document::databaseExceededQuota(const String& name)
    4751 {
    4752     Page* currentPage = page();
    4753     if (currentPage)
    4754         currentPage->chrome()->client()->exceededDatabaseQuota(document()->frame(), name);
    4755 }
    4756 
    4757 #endif
    4758 
    47594741bool Document::isContextThread() const
    47604742{
  • trunk/Source/WebCore/dom/Document.h

    r109656 r109716  
    10291029    bool loadEventFinished() const { return m_loadEventFinished; }
    10301030
    1031 #if ENABLE(SQL_DATABASE)
    1032     virtual bool allowDatabaseAccess() const;
    1033     virtual void databaseExceededQuota(const String& name);
    1034 #endif
    1035 
    10361031    virtual bool isContextThread() const;
    10371032    virtual bool isJSExecutionForbidden() const { return false; }
  • trunk/Source/WebCore/dom/ScriptExecutionContext.h

    r109319 r109716  
    7171    virtual bool isWorkerContext() const { return false; }
    7272
    73 #if ENABLE(SQL_DATABASE)
    74     virtual bool allowDatabaseAccess() const = 0;
    75     virtual void databaseExceededQuota(const String& name) = 0;
    76 #endif
    7773    virtual bool isContextThread() const { return true; }
    7874    virtual bool isJSExecutionForbidden() const = 0;
  • trunk/Source/WebCore/storage/DatabaseContext.cpp

    r109319 r109716  
    3131#if ENABLE(SQL_DATABASE)
    3232
     33#include "Chrome.h"
     34#include "ChromeClient.h"
    3335#include "Database.h"
    3436#include "DatabaseTask.h"
    3537#include "DatabaseThread.h"
     38#include "DatabaseTracker.h"
     39#include "Document.h"
     40#include "Page.h"
     41#include "SchemeRegistry.h"
     42#include "SecurityOrigin.h"
     43#include "Settings.h"
    3644
    3745namespace WebCore {
     
    4250}
    4351
    44 DatabaseContext::DatabaseContext()
    45     : m_hasOpenDatabases(false)
     52DatabaseContext::DatabaseContext(ScriptExecutionContext* context)
     53    : m_scriptExecutionContext(context)
     54    , m_hasOpenDatabases(false)
    4655{
    4756}
     
    5968    DatabaseContext* supplement = existingDatabaseContextFrom(context);
    6069    if (!supplement) {
    61         supplement = new DatabaseContext();
     70        supplement = new DatabaseContext(context);
    6271        provideTo(context, "DatabaseContext", adoptPtr(supplement));
    6372        ASSERT(supplement == existingDatabaseContextFrom(context));
     
    101110}
    102111
     112bool DatabaseContext::allowDatabaseAccess() const
     113{
     114    if (m_scriptExecutionContext->isDocument()) {
     115        Document* document = static_cast<Document*>(m_scriptExecutionContext);
     116        if (!document->page() || (document->page()->settings()->privateBrowsingEnabled() && !SchemeRegistry::allowsDatabaseAccessInPrivateBrowsing(document->securityOrigin()->protocol())))
     117            return false;
     118        return true;
     119    }
     120    ASSERT(m_scriptExecutionContext->isWorkerContext());
     121    // allowDatabaseAccess is not yet implemented for workers.
     122    return true;
     123}
     124
     125void DatabaseContext::databaseExceededQuota(const String& name)
     126{
     127    if (m_scriptExecutionContext->isDocument()) {
     128        Document* document = static_cast<Document*>(m_scriptExecutionContext);
     129        if (Page* page = document->page())
     130            page->chrome()->client()->exceededDatabaseQuota(document->frame(), name);
     131        return;
     132    }
     133    ASSERT(m_scriptExecutionContext->isWorkerContext());
     134#if !PLATFORM(CHROMIUM)
     135    // FIXME: This needs a real implementation; this is a temporary solution for testing.
     136    const unsigned long long defaultQuota = 5 * 1024 * 1024;
     137    DatabaseTracker::tracker().setQuota(m_scriptExecutionContext->securityOrigin(), defaultQuota);
     138#endif
     139}
     140
    103141} // namespace WebCore
    104142
  • trunk/Source/WebCore/storage/DatabaseContext.h

    r109319 r109716  
    5454    static void stopDatabases(ScriptExecutionContext*, DatabaseTaskSynchronizer*);
    5555
     56    bool allowDatabaseAccess() const;
     57    void databaseExceededQuota(const String& name);
     58
    5659private:
    57     DatabaseContext();
     60    explicit DatabaseContext(ScriptExecutionContext*);
    5861
     62    ScriptExecutionContext* m_scriptExecutionContext;
    5963    RefPtr<DatabaseThread> m_databaseThread;
    6064    bool m_hasOpenDatabases; // This never changes back to false, even after the database thread is closed.
  • trunk/Source/WebCore/storage/DatabaseTracker.cpp

    r98316 r109716  
    3535#include "Chrome.h"
    3636#include "ChromeClient.h"
     37#include "DatabaseContext.h"
    3738#include "DatabaseThread.h"
    3839#include "DatabaseTrackerClient.h"
     
    176177    }
    177178    // Drop all locks before calling out; we don't know what they'll do.
    178     context->databaseExceededQuota(name);
     179    DatabaseContext::from(context)->databaseExceededQuota(name);
    179180
    180181    MutexLocker lockDatabase(m_databaseGuard);
  • trunk/Source/WebCore/storage/SQLTransaction.cpp

    r109319 r109716  
    9999
    100100    int permissions = DatabaseAuthorizer::ReadWriteMask;
    101     if (!m_database->scriptExecutionContext()->allowDatabaseAccess())
     101    if (!m_database->databaseContext()->allowDatabaseAccess())
    102102        permissions |= DatabaseAuthorizer::NoAccessMask;
    103103    else if (m_readOnly)
  • trunk/Source/WebCore/storage/SQLTransactionClient.cpp

    r95901 r109716  
    3535
    3636#include "AbstractDatabase.h"
     37#include "DatabaseContext.h"
    3738#include "DatabaseTracker.h"
    3839#include "ScriptExecutionContext.h"
     
    5657    ASSERT(database->scriptExecutionContext()->isContextThread());
    5758    unsigned long long currentQuota = DatabaseTracker::tracker().quotaForOrigin(database->securityOrigin());
    58     database->scriptExecutionContext()->databaseExceededQuota(database->stringIdentifier());
     59    database->databaseContext()->databaseExceededQuota(database->stringIdentifier());
    5960    unsigned long long newQuota = DatabaseTracker::tracker().quotaForOrigin(database->securityOrigin());
    6061    return (newQuota > currentQuota);
  • trunk/Source/WebCore/storage/SQLTransactionSync.cpp

    r101492 r109716  
    3535
    3636#include "DatabaseAuthorizer.h"
     37#include "DatabaseContext.h"
    3738#include "DatabaseSync.h"
    3839#include "PlatformString.h"
     
    9596
    9697    int permissions = DatabaseAuthorizer::ReadWriteMask;
    97     if (!m_database->scriptExecutionContext()->allowDatabaseAccess())
     98    if (!m_database->databaseContext()->allowDatabaseAccess())
    9899      permissions |= DatabaseAuthorizer::NoAccessMask;
    99100    else if (m_readOnly)
  • trunk/Source/WebCore/workers/WorkerContext.cpp

    r109556 r109716  
    320320}
    321321
    322 void WorkerContext::databaseExceededQuota(const String&)
    323 {
    324 #if !PLATFORM(CHROMIUM)
    325     // FIXME: This needs a real implementation; this is a temporary solution for testing.
    326     const unsigned long long defaultQuota = 5 * 1024 * 1024;
    327     DatabaseTracker::tracker().setQuota(securityOrigin(), defaultQuota);
    328 #endif
    329 }
    330 
    331322PassRefPtr<DatabaseSync> WorkerContext::openDatabaseSync(const String& name, const String& version, const String& displayName, unsigned long estimatedSize, PassRefPtr<DatabaseCallback> creationCallback, ExceptionCode& ec)
    332323{
  • trunk/Source/WebCore/workers/WorkerContext.h

    r109556 r109716  
    117117        PassRefPtr<Database> openDatabase(const String& name, const String& version, const String& displayName, unsigned long estimatedSize, PassRefPtr<DatabaseCallback> creationCallback, ExceptionCode&);
    118118        PassRefPtr<DatabaseSync> openDatabaseSync(const String& name, const String& version, const String& displayName, unsigned long estimatedSize, PassRefPtr<DatabaseCallback> creationCallback, ExceptionCode&);
    119 
    120         // Not implemented yet.
    121         virtual bool allowDatabaseAccess() const { return true; }
    122         // Not implemented for real yet.
    123         virtual void databaseExceededQuota(const String&);
    124119#endif
    125120        virtual bool isContextThread() const;
Note: See TracChangeset for help on using the changeset viewer.