1 /*

     2  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.

     3  * Copyright (C) 2007 Justin Haygood (jhaygood@reaktix.com)

     4  *

     5  * Redistribution and use in source and binary forms, with or without

     6  * modification, are permitted provided that the following conditions

     7  * are met:

     8  * 1. Redistributions of source code must retain the above copyright

     9  *    notice, this list of conditions and the following disclaimer.

    10  * 2. Redistributions in binary form must reproduce the above copyright

    11  *    notice, this list of conditions and the following disclaimer in the

    12  *    documentation and/or other materials provided with the distribution.

    13  *

    14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY

    15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

    17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR

    18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

    22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

    25  */

    26 

    27 #include "config.h"

    28 #include "IconDatabase.h"

    29 

    30 #if ENABLE(ICONDATABASE)

    31 

    32 #include "AutodrainedPool.h"

    33 #include "DocumentLoader.h"

    34 #include "FileSystem.h"

    35 #include "IconDatabaseClient.h"

    36 #include "IconRecord.h"

    37 #include "IntSize.h"

    38 #include "Logging.h"

    39 #include "ScriptController.h"

    40 #include "SQLiteStatement.h"

    41 #include "SQLiteTransaction.h"

    42 #include "SuddenTermination.h"

    43 #include <wtf/CurrentTime.h>

    44 #include <wtf/MainThread.h>

    45 #include <wtf/StdLibExtras.h>

    46 

    47 // For methods that are meant to support API from the main thread - should not be called internally

    48 #define ASSERT_NOT_SYNC_THREAD() ASSERT(!m_syncThreadRunning || !IS_ICON_SYNC_THREAD())

    49 

    50 // For methods that are meant to support the sync thread ONLY

    51 #define IS_ICON_SYNC_THREAD() (m_syncThread == currentThread())

    52 #define ASSERT_ICON_SYNC_THREAD() ASSERT(IS_ICON_SYNC_THREAD())

    53 

    54 #if PLATFORM(QT) || PLATFORM(GTK)

    55 #define CAN_THEME_URL_ICON

    56 #endif

    57 

    58 namespace WebCore {

    59 

    60 static IconDatabase* sharedIconDatabase = 0;

    61 static int databaseCleanupCounter = 0;

    62 

    63 // This version number is in the DB and marks the current generation of the schema

    64 // Currently, a mismatched schema causes the DB to be wiped and reset.  This isn't 

    65 // so bad during development but in the future, we would need to write a conversion

    66 // function to advance older released schemas to "current"

    67 static const int currentDatabaseVersion = 6;

    68 

    69 // Icons expire once every 4 days

    70 static const int iconExpirationTime = 60*60*24*4; 

    71 

    72 static const int updateTimerDelay = 5; 

    73 

    74 static bool checkIntegrityOnOpen = false;

    75 

    76 #ifndef NDEBUG

    77 static String urlForLogging(const String& url)

    78 {

    79     static unsigned urlTruncationLength = 120;

    80 

    81     if (url.length() < urlTruncationLength)

    82         return url;

    83     return url.substring(0, urlTruncationLength) + "...";

    84 }

    85 #endif

    86 

    87 static IconDatabaseClient* defaultClient() 

    88 {

    89     static IconDatabaseClient* defaultClient = new IconDatabaseClient();

    90     return defaultClient;

    91 }

    92 

    93 IconDatabase* iconDatabase()

    94 {

    95     if (!sharedIconDatabase) {

    96         ScriptController::initializeThreading();

    97         sharedIconDatabase = new IconDatabase;

    98     }

    99     return sharedIconDatabase;

   100 }

   101 

   102 // ************************

   103 // *** Main Thread Only ***

   104 // ************************

   105 

   106 void IconDatabase::setClient(IconDatabaseClient* client)

   107 {

   108     // We don't allow a null client, because we never null check it anywhere in this code

   109     // Also don't allow a client change after the thread has already began 

   110     // (setting the client should occur before the database is opened)

   111     ASSERT(client);

   112     ASSERT(!m_syncThreadRunning);

   113     if (!client || m_syncThreadRunning)

   114         return;

   115         

   116     m_client = client;

   117 }

   118 

   119 bool IconDatabase::open(const String& databasePath)

   120 {

   121     ASSERT_NOT_SYNC_THREAD();

   122 

   123     if (!m_isEnabled)

   124         return false;

   125 

   126     if (isOpen()) {

   127         LOG_ERROR("Attempt to reopen the IconDatabase which is already open.  Must close it first.");

   128         return false;

   129     }

   130 

   131     m_databaseDirectory = databasePath.crossThreadString();

   132 

   133     // Formulate the full path for the database file

   134     m_completeDatabasePath = pathByAppendingComponent(m_databaseDirectory, defaultDatabaseFilename());

   135 

   136     // Lock here as well as first thing in the thread so the thread doesn't actually commence until the createThread() call 

   137     // completes and m_syncThreadRunning is properly set

   138     m_syncLock.lock();

   139     m_syncThread = createThread(IconDatabase::iconDatabaseSyncThreadStart, this, "WebCore: IconDatabase");

   140     m_syncThreadRunning = m_syncThread;

   141     m_syncLock.unlock();

   142     if (!m_syncThread)

   143         return false;

   144     return true;

   145 }

   146 

   147 void IconDatabase::close()

   148 {

   149     ASSERT_NOT_SYNC_THREAD();

   150     

   151     if (m_syncThreadRunning) {

   152         // Set the flag to tell the sync thread to wrap it up

   153         m_threadTerminationRequested = true;

   154 

   155         // Wake up the sync thread if it's waiting

   156         wakeSyncThread();

   157         

   158         // Wait for the sync thread to terminate

   159         waitForThreadCompletion(m_syncThread, 0);

   160     }

   161 

   162     m_syncThreadRunning = false;    

   163     m_threadTerminationRequested = false;

   164     m_removeIconsRequested = false;

   165 

   166     m_syncDB.close();

   167     ASSERT(!isOpen());

   168 }

   169 

   170 void IconDatabase::removeAllIcons()

   171 {

   172     ASSERT_NOT_SYNC_THREAD();

   173     

   174     if (!isOpen())

   175         return;

   176 

   177     LOG(IconDatabase, "Requesting background thread to remove all icons");

   178     

   179     // Clear the in-memory record of every IconRecord, anything waiting to be read from disk, and anything waiting to be written to disk

   180     {

   181         MutexLocker locker(m_urlAndIconLock);

   182         

   183         // Clear the IconRecords for every page URL - RefCounting will cause the IconRecords themselves to be deleted

   184         // We don't delete the actual PageRecords because we have the "retain icon for url" count to keep track of

   185         HashMap<String, PageURLRecord*>::iterator iter = m_pageURLToRecordMap.begin();

   186         HashMap<String, PageURLRecord*>::iterator end = m_pageURLToRecordMap.end();

   187         for (; iter != end; ++iter)

   188             (*iter).second->setIconRecord(0);

   189             

   190         // Clear the iconURL -> IconRecord map

   191         m_iconURLToRecordMap.clear();

   192                     

   193         // Clear all in-memory records of things that need to be synced out to disk

   194         {

   195             MutexLocker locker(m_pendingSyncLock);

   196             m_pageURLsPendingSync.clear();

   197             m_iconsPendingSync.clear();

   198         }

   199         

   200         // Clear all in-memory records of things that need to be read in from disk

   201         {

   202             MutexLocker locker(m_pendingReadingLock);

   203             m_pageURLsPendingImport.clear();

   204             m_pageURLsInterestedInIcons.clear();

   205             m_iconsPendingReading.clear();

   206             m_loadersPendingDecision.clear();

   207         }

   208     }

   209     

   210     m_removeIconsRequested = true;

   211     wakeSyncThread();

   212 }

   213 

   214 Image* IconDatabase::iconForPageURL(const String& pageURLOriginal, const IntSize& size)

   215 {   

   216     ASSERT_NOT_SYNC_THREAD();

   217 

   218     // pageURLOriginal cannot be stored without being deep copied first.  

   219     // We should go our of our way to only copy it if we have to store it

   220     

   221     if (!isOpen() || pageURLOriginal.isEmpty())

   222         return defaultIcon(size);

   223 

   224     MutexLocker locker(m_urlAndIconLock);

   225     

   226     String pageURLCopy; // Creates a null string for easy testing

   227     

   228     PageURLRecord* pageRecord = m_pageURLToRecordMap.get(pageURLOriginal);

   229     if (!pageRecord) {

   230         pageURLCopy = pageURLOriginal.crossThreadString();

   231         pageRecord = getOrCreatePageURLRecord(pageURLCopy);

   232     }

   233     

   234     // If pageRecord is NULL, one of two things is true -

   235     // 1 - The initial url import is incomplete and this pageURL was marked to be notified once it is complete if an iconURL exists

   236     // 2 - The initial url import IS complete and this pageURL has no icon

   237     if (!pageRecord) {

   238         MutexLocker locker(m_pendingReadingLock);

   239         

   240         // Import is ongoing, there might be an icon.  In this case, register to be notified when the icon comes in

   241         // If we ever reach this condition, we know we've already made the pageURL copy

   242         if (!m_iconURLImportComplete)

   243             m_pageURLsInterestedInIcons.add(pageURLCopy);

   244         

   245         return 0;

   246     }

   247 

   248     IconRecord* iconRecord = pageRecord->iconRecord();

   249     

   250     // If the initial URL import isn't complete, it's possible to have a PageURL record without an associated icon

   251     // In this case, the pageURL is already in the set to alert the client when the iconURL mapping is complete so

   252     // we can just bail now

   253     if (!m_iconURLImportComplete && !iconRecord)

   254         return 0;

   255     

   256     // The only way we should *not* have an icon record is if this pageURL is retained but has no icon yet - make sure of that

   257     ASSERT(iconRecord || m_retainedPageURLs.contains(pageURLOriginal));

   258     

   259     if (!iconRecord)

   260         return 0;

   261         

   262     // If it's a new IconRecord object that doesn't have its imageData set yet,

   263     // mark it to be read by the background thread

   264     if (iconRecord->imageDataStatus() == ImageDataStatusUnknown) {

   265         if (pageURLCopy.isNull())

   266             pageURLCopy = pageURLOriginal.crossThreadString();

   267     

   268         MutexLocker locker(m_pendingReadingLock);

   269         m_pageURLsInterestedInIcons.add(pageURLCopy);

   270         m_iconsPendingReading.add(iconRecord);

   271         wakeSyncThread();

   272         return 0;

   273     }

   274     

   275     // If the size parameter was (0, 0) that means the caller of this method just wanted the read from disk to be kicked off

   276     // and isn't actually interested in the image return value

   277     if (size == IntSize(0, 0))

   278         return 0;

   279         

   280     // PARANOID DISCUSSION: This method makes some assumptions.  It returns a WebCore::image which the icon database might dispose of at anytime in the future,

   281     // and Images aren't ref counted.  So there is no way for the client to guarantee continued existence of the image.

   282     // This has *always* been the case, but in practice clients would always create some other platform specific representation of the image

   283     // and drop the raw Image*.  On Mac an NSImage, and on windows drawing into an HBITMAP.

   284     // The async aspect adds a huge question - what if the image is deleted before the platform specific API has a chance to create its own

   285     // representation out of it?

   286     // If an image is read in from the icondatabase, we do *not* overwrite any image data that exists in the in-memory cache.  

   287     // This is because we make the assumption that anything in memory is newer than whatever is in the database.

   288     // So the only time the data will be set from the second thread is when it is INITIALLY being read in from the database, but we would never 

   289     // delete the image on the secondary thread if the image already exists.

   290     return iconRecord->image(size);

   291 }

   292 

   293 void IconDatabase::readIconForPageURLFromDisk(const String& pageURL)

   294 {

   295     // The effect of asking for an Icon for a pageURL automatically queues it to be read from disk

   296     // if it hasn't already been set in memory.  The special IntSize (0, 0) is a special way of telling 

   297     // that method "I don't care about the actual Image, i just want you to make sure you're getting it from disk.

   298     iconForPageURL(pageURL, IntSize(0,0));

   299 }

   300 

   301 String IconDatabase::iconURLForPageURL(const String& pageURLOriginal)

   302 {    

   303     ASSERT_NOT_SYNC_THREAD(); 

   304         

   305     // Cannot do anything with pageURLOriginal that would end up storing it without deep copying first

   306     // Also, in the case we have a real answer for the caller, we must deep copy that as well

   307     

   308     if (!isOpen() || pageURLOriginal.isEmpty())

   309         return String();

   310         

   311     MutexLocker locker(m_urlAndIconLock);

   312     

   313     PageURLRecord* pageRecord = m_pageURLToRecordMap.get(pageURLOriginal);

   314     if (!pageRecord)

   315         pageRecord = getOrCreatePageURLRecord(pageURLOriginal.crossThreadString());

   316     

   317     // If pageRecord is NULL, one of two things is true -

   318     // 1 - The initial url import is incomplete and this pageURL has already been marked to be notified once it is complete if an iconURL exists

   319     // 2 - The initial url import IS complete and this pageURL has no icon

   320     if (!pageRecord)

   321         return String();

   322     

   323     // Possible the pageRecord is around because it's a retained pageURL with no iconURL, so we have to check

   324     return pageRecord->iconRecord() ? pageRecord->iconRecord()->iconURL().threadsafeCopy() : String();

   325 }

   326 

   327 #ifdef CAN_THEME_URL_ICON

   328 static inline void loadDefaultIconRecord(IconRecord* defaultIconRecord)

   329 {

   330      defaultIconRecord->loadImageFromResource("urlIcon");

   331 }

   332 #else

   333 static inline void loadDefaultIconRecord(IconRecord* defaultIconRecord)

   334 {

   335     static const unsigned char defaultIconData[] = { 0x4D, 0x4D, 0x00, 0x2A, 0x00, 0x00, 0x03, 0x32, 0x80, 0x00, 0x20, 0x50, 0x38, 0x24, 0x16, 0x0D, 0x07, 0x84, 0x42, 0x61, 0x50, 0xB8, 

   336         0x64, 0x08, 0x18, 0x0D, 0x0A, 0x0B, 0x84, 0xA2, 0xA1, 0xE2, 0x08, 0x5E, 0x39, 0x28, 0xAF, 0x48, 0x24, 0xD3, 0x53, 0x9A, 0x37, 0x1D, 0x18, 0x0E, 0x8A, 0x4B, 0xD1, 0x38, 

   337         0xB0, 0x7C, 0x82, 0x07, 0x03, 0x82, 0xA2, 0xE8, 0x6C, 0x2C, 0x03, 0x2F, 0x02, 0x82, 0x41, 0xA1, 0xE2, 0xF8, 0xC8, 0x84, 0x68, 0x6D, 0x1C, 0x11, 0x0A, 0xB7, 0xFA, 0x91, 

   338         0x6E, 0xD1, 0x7F, 0xAF, 0x9A, 0x4E, 0x87, 0xFB, 0x19, 0xB0, 0xEA, 0x7F, 0xA4, 0x95, 0x8C, 0xB7, 0xF9, 0xA9, 0x0A, 0xA9, 0x7F, 0x8C, 0x88, 0x66, 0x96, 0xD4, 0xCA, 0x69, 

   339         0x2F, 0x00, 0x81, 0x65, 0xB0, 0x29, 0x90, 0x7C, 0xBA, 0x2B, 0x21, 0x1E, 0x5C, 0xE6, 0xB4, 0xBD, 0x31, 0xB6, 0xE7, 0x7A, 0xBF, 0xDD, 0x6F, 0x37, 0xD3, 0xFD, 0xD8, 0xF2, 

   340         0xB6, 0xDB, 0xED, 0xAC, 0xF7, 0x03, 0xC5, 0xFE, 0x77, 0x53, 0xB6, 0x1F, 0xE6, 0x24, 0x8B, 0x1D, 0xFE, 0x26, 0x20, 0x9E, 0x1C, 0xE0, 0x80, 0x65, 0x7A, 0x18, 0x02, 0x01, 

   341         0x82, 0xC5, 0xA0, 0xC0, 0xF1, 0x89, 0xBA, 0x23, 0x30, 0xAD, 0x1F, 0xE7, 0xE5, 0x5B, 0x6D, 0xFE, 0xE7, 0x78, 0x3E, 0x1F, 0xEE, 0x97, 0x8B, 0xE7, 0x37, 0x9D, 0xCF, 0xE7, 

   342         0x92, 0x8B, 0x87, 0x0B, 0xFC, 0xA0, 0x8E, 0x68, 0x3F, 0xC6, 0x27, 0xA6, 0x33, 0xFC, 0x36, 0x5B, 0x59, 0x3F, 0xC1, 0x02, 0x63, 0x3B, 0x74, 0x00, 0x03, 0x07, 0x0B, 0x61, 

   343         0x00, 0x20, 0x60, 0xC9, 0x08, 0x00, 0x1C, 0x25, 0x9F, 0xE0, 0x12, 0x8A, 0xD5, 0xFE, 0x6B, 0x4F, 0x35, 0x9F, 0xED, 0xD7, 0x4B, 0xD9, 0xFE, 0x8A, 0x59, 0xB8, 0x1F, 0xEC, 

   344         0x56, 0xD3, 0xC1, 0xFE, 0x63, 0x4D, 0xF2, 0x83, 0xC6, 0xB6, 0x1B, 0xFC, 0x34, 0x68, 0x61, 0x3F, 0xC1, 0xA6, 0x25, 0xEB, 0xFC, 0x06, 0x58, 0x5C, 0x3F, 0xC0, 0x03, 0xE4, 

   345         0xC3, 0xFC, 0x04, 0x0F, 0x1A, 0x6F, 0xE0, 0xE0, 0x20, 0xF9, 0x61, 0x7A, 0x02, 0x28, 0x2B, 0xBC, 0x46, 0x25, 0xF3, 0xFC, 0x66, 0x3D, 0x99, 0x27, 0xF9, 0x7E, 0x6B, 0x1D, 

   346         0xC7, 0xF9, 0x2C, 0x5E, 0x1C, 0x87, 0xF8, 0xC0, 0x4D, 0x9A, 0xE7, 0xF8, 0xDA, 0x51, 0xB2, 0xC1, 0x68, 0xF2, 0x64, 0x1F, 0xE1, 0x50, 0xED, 0x0A, 0x04, 0x23, 0x79, 0x8A, 

   347         0x7F, 0x82, 0xA3, 0x39, 0x80, 0x7F, 0x80, 0xC2, 0xB1, 0x5E, 0xF7, 0x04, 0x2F, 0xB2, 0x10, 0x02, 0x86, 0x63, 0xC9, 0xCC, 0x07, 0xBF, 0x87, 0xF8, 0x4A, 0x38, 0xAF, 0xC1, 

   348         0x88, 0xF8, 0x66, 0x1F, 0xE1, 0xD9, 0x08, 0xD4, 0x8F, 0x25, 0x5B, 0x4A, 0x49, 0x97, 0x87, 0x39, 0xFE, 0x25, 0x12, 0x10, 0x68, 0xAA, 0x4A, 0x2F, 0x42, 0x29, 0x12, 0x69, 

   349         0x9F, 0xE1, 0xC1, 0x00, 0x67, 0x1F, 0xE1, 0x58, 0xED, 0x00, 0x83, 0x23, 0x49, 0x82, 0x7F, 0x81, 0x21, 0xE0, 0xFC, 0x73, 0x21, 0x00, 0x50, 0x7D, 0x2B, 0x84, 0x03, 0x83, 

   350         0xC2, 0x1B, 0x90, 0x06, 0x69, 0xFE, 0x23, 0x91, 0xAE, 0x50, 0x9A, 0x49, 0x32, 0xC2, 0x89, 0x30, 0xE9, 0x0A, 0xC4, 0xD9, 0xC4, 0x7F, 0x94, 0xA6, 0x51, 0xDE, 0x7F, 0x9D, 

   351         0x07, 0x89, 0xF6, 0x7F, 0x91, 0x85, 0xCA, 0x88, 0x25, 0x11, 0xEE, 0x50, 0x7C, 0x43, 0x35, 0x21, 0x60, 0xF1, 0x0D, 0x82, 0x62, 0x39, 0x07, 0x2C, 0x20, 0xE0, 0x80, 0x72, 

   352         0x34, 0x17, 0xA1, 0x80, 0xEE, 0xF0, 0x89, 0x24, 0x74, 0x1A, 0x2C, 0x93, 0xB3, 0x78, 0xCC, 0x52, 0x9D, 0x6A, 0x69, 0x56, 0xBB, 0x0D, 0x85, 0x69, 0xE6, 0x7F, 0x9E, 0x27, 

   353         0xB9, 0xFD, 0x50, 0x54, 0x47, 0xF9, 0xCC, 0x78, 0x9F, 0x87, 0xF9, 0x98, 0x70, 0xB9, 0xC2, 0x91, 0x2C, 0x6D, 0x1F, 0xE1, 0xE1, 0x00, 0xBF, 0x02, 0xC1, 0xF5, 0x18, 0x84,

   354         0x01, 0xE1, 0x48, 0x8C, 0x42, 0x07, 0x43, 0xC9, 0x76, 0x7F, 0x8B, 0x04, 0xE4, 0xDE, 0x35, 0x95, 0xAB, 0xB0, 0xF0, 0x5C, 0x55, 0x23, 0xF9, 0x7E, 0x7E, 0x9F, 0xE4, 0x0C, 

   355         0xA7, 0x55, 0x47, 0xC7, 0xF9, 0xE6, 0xCF, 0x1F, 0xE7, 0x93, 0x35, 0x52, 0x54, 0x63, 0x19, 0x46, 0x73, 0x1F, 0xE2, 0x61, 0x08, 0xF0, 0x82, 0xE1, 0x80, 0x92, 0xF9, 0x20, 

   356         0xC0, 0x28, 0x18, 0x0A, 0x05, 0xA1, 0xA2, 0xF8, 0x6E, 0xDB, 0x47, 0x49, 0xFE, 0x3E, 0x17, 0xB6, 0x61, 0x13, 0x1A, 0x29, 0x26, 0xA9, 0xFE, 0x7F, 0x92, 0x70, 0x69, 0xFE, 

   357         0x4C, 0x2F, 0x55, 0x01, 0xF1, 0x54, 0xD4, 0x35, 0x49, 0x4A, 0x69, 0x59, 0x83, 0x81, 0x58, 0x76, 0x9F, 0xE2, 0x20, 0xD6, 0x4C, 0x9B, 0xA0, 0x48, 0x1E, 0x0B, 0xB7, 0x48, 

   358         0x58, 0x26, 0x11, 0x06, 0x42, 0xE8, 0xA4, 0x40, 0x17, 0x27, 0x39, 0x00, 0x60, 0x2D, 0xA4, 0xC3, 0x2C, 0x7F, 0x94, 0x56, 0xE4, 0xE1, 0x77, 0x1F, 0xE5, 0xB9, 0xD7, 0x66, 

   359         0x1E, 0x07, 0xB3, 0x3C, 0x63, 0x1D, 0x35, 0x49, 0x0E, 0x63, 0x2D, 0xA2, 0xF1, 0x12, 0x60, 0x1C, 0xE0, 0xE0, 0x52, 0x1B, 0x8B, 0xAC, 0x38, 0x0E, 0x07, 0x03, 0x60, 0x28, 

   360         0x1C, 0x0E, 0x87, 0x00, 0xF0, 0x66, 0x27, 0x11, 0xA2, 0xC1, 0x02, 0x5A, 0x1C, 0xE4, 0x21, 0x83, 0x1F, 0x13, 0x86, 0xFA, 0xD2, 0x55, 0x1D, 0xD6, 0x61, 0xBC, 0x77, 0xD3, 

   361         0xE6, 0x91, 0xCB, 0x4C, 0x90, 0xA6, 0x25, 0xB8, 0x2F, 0x90, 0xC5, 0xA9, 0xCE, 0x12, 0x07, 0x02, 0x91, 0x1B, 0x9F, 0x68, 0x00, 0x16, 0x76, 0x0D, 0xA1, 0x00, 0x08, 0x06, 

   362         0x03, 0x81, 0xA0, 0x20, 0x1A, 0x0D, 0x06, 0x80, 0x30, 0x24, 0x12, 0x89, 0x20, 0x98, 0x4A, 0x1F, 0x0F, 0x21, 0xA0, 0x9E, 0x36, 0x16, 0xC2, 0x88, 0xE6, 0x48, 0x9B, 0x83, 

   363         0x31, 0x1C, 0x55, 0x1E, 0x43, 0x59, 0x1A, 0x56, 0x1E, 0x42, 0xF0, 0xFA, 0x4D, 0x1B, 0x9B, 0x08, 0xDC, 0x5B, 0x02, 0xA1, 0x30, 0x7E, 0x3C, 0xEE, 0x5B, 0xA6, 0xDD, 0xB8, 

   364         0x6D, 0x5B, 0x62, 0xB7, 0xCD, 0xF3, 0x9C, 0xEA, 0x04, 0x80, 0x80, 0x00, 0x00, 0x0E, 0x01, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x10, 0x00, 0x00, 0x01, 0x01, 

   365         0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x10, 0x00, 0x00, 0x01, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x03, 0xE0, 0x01, 0x03, 0x00, 0x03, 0x00, 0x00, 

   366         0x00, 0x01, 0x00, 0x05, 0x00, 0x00, 0x01, 0x06, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x01, 0x11, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 

   367         0x00, 0x08, 0x01, 0x15, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x04, 0x00, 0x00, 0x01, 0x16, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x00, 0x01, 0x17, 

   368         0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0x29, 0x01, 0x1A, 0x00, 0x05, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0xE8, 0x01, 0x1B, 0x00, 0x05, 0x00, 0x00, 

   369         0x00, 0x01, 0x00, 0x00, 0x03, 0xF0, 0x01, 0x1C, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x28, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 

   370         0x00, 0x00, 0x01, 0x52, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x0A, 

   371         0xFC, 0x80, 0x00, 0x00, 0x27, 0x10, 0x00, 0x0A, 0xFC, 0x80, 0x00, 0x00, 0x27, 0x10 };

   372         

   373     DEFINE_STATIC_LOCAL(RefPtr<SharedBuffer>, defaultIconBuffer, (SharedBuffer::create(defaultIconData, sizeof(defaultIconData))));

   374     defaultIconRecord->setImageData(defaultIconBuffer);

   375 }

   376 #endif

   377 

   378 Image* IconDatabase::defaultIcon(const IntSize& size)

   379 {

   380     ASSERT_NOT_SYNC_THREAD();

   381 

   382     

   383     if (!m_defaultIconRecord) {

   384         m_defaultIconRecord = IconRecord::create("urlIcon");

   385         loadDefaultIconRecord(m_defaultIconRecord.get());

   386     }

   387     

   388     return m_defaultIconRecord->image(size);

   389 }

   390 

   391 

   392 void IconDatabase::retainIconForPageURL(const String& pageURLOriginal)

   393 {    

   394     ASSERT_NOT_SYNC_THREAD();

   395     

   396     // Cannot do anything with pageURLOriginal that would end up storing it without deep copying first

   397     

   398     if (!isEnabled() || pageURLOriginal.isEmpty())

   399         return;

   400        

   401     MutexLocker locker(m_urlAndIconLock);

   402 

   403     PageURLRecord* record = m_pageURLToRecordMap.get(pageURLOriginal);

   404     

   405     String pageURL;

   406     

   407     if (!record) {

   408         pageURL = pageURLOriginal.crossThreadString();

   409 

   410         record = new PageURLRecord(pageURL);

   411         m_pageURLToRecordMap.set(pageURL, record);

   412     }

   413     

   414     if (!record->retain()) {

   415         if (pageURL.isNull())

   416             pageURL = pageURLOriginal.crossThreadString();

   417 

   418         // This page just had its retain count bumped from 0 to 1 - Record that fact

   419         m_retainedPageURLs.add(pageURL);

   420 

   421         // If we read the iconURLs yet, we want to avoid any pageURL->iconURL lookups and the pageURLsPendingDeletion is moot, 

   422         // so we bail here and skip those steps

   423         if (!m_iconURLImportComplete)

   424             return;

   425 

   426         MutexLocker locker(m_pendingSyncLock);

   427         // If this pageURL waiting to be sync'ed, update the sync record

   428         // This saves us in the case where a page was ready to be deleted from the database but was just retained - so theres no need to delete it!

   429         if (!m_privateBrowsingEnabled && m_pageURLsPendingSync.contains(pageURL)) {

   430             LOG(IconDatabase, "Bringing %s back from the brink", pageURL.ascii().data());

   431             m_pageURLsPendingSync.set(pageURL, record->snapshot());

   432         }

   433     }

   434 }

   435 

   436 void IconDatabase::releaseIconForPageURL(const String& pageURLOriginal)

   437 {

   438     ASSERT_NOT_SYNC_THREAD();

   439         

   440     // Cannot do anything with pageURLOriginal that would end up storing it without deep copying first

   441     

   442     if (!isEnabled() || pageURLOriginal.isEmpty())

   443         return;

   444     

   445     MutexLocker locker(m_urlAndIconLock);

   446 

   447     // Check if this pageURL is actually retained

   448     if (!m_retainedPageURLs.contains(pageURLOriginal)) {

   449         LOG_ERROR("Attempting to release icon for URL %s which is not retained", urlForLogging(pageURLOriginal).ascii().data());

   450         return;

   451     }

   452     

   453     // Get its retain count - if it's retained, we'd better have a PageURLRecord for it

   454     PageURLRecord* pageRecord = m_pageURLToRecordMap.get(pageURLOriginal);

   455     ASSERT(pageRecord);

   456     LOG(IconDatabase, "Releasing pageURL %s to a retain count of %i", urlForLogging(pageURLOriginal).ascii().data(), pageRecord->retainCount() - 1);

   457     ASSERT(pageRecord->retainCount() > 0);

   458         

   459     // If it still has a positive retain count, store the new count and bail

   460     if (pageRecord->release())

   461         return;

   462         

   463     // This pageRecord has now been fully released.  Do the appropriate cleanup

   464     LOG(IconDatabase, "No more retainers for PageURL %s", urlForLogging(pageURLOriginal).ascii().data());

   465     m_pageURLToRecordMap.remove(pageURLOriginal);

   466     m_retainedPageURLs.remove(pageURLOriginal);       

   467     

   468     // Grab the iconRecord for later use (and do a sanity check on it for kicks)

   469     IconRecord* iconRecord = pageRecord->iconRecord();

   470     

   471     ASSERT(!iconRecord || (iconRecord && m_iconURLToRecordMap.get(iconRecord->iconURL()) == iconRecord));

   472 

   473     {

   474         MutexLocker locker(m_pendingReadingLock);

   475         

   476         // Since this pageURL is going away, there's no reason anyone would ever be interested in its read results    

   477         if (!m_iconURLImportComplete)

   478             m_pageURLsPendingImport.remove(pageURLOriginal);

   479         m_pageURLsInterestedInIcons.remove(pageURLOriginal);

   480         

   481         // If this icon is down to it's last retainer, we don't care about reading it in from disk anymore

   482         if (iconRecord && iconRecord->hasOneRef()) {

   483             m_iconURLToRecordMap.remove(iconRecord->iconURL());

   484             m_iconsPendingReading.remove(iconRecord);

   485         }

   486     }

   487     

   488     // Mark stuff for deletion from the database only if we're not in private browsing

   489     if (!m_privateBrowsingEnabled) {

   490         MutexLocker locker(m_pendingSyncLock);

   491         m_pageURLsPendingSync.set(pageURLOriginal.crossThreadString(), pageRecord->snapshot(true));

   492     

   493         // If this page is the last page to refer to a particular IconRecord, that IconRecord needs to

   494         // be marked for deletion

   495         if (iconRecord && iconRecord->hasOneRef())

   496             m_iconsPendingSync.set(iconRecord->iconURL(), iconRecord->snapshot(true));

   497     }

   498     

   499     delete pageRecord;

   500 

   501     if (isOpen())

   502         scheduleOrDeferSyncTimer();

   503 }

   504 

   505 void IconDatabase::setIconDataForIconURL(PassRefPtr<SharedBuffer> dataOriginal, const String& iconURLOriginal)

   506 {    

   507     ASSERT_NOT_SYNC_THREAD();

   508     

   509     // Cannot do anything with dataOriginal or iconURLOriginal that would end up storing them without deep copying first

   510     

   511     if (!isOpen() || iconURLOriginal.isEmpty())

   512         return;

   513     

   514     RefPtr<SharedBuffer> data = dataOriginal ? dataOriginal->copy() : 0;

   515     String iconURL = iconURLOriginal.crossThreadString();

   516     

   517     Vector<String> pageURLs;

   518     {

   519         MutexLocker locker(m_urlAndIconLock);

   520     

   521         // If this icon was pending a read, remove it from that set because this new data should override what is on disk

   522         RefPtr<IconRecord> icon = m_iconURLToRecordMap.get(iconURL);

   523         if (icon) {

   524             MutexLocker locker(m_pendingReadingLock);

   525             m_iconsPendingReading.remove(icon.get());

   526         } else

   527             icon = getOrCreateIconRecord(iconURL);

   528     

   529         // Update the data and set the time stamp

   530         icon->setImageData(data);

   531         icon->setTimestamp((int)currentTime());

   532         

   533         // Copy the current retaining pageURLs - if any - to notify them of the change

   534         pageURLs.appendRange(icon->retainingPageURLs().begin(), icon->retainingPageURLs().end());

   535         

   536         // Mark the IconRecord as requiring an update to the database only if private browsing is disabled

   537         if (!m_privateBrowsingEnabled) {

   538             MutexLocker locker(m_pendingSyncLock);

   539             m_iconsPendingSync.set(iconURL, icon->snapshot());

   540         }

   541 

   542         if (icon->hasOneRef()) {

   543             ASSERT(icon->retainingPageURLs().isEmpty());

   544             LOG(IconDatabase, "Icon for icon url %s is about to be destroyed - removing mapping for it", urlForLogging(icon->iconURL()).ascii().data());

   545             m_iconURLToRecordMap.remove(icon->iconURL());

   546         }

   547     }

   548 

   549     // Send notification out regarding all PageURLs that retain this icon

   550     // But not if we're on the sync thread because that implies this mapping

   551     // comes from the initial import which we don't want notifications for

   552     if (!IS_ICON_SYNC_THREAD()) {

   553         // Start the timer to commit this change - or further delay the timer if it was already started

   554         scheduleOrDeferSyncTimer();

   555 

   556         // Informal testing shows that draining the autorelease pool every 25 iterations is about as low as we can go

   557         // before performance starts to drop off, but we don't want to increase this number because then accumulated memory usage will go up        

   558         AutodrainedPool pool(25);

   559 

   560         for (unsigned i = 0; i < pageURLs.size(); ++i) {

   561             LOG(IconDatabase, "Dispatching notification that retaining pageURL %s has a new icon", urlForLogging(pageURLs[i]).ascii().data());

   562             m_client->dispatchDidAddIconForPageURL(pageURLs[i]);

   563 

   564             pool.cycle();

   565         }

   566     }

   567 }

   568 

   569 void IconDatabase::setIconURLForPageURL(const String& iconURLOriginal, const String& pageURLOriginal)

   570 {    

   571     ASSERT_NOT_SYNC_THREAD();

   572 

   573     // Cannot do anything with iconURLOriginal or pageURLOriginal that would end up storing them without deep copying first

   574     

   575     ASSERT(!iconURLOriginal.isEmpty());

   576         

   577     if (!isOpen() || pageURLOriginal.isEmpty())

   578         return;

   579     

   580     String iconURL, pageURL;

   581     

   582     {

   583         MutexLocker locker(m_urlAndIconLock);

   584 

   585         PageURLRecord* pageRecord = m_pageURLToRecordMap.get(pageURLOriginal);

   586         

   587         // If the urls already map to each other, bail.

   588         // This happens surprisingly often, and seems to cream iBench performance

   589         if (pageRecord && pageRecord->iconRecord() && pageRecord->iconRecord()->iconURL() == iconURLOriginal)

   590             return;

   591             

   592         pageURL = pageURLOriginal.crossThreadString();

   593         iconURL = iconURLOriginal.crossThreadString();

   594 

   595         if (!pageRecord) {

   596             pageRecord = new PageURLRecord(pageURL);

   597             m_pageURLToRecordMap.set(pageURL, pageRecord);

   598         }

   599 

   600         RefPtr<IconRecord> iconRecord = pageRecord->iconRecord();

   601 

   602         // Otherwise, set the new icon record for this page

   603         pageRecord->setIconRecord(getOrCreateIconRecord(iconURL));

   604 

   605         // If the current icon has only a single ref left, it is about to get wiped out. 

   606         // Remove it from the in-memory records and don't bother reading it in from disk anymore

   607         if (iconRecord && iconRecord->hasOneRef()) {

   608             ASSERT(iconRecord->retainingPageURLs().size() == 0);

   609             LOG(IconDatabase, "Icon for icon url %s is about to be destroyed - removing mapping for it", urlForLogging(iconRecord->iconURL()).ascii().data());

   610             m_iconURLToRecordMap.remove(iconRecord->iconURL());

   611             MutexLocker locker(m_pendingReadingLock);

   612             m_iconsPendingReading.remove(iconRecord.get());

   613         }

   614         

   615         // And mark this mapping to be added to the database

   616         if (!m_privateBrowsingEnabled) {

   617             MutexLocker locker(m_pendingSyncLock);

   618             m_pageURLsPendingSync.set(pageURL, pageRecord->snapshot());

   619             

   620             // If the icon is on its last ref, mark it for deletion

   621             if (iconRecord && iconRecord->hasOneRef())

   622                 m_iconsPendingSync.set(iconRecord->iconURL(), iconRecord->snapshot(true));

   623         }

   624     }

   625 

   626     // Since this mapping is new, send the notification out - but not if we're on the sync thread because that implies this mapping

   627     // comes from the initial import which we don't want notifications for

   628     if (!IS_ICON_SYNC_THREAD()) {

   629         // Start the timer to commit this change - or further delay the timer if it was already started

   630         scheduleOrDeferSyncTimer();

   631         

   632         LOG(IconDatabase, "Dispatching notification that we changed an icon mapping for url %s", urlForLogging(pageURL).ascii().data());

   633         AutodrainedPool pool;

   634         m_client->dispatchDidAddIconForPageURL(pageURL);

   635     }

   636 }

   637 

   638 IconLoadDecision IconDatabase::loadDecisionForIconURL(const String& iconURL, DocumentLoader* notificationDocumentLoader)

   639 {

   640     ASSERT_NOT_SYNC_THREAD();

   641 

   642     if (!isOpen() || iconURL.isEmpty())

   643         return IconLoadNo;

   644     

   645     // If we have a IconRecord, it should also have its timeStamp marked because there is only two times when we create the IconRecord:

   646     // 1 - When we read the icon urls from disk, getting the timeStamp at the same time

   647     // 2 - When we get a new icon from the loader, in which case the timestamp is set at that time

   648     {

   649         MutexLocker locker(m_urlAndIconLock);

   650         if (IconRecord* icon = m_iconURLToRecordMap.get(iconURL)) {

   651             LOG(IconDatabase, "Found expiration time on a present icon based on existing IconRecord");

   652             return (int)currentTime() - icon->getTimestamp() > iconExpirationTime ? IconLoadYes : IconLoadNo;

   653         }

   654     }

   655     

   656     // If we don't have a record for it, but we *have* imported all iconURLs from disk, then we should load it now

   657     MutexLocker readingLocker(m_pendingReadingLock);

   658     if (m_iconURLImportComplete)

   659         return IconLoadYes;

   660         

   661     // Otherwise - since we refuse to perform I/O on the main thread to find out for sure - we return the answer that says

   662     // "You might be asked to load this later, so flag that"

   663     LOG(IconDatabase, "Don't know if we should load %s or not - adding %p to the set of document loaders waiting on a decision", iconURL.ascii().data(), notificationDocumentLoader);

   664     m_loadersPendingDecision.add(notificationDocumentLoader);    

   665 

   666     return IconLoadUnknown;

   667 }

   668 

   669 bool IconDatabase::iconDataKnownForIconURL(const String& iconURL)

   670 {

   671     ASSERT_NOT_SYNC_THREAD();

   672     

   673     MutexLocker locker(m_urlAndIconLock);

   674     if (IconRecord* icon = m_iconURLToRecordMap.get(iconURL))

   675         return icon->imageDataStatus() != ImageDataStatusUnknown;

   676 

   677     return false;

   678 }

   679 

   680 void IconDatabase::setEnabled(bool enabled)

   681 {

   682     ASSERT_NOT_SYNC_THREAD();

   683     

   684     if (!enabled && isOpen())

   685         close();

   686     m_isEnabled = enabled;

   687 }

   688 

   689 bool IconDatabase::isEnabled() const

   690 {

   691     ASSERT_NOT_SYNC_THREAD();

   692     

   693      return m_isEnabled;

   694 }

   695 

   696 void IconDatabase::setPrivateBrowsingEnabled(bool flag)

   697 {

   698     m_privateBrowsingEnabled = flag;

   699 }

   700 

   701 bool IconDatabase::isPrivateBrowsingEnabled() const

   702 {

   703     return m_privateBrowsingEnabled;

   704 }

   705 

   706 void IconDatabase::delayDatabaseCleanup()

   707 {

   708     ++databaseCleanupCounter;

   709     if (databaseCleanupCounter == 1)

   710         LOG(IconDatabase, "Database cleanup is now DISABLED");

   711 }

   712 

   713 void IconDatabase::allowDatabaseCleanup()

   714 {

   715     if (--databaseCleanupCounter < 0)

   716         databaseCleanupCounter = 0;

   717     if (databaseCleanupCounter == 0)

   718         LOG(IconDatabase, "Database cleanup is now ENABLED");

   719 }

   720 

   721 void IconDatabase::checkIntegrityBeforeOpening()

   722 {

   723     checkIntegrityOnOpen = true;

   724 }

   725 

   726 size_t IconDatabase::pageURLMappingCount()

   727 {

   728     MutexLocker locker(m_urlAndIconLock);

   729     return m_pageURLToRecordMap.size();

   730 }

   731 

   732 size_t IconDatabase::retainedPageURLCount()

   733 {

   734     MutexLocker locker(m_urlAndIconLock);

   735     return m_retainedPageURLs.size();

   736 }

   737 

   738 size_t IconDatabase::iconRecordCount()

   739 {

   740     MutexLocker locker(m_urlAndIconLock);

   741     return m_iconURLToRecordMap.size();

   742 }

   743 

   744 size_t IconDatabase::iconRecordCountWithData()

   745 {

   746     MutexLocker locker(m_urlAndIconLock);

   747     size_t result = 0;

   748     

   749     HashMap<String, IconRecord*>::iterator i = m_iconURLToRecordMap.begin();

   750     HashMap<String, IconRecord*>::iterator end = m_iconURLToRecordMap.end();

   751     

   752     for (; i != end; ++i)

   753         result += ((*i).second->imageDataStatus() == ImageDataStatusPresent);

   754             

   755     return result;

   756 }

   757 

   758 IconDatabase::IconDatabase()

   759     : m_syncTimer(this, &IconDatabase::syncTimerFired)

   760     , m_syncThreadRunning(false)

   761     , m_isEnabled(false)

   762     , m_privateBrowsingEnabled(false)

   763     , m_threadTerminationRequested(false)

   764     , m_removeIconsRequested(false)

   765     , m_iconURLImportComplete(false)

   766     , m_initialPruningComplete(false)

   767     , m_client(defaultClient())

   768     , m_imported(false)

   769     , m_isImportedSet(false)

   770 {

   771     ASSERT(isMainThread());

   772 }

   773 

   774 IconDatabase::~IconDatabase()

   775 {

   776     ASSERT_NOT_REACHED();

   777 }

   778 

   779 void IconDatabase::notifyPendingLoadDecisionsOnMainThread(void* context)

   780 {

   781     static_cast<IconDatabase*>(context)->notifyPendingLoadDecisions();

   782 }

   783 

   784 void IconDatabase::notifyPendingLoadDecisions()

   785 {

   786     ASSERT_NOT_SYNC_THREAD();

   787     

   788     // This method should only be called upon completion of the initial url import from the database

   789     ASSERT(m_iconURLImportComplete);

   790     LOG(IconDatabase, "Notifying all DocumentLoaders that were waiting on a load decision for thier icons");

   791     

   792     HashSet<RefPtr<DocumentLoader> >::iterator i = m_loadersPendingDecision.begin();

   793     HashSet<RefPtr<DocumentLoader> >::iterator end = m_loadersPendingDecision.end();

   794     

   795     for (; i != end; ++i)

   796         if ((*i)->refCount() > 1)

   797             (*i)->iconLoadDecisionAvailable();

   798             

   799     m_loadersPendingDecision.clear();

   800 }

   801 

   802 void IconDatabase::wakeSyncThread()

   803 {

   804     // The following is balanced by the call to enableSuddenTermination in the

   805     // syncThreadMainLoop function.

   806     // FIXME: It would be better to only disable sudden termination if we have

   807     // something to write, not just if we have something to read.

   808     disableSuddenTermination();

   809 

   810     MutexLocker locker(m_syncLock);

   811     m_syncCondition.signal();

   812 }

   813 

   814 void IconDatabase::scheduleOrDeferSyncTimer()

   815 {

   816     ASSERT_NOT_SYNC_THREAD();

   817 

   818     if (!m_syncTimer.isActive()) {

   819         // The following is balanced by the call to enableSuddenTermination in the

   820         // syncTimerFired function.

   821         disableSuddenTermination();

   822     }

   823 

   824     m_syncTimer.startOneShot(updateTimerDelay);

   825 }

   826 

   827 void IconDatabase::syncTimerFired(Timer<IconDatabase>*)

   828 {

   829     ASSERT_NOT_SYNC_THREAD();

   830     wakeSyncThread();

   831 

   832     // The following is balanced by the call to disableSuddenTermination in the

   833     // scheduleOrDeferSyncTimer function.

   834     enableSuddenTermination();

   835 }

   836 

   837 // ******************

   838 // *** Any Thread ***

   839 // ******************

   840 

   841 bool IconDatabase::isOpen() const

   842 {

   843     MutexLocker locker(m_syncLock);

   844     return m_syncDB.isOpen();

   845 }

   846 

   847 String IconDatabase::databasePath() const

   848 {

   849     MutexLocker locker(m_syncLock);

   850     return m_completeDatabasePath.threadsafeCopy();

   851 }

   852 

   853 String IconDatabase::defaultDatabaseFilename()

   854 {

   855     DEFINE_STATIC_LOCAL(String, defaultDatabaseFilename, ("WebpageIcons.db"));

   856     return defaultDatabaseFilename.threadsafeCopy();

   857 }

   858 

   859 // Unlike getOrCreatePageURLRecord(), getOrCreateIconRecord() does not mark the icon as "interested in import"

   860 PassRefPtr<IconRecord> IconDatabase::getOrCreateIconRecord(const String& iconURL)

   861 {

   862     // Clients of getOrCreateIconRecord() are required to acquire the m_urlAndIconLock before calling this method

   863     ASSERT(!m_urlAndIconLock.tryLock());

   864 

   865     if (IconRecord* icon = m_iconURLToRecordMap.get(iconURL))

   866         return icon;

   867 

   868     RefPtr<IconRecord> newIcon = IconRecord::create(iconURL);

   869     m_iconURLToRecordMap.set(iconURL, newIcon.get());

   870 

   871     return newIcon.release();

   872 }

   873 

   874 // This method retrieves the existing PageURLRecord, or creates a new one and marks it as "interested in the import" for later notification

   875 PageURLRecord* IconDatabase::getOrCreatePageURLRecord(const String& pageURL)

   876 {

   877     // Clients of getOrCreatePageURLRecord() are required to acquire the m_urlAndIconLock before calling this method

   878     ASSERT(!m_urlAndIconLock.tryLock());

   879 

   880     if (pageURL.isEmpty())

   881         return 0;

   882 

   883     PageURLRecord* pageRecord = m_pageURLToRecordMap.get(pageURL);

   884     

   885     MutexLocker locker(m_pendingReadingLock);

   886     if (!m_iconURLImportComplete) {

   887         // If the initial import of all URLs hasn't completed and we have no page record, we assume we *might* know about this later and create a record for it

   888         if (!pageRecord) {

   889             LOG(IconDatabase, "Creating new PageURLRecord for pageURL %s", urlForLogging(pageURL).ascii().data());

   890             pageRecord = new PageURLRecord(pageURL);

   891             m_pageURLToRecordMap.set(pageURL, pageRecord);

   892         }

   893 

   894         // If the pageRecord for this page does not have an iconRecord attached to it, then it is a new pageRecord still awaiting the initial import

   895         // Mark the URL as "interested in the result of the import" then bail

   896         if (!pageRecord->iconRecord()) {

   897             m_pageURLsPendingImport.add(pageURL);

   898             return 0;

   899         }

   900     }

   901 

   902     // We've done the initial import of all URLs known in the database.  If this record doesn't exist now, it never will    

   903      return pageRecord;

   904 }

   905 

   906 

   907 // ************************

   908 // *** Sync Thread Only ***

   909 // ************************

   910 

   911 void IconDatabase::importIconURLForPageURL(const String& iconURL, const String& pageURL)

   912 {

   913     ASSERT_ICON_SYNC_THREAD();

   914     

   915     // This function is only for setting actual existing url mappings so assert that neither of these URLs are empty

   916     ASSERT(!iconURL.isEmpty() && !pageURL.isEmpty());

   917     

   918     setIconURLForPageURLInSQLDatabase(iconURL, pageURL);    

   919 }

   920 

   921 void IconDatabase::importIconDataForIconURL(PassRefPtr<SharedBuffer> data, const String& iconURL)

   922 {

   923     ASSERT_ICON_SYNC_THREAD();

   924     

   925     ASSERT(!iconURL.isEmpty());

   926 

   927     writeIconSnapshotToSQLDatabase(IconSnapshot(iconURL, (int)currentTime(), data.get()));

   928 }

   929 

   930 bool IconDatabase::shouldStopThreadActivity() const

   931 {

   932     ASSERT_ICON_SYNC_THREAD();

   933     

   934     return m_threadTerminationRequested || m_removeIconsRequested;

   935 }

   936 

   937 void* IconDatabase::iconDatabaseSyncThreadStart(void* vIconDatabase)

   938 {    

   939     IconDatabase* iconDB = static_cast<IconDatabase*>(vIconDatabase);

   940     

   941     return iconDB->iconDatabaseSyncThread();

   942 }

   943 

   944 void* IconDatabase::iconDatabaseSyncThread()

   945 {

   946     // The call to create this thread might not complete before the thread actually starts, so we might fail this ASSERT_ICON_SYNC_THREAD() because the pointer 

   947     // to our thread structure hasn't been filled in yet.

   948     // To fix this, the main thread acquires this lock before creating us, then releases the lock after creation is complete.  A quick lock/unlock cycle here will 

   949     // prevent us from running before that call completes

   950     m_syncLock.lock();

   951     m_syncLock.unlock();

   952 

   953     ASSERT_ICON_SYNC_THREAD();

   954     

   955     LOG(IconDatabase, "(THREAD) IconDatabase sync thread started");

   956 

   957 #ifndef NDEBUG

   958     double startTime = currentTime();

   959 #endif

   960 

   961     // Need to create the database path if it doesn't already exist

   962     makeAllDirectories(m_databaseDirectory);

   963 

   964     // Existence of a journal file is evidence of a previous crash/force quit and automatically qualifies

   965     // us to do an integrity check

   966     String journalFilename = m_completeDatabasePath + "-journal";

   967     if (!checkIntegrityOnOpen) {

   968         AutodrainedPool pool;

   969         checkIntegrityOnOpen = fileExists(journalFilename);

   970     }

   971     

   972     {

   973         MutexLocker locker(m_syncLock);

   974         if (!m_syncDB.open(m_completeDatabasePath)) {

   975             LOG_ERROR("Unable to open icon database at path %s - %s", m_completeDatabasePath.ascii().data(), m_syncDB.lastErrorMsg());

   976             return 0;

   977         }

   978     }

   979     

   980     if (shouldStopThreadActivity())

   981         return syncThreadMainLoop();

   982         

   983 #ifndef NDEBUG

   984     double timeStamp = currentTime();

   985     LOG(IconDatabase, "(THREAD) Open took %.4f seconds", timeStamp - startTime);

   986 #endif    

   987 

   988     performOpenInitialization();

   989     if (shouldStopThreadActivity())

   990         return syncThreadMainLoop();

   991         

   992 #ifndef NDEBUG

   993     double newStamp = currentTime();

   994     LOG(IconDatabase, "(THREAD) performOpenInitialization() took %.4f seconds, now %.4f seconds from thread start", newStamp - timeStamp, newStamp - startTime);

   995     timeStamp = newStamp;

   996 #endif 

   997 

   998     if (!imported()) {

   999         LOG(IconDatabase, "(THREAD) Performing Safari2 import procedure");

  1000         SQLiteTransaction importTransaction(m_syncDB);

  1001         importTransaction.begin();

  1002         

  1003         // Commit the transaction only if the import completes (the import should be atomic)

  1004         if (m_client->performImport()) {

  1005             setImported(true);

  1006             importTransaction.commit();

  1007         } else {

  1008             LOG(IconDatabase, "(THREAD) Safari 2 import was cancelled");

  1009             importTransaction.rollback();

  1010         }

  1011         

  1012         if (shouldStopThreadActivity())

  1013             return syncThreadMainLoop();

  1014             

  1015 #ifndef NDEBUG

  1016         newStamp = currentTime();

  1017         LOG(IconDatabase, "(THREAD) performImport() took %.4f seconds, now %.4f seconds from thread start", newStamp - timeStamp, newStamp - startTime);

  1018         timeStamp = newStamp;

  1019 #endif 

  1020     }

  1021         

  1022     // Uncomment the following line to simulate a long lasting URL import (*HUGE* icon databases, or network home directories)

  1023     // while (currentTime() - timeStamp < 10);

  1024 

  1025     // Read in URL mappings from the database          

  1026     LOG(IconDatabase, "(THREAD) Starting iconURL import");

  1027     performURLImport();

  1028     

  1029     if (shouldStopThreadActivity())

  1030         return syncThreadMainLoop();

  1031 

  1032 #ifndef NDEBUG

  1033     newStamp = currentTime();

  1034     LOG(IconDatabase, "(THREAD) performURLImport() took %.4f seconds.  Entering main loop %.4f seconds from thread start", newStamp - timeStamp, newStamp - startTime);

  1035 #endif 

  1036 

  1037     LOG(IconDatabase, "(THREAD) Beginning sync");

  1038     return syncThreadMainLoop();

  1039 }

  1040 

  1041 static int databaseVersionNumber(SQLiteDatabase& db)

  1042 {

  1043     return SQLiteStatement(db, "SELECT value FROM IconDatabaseInfo WHERE key = 'Version';").getColumnInt(0);

  1044 }

  1045 

  1046 static bool isValidDatabase(SQLiteDatabase& db)

  1047 {

  1048 

  1049     // These four tables should always exist in a valid db

  1050     if (!db.tableExists("IconInfo") || !db.tableExists("IconData") || !db.tableExists("PageURL") || !db.tableExists("IconDatabaseInfo"))

  1051         return false;

  1052     

  1053     if (databaseVersionNumber(db) < currentDatabaseVersion) {

  1054         LOG(IconDatabase, "DB version is not found or below expected valid version");

  1055         return false;

  1056     }

  1057     

  1058     return true;

  1059 }

  1060 

  1061 static void createDatabaseTables(SQLiteDatabase& db)

  1062 {

  1063     if (!db.executeCommand("CREATE TABLE PageURL (url TEXT NOT NULL ON CONFLICT FAIL UNIQUE ON CONFLICT REPLACE,iconID INTEGER NOT NULL ON CONFLICT FAIL);")) {

  1064         LOG_ERROR("Could not create PageURL table in database (%i) - %s", db.lastError(), db.lastErrorMsg());

  1065         db.close();

  1066         return;

  1067     }

  1068     if (!db.executeCommand("CREATE INDEX PageURLIndex ON PageURL (url);")) {

  1069         LOG_ERROR("Could not create PageURL index in database (%i) - %s", db.lastError(), db.lastErrorMsg());

  1070         db.close();

  1071         return;

  1072     }

  1073     if (!db.executeCommand("CREATE TABLE IconInfo (iconID INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE ON CONFLICT REPLACE, url TEXT NOT NULL ON CONFLICT FAIL UNIQUE ON CONFLICT FAIL, stamp INTEGER);")) {

  1074         LOG_ERROR("Could not create IconInfo table in database (%i) - %s", db.lastError(), db.lastErrorMsg());

  1075         db.close();

  1076         return;

  1077     }

  1078     if (!db.executeCommand("CREATE INDEX IconInfoIndex ON IconInfo (url, iconID);")) {

  1079         LOG_ERROR("Could not create PageURL index in database (%i) - %s", db.lastError(), db.lastErrorMsg());

  1080         db.close();

  1081         return;

  1082     }

  1083     if (!db.executeCommand("CREATE TABLE IconData (iconID INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE ON CONFLICT REPLACE, data BLOB);")) {

  1084         LOG_ERROR("Could not create IconData table in database (%i) - %s", db.lastError(), db.lastErrorMsg());

  1085         db.close();

  1086         return;

  1087     }

  1088     if (!db.executeCommand("CREATE INDEX IconDataIndex ON IconData (iconID);")) {

  1089         LOG_ERROR("Could not create PageURL index in database (%i) - %s", db.lastError(), db.lastErrorMsg());

  1090         db.close();

  1091         return;

  1092     }

  1093     if (!db.executeCommand("CREATE TABLE IconDatabaseInfo (key TEXT NOT NULL ON CONFLICT FAIL UNIQUE ON CONFLICT REPLACE,value TEXT NOT NULL ON CONFLICT FAIL);")) {

  1094         LOG_ERROR("Could not create IconDatabaseInfo table in database (%i) - %s", db.lastError(), db.lastErrorMsg());

  1095         db.close();

  1096         return;

  1097     }

  1098     if (!db.executeCommand(String("INSERT INTO IconDatabaseInfo VALUES ('Version', ") + String::number(currentDatabaseVersion) + ");")) {

  1099         LOG_ERROR("Could not insert icon database version into IconDatabaseInfo table (%i) - %s", db.lastError(), db.lastErrorMsg());

  1100         db.close();

  1101         return;

  1102     }

  1103 }    

  1104 

  1105 void IconDatabase::performOpenInitialization()

  1106 {

  1107     ASSERT_ICON_SYNC_THREAD();

  1108     

  1109     if (!isOpen())

  1110         return;

  1111     

  1112     if (checkIntegrityOnOpen) {

  1113         checkIntegrityOnOpen = false;

  1114         if (!checkIntegrity()) {

  1115             LOG(IconDatabase, "Integrity check was bad - dumping IconDatabase");

  1116 

  1117             m_syncDB.close();

  1118             

  1119             {

  1120                 MutexLocker locker(m_syncLock);

  1121                 // Should've been consumed by SQLite, delete just to make sure we don't see it again in the future;

  1122                 deleteFile(m_completeDatabasePath + "-journal");

  1123                 deleteFile(m_completeDatabasePath);

  1124             }

  1125             

  1126             // Reopen the write database, creating it from scratch

  1127             if (!m_syncDB.open(m_completeDatabasePath)) {

  1128                 LOG_ERROR("Unable to open icon database at path %s - %s", m_completeDatabasePath.ascii().data(), m_syncDB.lastErrorMsg());

  1129                 return;

  1130             }          

  1131         }

  1132     }

  1133     

  1134     int version = databaseVersionNumber(m_syncDB);

  1135