Remove worker support of Web SQL Database.

Source/modules/webdatabase/DatabaseBackendBase.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  * Copyright (C) 2013 Apple 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.
@@ skipping 184 matching lines @@
     return guid;
 }
 
 // static
 const char* DatabaseBackendBase::databaseInfoTableName()
 {
     return infoTableName;
 }
 
 DatabaseBackendBase::DatabaseBackendBase(DatabaseContext* databaseContext, const String& name,
-    const String& expectedVersion, const String& displayName, unsigned long estimatedSize, DatabaseType databaseType)
+    const String& expectedVersion, const String& displayName, unsigned long estimatedSize)
     : m_databaseContext(databaseContext)
     , m_name(name.isolatedCopy())
     , m_expectedVersion(expectedVersion.isolatedCopy())
     , m_displayName(displayName.isolatedCopy())
     , m_estimatedSize(estimatedSize)
     , m_guid(0)
     , m_opened(false)
     , m_new(false)
-    , m_isSyncDatabase(databaseType == DatabaseType::Sync)
 {
     m_contextThreadSecurityOrigin = m_databaseContext->securityOrigin()->isolatedCopy();
 
     m_databaseAuthorizer = DatabaseAuthorizer::create(infoTableName);
 
     if (m_name.isNull())
         m_name = "";
 
     {
         SafePointAwareMutexLocker locker(guidMutex());
@@ skipping 31 matching lines @@
     visitor->trace(m_databaseAuthorizer);
 }
 
 void DatabaseBackendBase::closeDatabase()
 {
     if (!m_opened)
         return;
 
     m_sqliteDatabase.close();
     m_opened = false;
-    databaseContext()->didCloseDatabase(*this);
     // See comment at the top this file regarding calling removeOpenDatabase().
     DatabaseTracker::tracker().removeOpenDatabase(this);
     {
         SafePointAwareMutexLocker locker(guidMutex());
 
         HashSet<DatabaseBackendBase*>* hashSet = guidToDatabaseMap().get(m_guid);
         ASSERT(hashSet);
         ASSERT(hashSet->contains(this));
         hashSet->remove(this);
         if (hashSet->isEmpty()) {
@@ skipping 134 matching lines @@
     if ((!m_new || shouldSetVersionInNewDatabase) && m_expectedVersion.length() && m_expectedVersion != currentVersion) {
         reportOpenDatabaseResult(6, InvalidStateError, 0);
         errorMessage = "unable to open database, version mismatch, '" + m_expectedVersion + "' does not match the currentVersion of '" + currentVersion + "'";
         m_sqliteDatabase.close();
         return false;
     }
 
     ASSERT(m_databaseAuthorizer);
     m_sqliteDatabase.setAuthorizer(m_databaseAuthorizer.get());
 
-    databaseContext()->didOpenDatabase(*this);
     // See comment at the top this file regarding calling addOpenDatabase().
     DatabaseTracker::tracker().addOpenDatabase(this);
     m_opened = true;
 
     // Declare success:
     error = DatabaseError::None; // Clear the presumed error from above.
     onExitCaller.setOpenSucceeded();
 
     if (m_new && !shouldSetVersionInNewDatabase)
         m_expectedVersion = ""; // The caller provided a creationCallback which will set the expected version.
@@ skipping 152 matching lines @@
     int64_t freeSpaceSize = m_sqliteDatabase.freeSpaceSize();
     int64_t totalSize = m_sqliteDatabase.totalSize();
     if (totalSize <= 10 * freeSpaceSize) {
         int result = m_sqliteDatabase.runIncrementalVacuumCommand();
         reportVacuumDatabaseResult(result);
         if (result != SQLResultOk)
             logErrorMessage(formatErrorMessage("error vacuuming database", result, m_sqliteDatabase.lastErrorMsg()));
     }
 }
 
-void DatabaseBackendBase::interrupt()
-{
-    m_sqliteDatabase.interrupt();
-}
-
-bool DatabaseBackendBase::isInterrupted()
-{
-    MutexLocker locker(m_sqliteDatabase.databaseMutex());
-    return m_sqliteDatabase.isInterrupted();
-}
-
 // These are used to generate histograms of errors seen with websql.
 // See about:histograms in chromium.
 void DatabaseBackendBase::reportOpenDatabaseResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
 {
     if (Platform::current()->databaseObserver()) {
         Platform::current()->databaseObserver()->reportOpenDatabaseResult(
             createDatabaseIdentifierFromSecurityOrigin(securityOrigin()),
-            stringIdentifier(), isSyncDatabase(),
+            stringIdentifier(), false,
             errorSite, webSqlErrorCode, sqliteErrorCode);
     }
 }
 
 void DatabaseBackendBase::reportChangeVersionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
 {
     if (Platform::current()->databaseObserver()) {
         Platform::current()->databaseObserver()->reportChangeVersionResult(
             createDatabaseIdentifierFromSecurityOrigin(securityOrigin()),
-            stringIdentifier(), isSyncDatabase(),
+            stringIdentifier(), false,
             errorSite, webSqlErrorCode, sqliteErrorCode);
     }
 }
 
 void DatabaseBackendBase::reportStartTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
 {
     if (Platform::current()->databaseObserver()) {
         Platform::current()->databaseObserver()->reportStartTransactionResult(
             createDatabaseIdentifierFromSecurityOrigin(securityOrigin()),
-            stringIdentifier(), isSyncDatabase(),
+            stringIdentifier(), false,
             errorSite, webSqlErrorCode, sqliteErrorCode);
     }
 }
 
 void DatabaseBackendBase::reportCommitTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
 {
     if (Platform::current()->databaseObserver()) {
         Platform::current()->databaseObserver()->reportCommitTransactionResult(
             createDatabaseIdentifierFromSecurityOrigin(securityOrigin()),
-            stringIdentifier(), isSyncDatabase(),
+            stringIdentifier(), false,
             errorSite, webSqlErrorCode, sqliteErrorCode);
     }
 }
 
 void DatabaseBackendBase::reportExecuteStatementResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
 {
     if (Platform::current()->databaseObserver()) {
         Platform::current()->databaseObserver()->reportExecuteStatementResult(
             createDatabaseIdentifierFromSecurityOrigin(securityOrigin()),
-            stringIdentifier(), isSyncDatabase(),
+            stringIdentifier(), false,
             errorSite, webSqlErrorCode, sqliteErrorCode);
     }
 }
 
 void DatabaseBackendBase::reportVacuumDatabaseResult(int sqliteErrorCode)
 {
     if (Platform::current()->databaseObserver()) {
         Platform::current()->databaseObserver()->reportVacuumDatabaseResult(
             createDatabaseIdentifierFromSecurityOrigin(securityOrigin()),
-            stringIdentifier(), isSyncDatabase(), sqliteErrorCode);
+            stringIdentifier(), false, sqliteErrorCode);
     }
 }
 
 void DatabaseBackendBase::logErrorMessage(const String& message)
 {
     executionContext()->addConsoleMessage(ConsoleMessage::create(StorageMessageSource, ErrorMessageLevel, message));
 }
 
 ExecutionContext* DatabaseBackendBase::executionContext() const
 {
     return databaseContext()->executionContext();
 }
 
 } // namespace blink