Changeset 109697 in webkit


Ignore:
Timestamp:
Mar 4, 2012 7:23:58 PM (12 years ago)
Author:
commit-queue@webkit.org
Message:

[BlackBerry] Credential backing store implementation
​https://bugs.webkit.org/show_bug.cgi?id=79650

Patch by Jonathan Dong <Jonathan Dong> on 2012-03-04
Reviewed by Antonio Gomes.

Opened Credential database in CedentialBackingStore::instance().
Added never_remember table and associated sql statment
members to store the never remember sites.
Removed CredentialStorage initialize codes because that
won't give users a chance to re-enter the new credential
information for an already stored site.
Changed login update and has statement to support
autofill feature of multiple credential forms in the
same page; Also added url as a parameter of hasLogin() function.
Added calling reset() after each statement calls step(),
to make it work correctly next time.
Also fixed a macro typo in HANDLE_SQL_EXEC_FAILURE.

No new tests.

  • platform/network/blackberry/CredentialBackingStore.cpp:

(WebCore::CredentialBackingStore::instance):
(WebCore::CredentialBackingStore::CredentialBackingStore):
(WebCore::CredentialBackingStore::open):
(WebCore::CredentialBackingStore::close):
(WebCore::CredentialBackingStore::addLogin):
(WebCore::CredentialBackingStore::updateLogin):
(WebCore::CredentialBackingStore::hasLogin):
(WebCore::CredentialBackingStore::getLogin):
(WebCore):
(WebCore::CredentialBackingStore::removeLogin):
(WebCore::CredentialBackingStore::addNeverRemember):
(WebCore::CredentialBackingStore::hasNeverRemember):
(WebCore::CredentialBackingStore::getNeverRemember):
(WebCore::CredentialBackingStore::removeNeverRemember):
(WebCore::CredentialBackingStore::clearLogins):
(WebCore::CredentialBackingStore::clearNeverRemember):

  • platform/network/blackberry/CredentialBackingStore.h:

(CredentialBackingStore):

Location:
trunk/Source/WebCore
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r109696 r109697  
     12012-03-04  Jonathan Dong  <jonathan.dong@torchmobile.com.cn>
     2
     3        [BlackBerry] Credential backing store implementation
     4        https://bugs.webkit.org/show_bug.cgi?id=79650
     5
     6        Reviewed by Antonio Gomes.
     7
     8        Opened Credential database in CedentialBackingStore::instance().
     9        Added never_remember table and associated sql statment
     10        members to store the never remember sites.
     11        Removed CredentialStorage initialize codes because that
     12        won't give users a chance to re-enter the new credential
     13        information for an already stored site.
     14        Changed login update and has statement to support
     15        autofill feature of multiple credential forms in the
     16        same page; Also added url as a parameter of hasLogin() function.
     17        Added calling reset() after each statement calls step(),
     18        to make it work correctly next time.
     19        Also fixed a macro typo in HANDLE_SQL_EXEC_FAILURE.
     20
     21        No new tests.
     22
     23        * platform/network/blackberry/CredentialBackingStore.cpp:
     24        (WebCore::CredentialBackingStore::instance):
     25        (WebCore::CredentialBackingStore::CredentialBackingStore):
     26        (WebCore::CredentialBackingStore::open):
     27        (WebCore::CredentialBackingStore::close):
     28        (WebCore::CredentialBackingStore::addLogin):
     29        (WebCore::CredentialBackingStore::updateLogin):
     30        (WebCore::CredentialBackingStore::hasLogin):
     31        (WebCore::CredentialBackingStore::getLogin):
     32        (WebCore):
     33        (WebCore::CredentialBackingStore::removeLogin):
     34        (WebCore::CredentialBackingStore::addNeverRemember):
     35        (WebCore::CredentialBackingStore::hasNeverRemember):
     36        (WebCore::CredentialBackingStore::getNeverRemember):
     37        (WebCore::CredentialBackingStore::removeNeverRemember):
     38        (WebCore::CredentialBackingStore::clearLogins):
     39        (WebCore::CredentialBackingStore::clearNeverRemember):
     40        * platform/network/blackberry/CredentialBackingStore.h:
     41        (CredentialBackingStore):
     42
    1432012-03-04  Hyowon Kim  <hw1008.kim@samsung.com>
    244

  • trunk/Source/WebCore/platform/network/blackberry/CredentialBackingStore.cpp

    r106234 r109697  
    2323
    2424#include "CredentialStorage.h"
     25#include "FileSystem.h"
    2526#include "KURL.h"
    2627#include "NotImplemented.h"
    2728#include "ProtectionSpaceHash.h"
    2829#include "SQLiteStatement.h"
    29 #include <wtf/UnusedParam.h>
     30#include <BlackBerryPlatformClient.h>
    3031
    3132#define HANDLE_SQL_EXEC_FAILURE(statement, returnValue, ...) \
    3233    if (statement) { \
    33         LOG_ERROR(__VAR_ARGS__); \
     34        LOG_ERROR(__VA_ARGS__); \
    3435        return returnValue; \
    3536    }
    … …  
    4041{
    4142    static CredentialBackingStore* backingStore = 0;
    42     if (!backingStore)
     43    if (!backingStore) {
    4344        backingStore = new CredentialBackingStore;
     45        backingStore->open(pathByAppendingComponent(BlackBerry::Platform::Client::get()->getApplicationDataDirectory().c_str(), "/credentials.db"));
     46    }
    4447    return backingStore;
    4548}
    4649
    4750CredentialBackingStore::CredentialBackingStore()
    48     : m_addStatement(0)
    49     , m_updateStatement(0)
    50     , m_hasStatement(0)
    51     , m_getStatement(0)
    52     , m_removeStatement(0)
     51    : m_addLoginStatement(0)
     52    , m_updateLoginStatement(0)
     53    , m_hasLoginStatement(0)
     54    , m_getLoginStatement(0)
     55    , m_getLoginByURLStatement(0)
     56    , m_removeLoginStatement(0)
     57    , m_addNeverRememberStatement(0)
     58    , m_hasNeverRememberStatement(0)
     59    , m_getNeverRememberStatement(0)
     60    , m_removeNeverRememberStatement(0)
    5361{
    5462}
    … …  
    7280
    7381        // Create index for table logins.
    74         HANDLE_SQL_EXEC_FAILURE(!m_database.executeCommand("CREATE INDEX logins_signon ON logins (host)"),
     82        HANDLE_SQL_EXEC_FAILURE(!m_database.executeCommand("CREATE INDEX logins_index ON logins (host)"),
    7583            false, "Failed to create index for table logins");
    76     } else { // Initiate CredentialStorage.
    77         SQLiteStatement query(m_database, "SELECT origin_url, host, port, service_type, realm, auth_scheme, username, password FROM logins");
    78         HANDLE_SQL_EXEC_FAILURE(query.prepare() != SQLResultOk,
    79             false, "Failed to prepare query statement to initiate CredentialStorage");
    80 
    81         int result = query.step();
    82         while (result == SQLResultRow) {
    83             String strUrl = query.getColumnText(1);
    84             String strHost = query.getColumnText(2);
    85             int intPort = query.getColumnInt(3);
    86             ProtectionSpaceServerType serviceType = static_cast<ProtectionSpaceServerType>(query.getColumnInt(4));
    87             String strRealm = query.getColumnText(5);
    88             ProtectionSpaceAuthenticationScheme authScheme = static_cast<ProtectionSpaceAuthenticationScheme>(query.getColumnInt(6));
    89             String strUserName = query.getColumnText(7);
    90             String strPassword = decryptedString(query.getColumnText(8));
    91 
    92             KURL url(ParsedURLString, strUrl);
    93             ProtectionSpace protectionSpace(strHost, intPort, serviceType, strRealm, authScheme);
    94             Credential credential(strUserName, strPassword, CredentialPersistencePermanent);
    95             CredentialStorage::set(credential, protectionSpace, url);
    96 
    97             result = query.step();
    98         }
    9984    }
    10085
     86    if (!m_database.tableExists("never_remember")) {
     87        HANDLE_SQL_EXEC_FAILURE(!m_database.executeCommand("CREATE TABLE never_remember (origin_url VARCHAR NOT NULL, host VARCHAR NOT NULL, port INTEGER, service_type INTEGER NOT NULL, realm VARCHAR, auth_scheme INTEGER NOT NULL) "),
     88            false, "Failed to create table never_remember for login database");
     89
     90        // Create index for table never_remember.
     91        HANDLE_SQL_EXEC_FAILURE(!m_database.executeCommand("CREATE INDEX never_remember_index ON never_remember (host)"),
     92            false, "Failed to create index for table never_remember");
     93    }
     94
    10195    // Prepare the statements.
    102     m_addStatement = new SQLiteStatement(m_database, "INSERT OR REPLACE INTO logins (origin_url, host, port, service_type, realm, auth_scheme, username, password) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
    103     HANDLE_SQL_EXEC_FAILURE(m_addStatement->prepare() != SQLResultOk,
     96    m_addLoginStatement = new SQLiteStatement(m_database, "INSERT OR REPLACE INTO logins (origin_url, host, port, service_type, realm, auth_scheme, username, password) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
     97    HANDLE_SQL_EXEC_FAILURE(m_addLoginStatement->prepare() != SQLResultOk,
    10498        false, "Failed to prepare addLogin statement");
    10599
    106     m_updateStatement = new SQLiteStatement(m_database, "UPDATE logins SET username = ?, password = ? WHERE origin_url = ? AND host = ? AND port = ? AND service_type = ? AND realm = ? AND auth_scheme = ?");
    107     HANDLE_SQL_EXEC_FAILURE(m_updateStatement->prepare() != SQLResultOk,
     100    m_updateLoginStatement = new SQLiteStatement(m_database, "UPDATE logins SET username = ?, password = ? WHERE origin_url = ? AND host = ? AND port = ? AND service_type = ? AND realm = ? AND auth_scheme = ?");
     101    HANDLE_SQL_EXEC_FAILURE(m_updateLoginStatement->prepare() != SQLResultOk,
    108102        false, "Failed to prepare updateLogin statement");
    109103
    110     m_hasStatement = new SQLiteStatement(m_database, "SELECT COUNT(*) FROM logins WHERE host = ? AND port = ? AND service_type = ? AND realm = ? AND auth_scheme = ?");
    111     HANDLE_SQL_EXEC_FAILURE(m_hasStatement->prepare() != SQLResultOk,
     104    m_hasLoginStatement = new SQLiteStatement(m_database, "SELECT COUNT(*) FROM logins WHERE origin_url = ? AND host = ? AND port = ? AND service_type = ? AND realm = ? AND auth_scheme = ?");
     105    HANDLE_SQL_EXEC_FAILURE(m_hasLoginStatement->prepare() != SQLResultOk,
    112106        false, "Failed to prepare hasLogin statement");
    113107
    114     m_getStatement = new SQLiteStatement(m_database, "SELECT username, password FROM logins WHERE host = ? AND port = ? AND service_type = ? AND realm = ? AND auth_scheme = ?");
    115     HANDLE_SQL_EXEC_FAILURE(m_getStatement->prepare() != SQLResultOk,
     108    m_getLoginStatement = new SQLiteStatement(m_database, "SELECT username, password FROM logins WHERE host = ? AND port = ? AND service_type = ? AND realm = ? AND auth_scheme = ?");
     109    HANDLE_SQL_EXEC_FAILURE(m_getLoginStatement->prepare() != SQLResultOk,
    116110        false, "Failed to prepare getLogin statement");
    117111
    118     m_removeStatement = new SQLiteStatement(m_database, "DELETE FROM logins WHERE host = ? AND port = ? AND service_type = ? AND realm = ? AND auth_scheme = ?");
    119     HANDLE_SQL_EXEC_FAILURE(m_removeStatement->prepare() != SQLResultOk,
     112    m_getLoginByURLStatement = new SQLiteStatement(m_database, "SELECT username, password FROM logins WHERE origin_url = ?");
     113    HANDLE_SQL_EXEC_FAILURE(m_getLoginByURLStatement->prepare() != SQLResultOk,
     114        false, "Failed to prepare getLoginByURL statement");
     115
     116    m_removeLoginStatement = new SQLiteStatement(m_database, "DELETE FROM logins WHERE origin_url = ? AND host = ? AND port = ? AND service_type = ? AND realm = ? AND auth_scheme = ?");
     117    HANDLE_SQL_EXEC_FAILURE(m_removeLoginStatement->prepare() != SQLResultOk,
    120118        false, "Failed to prepare removeLogin statement");
    121119
     120    m_addNeverRememberStatement = new SQLiteStatement(m_database, "INSERT OR REPLACE INTO never_remember (origin_url, host, port, service_type, realm, auth_scheme) VALUES (?, ?, ?, ?, ?, ?)");
     121    HANDLE_SQL_EXEC_FAILURE(m_addNeverRememberStatement->prepare() != SQLResultOk,
     122        false, "Failed to prepare addNeverRemember statement");
     123
     124    m_hasNeverRememberStatement = new SQLiteStatement(m_database, "SELECT COUNT(*) FROM never_remember WHERE host = ? AND port = ? AND service_type = ? AND realm = ? AND auth_scheme = ?");
     125    HANDLE_SQL_EXEC_FAILURE(m_hasNeverRememberStatement->prepare() != SQLResultOk,
     126        false, "Failed to prepare hasNeverRemember statement");
     127
     128    m_getNeverRememberStatement = new SQLiteStatement(m_database, "SELECT origin_url FROM never_remember WHERE host = ? AND port = ? AND service_type = ? AND realm = ? AND auth_scheme = ?");
     129    HANDLE_SQL_EXEC_FAILURE(m_getNeverRememberStatement->prepare() != SQLResultOk,
     130        false, "Failed to prepare getNeverRemember statement");
     131
     132    m_removeNeverRememberStatement = new SQLiteStatement(m_database, "DELETE FROM never_remember WHERE host = ? AND port = ? AND service_type = ? AND realm = ? AND auth_scheme = ?");
     133    HANDLE_SQL_EXEC_FAILURE(m_removeNeverRememberStatement->prepare() != SQLResultOk,
     134        false, "Failed to prepare removeNeverRemember statement");
     135
    122136    return true;
    123137}
    … …  
    125139void CredentialBackingStore::close()
    126140{
    127     delete m_addStatement;
    128     m_addStatement = 0;
    129     delete m_updateStatement;
    130     m_updateStatement = 0;
    131     delete m_hasStatement;
    132     m_hasStatement = 0;
    133     delete m_getStatement;
    134     m_getStatement = 0;
    135     delete m_removeStatement;
    136     m_removeStatement = 0;
     141    delete m_addLoginStatement;
     142    m_addLoginStatement = 0;
     143    delete m_updateLoginStatement;
     144    m_updateLoginStatement = 0;
     145    delete m_hasLoginStatement;
     146    m_hasLoginStatement = 0;
     147    delete m_getLoginStatement;
     148    m_getLoginStatement = 0;
     149    delete m_getLoginByURLStatement;
     150    m_getLoginByURLStatement = 0;
     151    delete m_removeLoginStatement;
     152    m_removeLoginStatement = 0;
     153    delete m_addNeverRememberStatement;
     154    m_addNeverRememberStatement = 0;
     155    delete m_hasNeverRememberStatement;
     156    m_hasNeverRememberStatement = 0;
     157    delete m_getNeverRememberStatement;
     158    m_getNeverRememberStatement = 0;
     159    delete m_removeNeverRememberStatement;
     160    m_removeNeverRememberStatement = 0;
    137161
    138162    if (m_database.isOpen())
    … …  
    145169    ASSERT(m_database.tableExists("logins"));
    146170
    147     if (!m_addStatement)
    148         return false;
    149 
    150     m_addStatement->bindText(1, url.string());
    151     m_addStatement->bindText(2, protectionSpace.host());
    152     m_addStatement->bindInt(3, protectionSpace.port());
    153     m_addStatement->bindInt(4, static_cast<int>(protectionSpace.serverType()));
    154     m_addStatement->bindText(5, protectionSpace.realm());
    155     m_addStatement->bindInt(6, static_cast<int>(protectionSpace.authenticationScheme()));
    156     m_addStatement->bindText(7, credential.user());
    157     m_addStatement->bindBlob(8, encryptedString(credential.password()));
    158 
    159     int result = m_addStatement->step();
     171    if (!m_addLoginStatement)
     172        return false;
     173
     174    m_addLoginStatement->bindText(1, url.string());
     175    m_addLoginStatement->bindText(2, protectionSpace.host());
     176    m_addLoginStatement->bindInt(3, protectionSpace.port());
     177    m_addLoginStatement->bindInt(4, static_cast<int>(protectionSpace.serverType()));
     178    m_addLoginStatement->bindText(5, protectionSpace.realm());
     179    m_addLoginStatement->bindInt(6, static_cast<int>(protectionSpace.authenticationScheme()));
     180    m_addLoginStatement->bindText(7, credential.user());
     181    m_addLoginStatement->bindBlob(8, encryptedString(credential.password()));
     182
     183    int result = m_addLoginStatement->step();
     184    m_addLoginStatement->reset();
    160185    HANDLE_SQL_EXEC_FAILURE(result != SQLResultDone, false,
    161186        "Failed to add login info into table logins - %i", result);
    … …  
    169194    ASSERT(m_database.tableExists("logins"));
    170195
    171     if (!m_updateStatement)
    172         return false;
    173 
    174     m_updateStatement->bindText(1, url.string());
    175     m_updateStatement->bindText(2, credential.user());
    176     m_updateStatement->bindBlob(3, encryptedString(credential.password()));
    177     m_updateStatement->bindText(4, protectionSpace.host());
    178     m_updateStatement->bindInt(5, protectionSpace.port());
    179     m_updateStatement->bindInt(6, static_cast<int>(protectionSpace.serverType()));
    180     m_updateStatement->bindText(7, protectionSpace.realm());
    181     m_updateStatement->bindInt(8, static_cast<int>(protectionSpace.authenticationScheme()));
    182 
    183     int result = m_updateStatement->step();
     196    if (!m_updateLoginStatement)
     197        return false;
     198
     199    m_updateLoginStatement->bindText(1, credential.user());
     200    m_updateLoginStatement->bindBlob(2, encryptedString(credential.password()));
     201    m_updateLoginStatement->bindText(3, url.string());
     202    m_updateLoginStatement->bindText(4, protectionSpace.host());
     203    m_updateLoginStatement->bindInt(5, protectionSpace.port());
     204    m_updateLoginStatement->bindInt(6, static_cast<int>(protectionSpace.serverType()));
     205    m_updateLoginStatement->bindText(7, protectionSpace.realm());
     206    m_updateLoginStatement->bindInt(8, static_cast<int>(protectionSpace.authenticationScheme()));
     207
     208    int result = m_updateLoginStatement->step();
     209    m_updateLoginStatement->reset();
    184210    HANDLE_SQL_EXEC_FAILURE(result != SQLResultDone, false,
    185211        "Failed to update login info in table logins - %i", result);
    … …  
    188214}
    189215
    190 bool CredentialBackingStore::hasLogin(const ProtectionSpace& protectionSpace)
    191 {
    192     ASSERT(m_database.isOpen());
    193     ASSERT(m_database.tableExists("logins"));
    194 
    195     if (!m_hasStatement)
    196         return false;
    197 
    198     m_hasStatement->bindText(1, protectionSpace.host());
    199     m_hasStatement->bindInt(2, protectionSpace.port());
    200     m_hasStatement->bindInt(3, static_cast<int>(protectionSpace.serverType()));
    201     m_hasStatement->bindText(4, protectionSpace.realm());
    202     m_hasStatement->bindInt(5, static_cast<int>(protectionSpace.authenticationScheme()));
    203 
    204     int result = m_hasStatement->step();
     216bool CredentialBackingStore::hasLogin(const KURL& url, const ProtectionSpace& protectionSpace)
     217{
     218    ASSERT(m_database.isOpen());
     219    ASSERT(m_database.tableExists("logins"));
     220
     221    if (!m_hasLoginStatement)
     222        return false;
     223
     224    m_hasLoginStatement->bindText(1, url.string());
     225    m_hasLoginStatement->bindText(2, protectionSpace.host());
     226    m_hasLoginStatement->bindInt(3, protectionSpace.port());
     227    m_hasLoginStatement->bindInt(4, static_cast<int>(protectionSpace.serverType()));
     228    m_hasLoginStatement->bindText(5, protectionSpace.realm());
     229    m_hasLoginStatement->bindInt(6, static_cast<int>(protectionSpace.authenticationScheme()));
     230
     231    int result = m_hasLoginStatement->step();
     232    int numOfRow = m_hasLoginStatement->getColumnInt(0);
     233    m_hasLoginStatement->reset();
    205234    HANDLE_SQL_EXEC_FAILURE(result != SQLResultRow, false,
    206235        "Failed to execute select login info from table logins in hasLogin - %i", result);
    207236
    208     if (m_hasStatement->getColumnInt(0))
     237    if (numOfRow)
    209238        return true;
    210239    return false;
    … …  
    216245    ASSERT(m_database.tableExists("logins"));
    217246
    218     if (!m_getStatement)
     247    if (!m_getLoginStatement)
    219248        return Credential();
    220249
    221     m_getStatement->bindText(1, protectionSpace.host());
    222     m_getStatement->bindInt(2, protectionSpace.port());
    223     m_getStatement->bindInt(3, static_cast<int>(protectionSpace.serverType()));
    224     m_getStatement->bindText(4, protectionSpace.realm());
    225     m_getStatement->bindInt(5, static_cast<int>(protectionSpace.authenticationScheme()));
    226 
    227     int result = m_getStatement->step();
     250    m_getLoginStatement->bindText(1, protectionSpace.host());
     251    m_getLoginStatement->bindInt(2, protectionSpace.port());
     252    m_getLoginStatement->bindInt(3, static_cast<int>(protectionSpace.serverType()));
     253    m_getLoginStatement->bindText(4, protectionSpace.realm());
     254    m_getLoginStatement->bindInt(5, static_cast<int>(protectionSpace.authenticationScheme()));
     255
     256    int result = m_getLoginStatement->step();
     257    String username = m_getLoginStatement->getColumnText(0);
     258    String password = m_getLoginStatement->getColumnBlobAsString(1);
     259    m_getLoginStatement->reset();
    228260    HANDLE_SQL_EXEC_FAILURE(result != SQLResultRow, Credential(),
    229261        "Failed to execute select login info from table logins in getLogin - %i", result);
    230262
    231     return Credential(m_getStatement->getColumnText(0), decryptedString(m_getStatement->getColumnText(1)), CredentialPersistencePermanent);
    232 }
    233 
    234 bool CredentialBackingStore::removeLogin(const ProtectionSpace& protectionSpace)
    235 {
    236     ASSERT(m_database.isOpen());
    237     ASSERT(m_database.tableExists("logins"));
    238 
    239     if (!m_removeStatement)
    240         return false;
    241 
    242     m_removeStatement->bindText(1, protectionSpace.host());
    243     m_removeStatement->bindInt(2, protectionSpace.port());
    244     m_removeStatement->bindInt(3, static_cast<int>(protectionSpace.serverType()));
    245     m_removeStatement->bindText(4, protectionSpace.realm());
    246     m_removeStatement->bindInt(5, static_cast<int>(protectionSpace.authenticationScheme()));
    247 
    248     int result = m_removeStatement->step();
     263    return Credential(username, decryptedString(password), CredentialPersistencePermanent);
     264}
     265
     266Credential CredentialBackingStore::getLogin(const KURL& url)
     267{
     268    ASSERT(m_database.isOpen());
     269    ASSERT(m_database.tableExists("logins"));
     270
     271    if (!m_getLoginByURLStatement)
     272        return Credential();
     273
     274    m_getLoginByURLStatement->bindText(1, url.string());
     275
     276    int result = m_getLoginByURLStatement->step();
     277    String username = m_getLoginByURLStatement->getColumnText(0);
     278    String password = m_getLoginByURLStatement->getColumnBlobAsString(1);
     279    m_getLoginByURLStatement->reset();
     280    HANDLE_SQL_EXEC_FAILURE(result != SQLResultRow, Credential(),
     281        "Failed to execute select login info from table logins in getLogin - %i", result);
     282
     283    return Credential(username, decryptedString(password), CredentialPersistencePermanent);
     284}
     285
     286bool CredentialBackingStore::removeLogin(const KURL& url, const ProtectionSpace& protectionSpace)
     287{
     288    ASSERT(m_database.isOpen());
     289    ASSERT(m_database.tableExists("logins"));
     290
     291    if (!m_removeLoginStatement)
     292        return false;
     293
     294    m_removeLoginStatement->bindText(1, url.string());
     295    m_removeLoginStatement->bindText(2, protectionSpace.host());
     296    m_removeLoginStatement->bindInt(3, protectionSpace.port());
     297    m_removeLoginStatement->bindInt(4, static_cast<int>(protectionSpace.serverType()));
     298    m_removeLoginStatement->bindText(5, protectionSpace.realm());
     299    m_removeLoginStatement->bindInt(6, static_cast<int>(protectionSpace.authenticationScheme()));
     300
     301    int result = m_removeLoginStatement->step();
     302    m_removeLoginStatement->reset();
    249303    HANDLE_SQL_EXEC_FAILURE(result != SQLResultDone, false,
    250304        "Failed to remove login info from table logins - %i", result);
    … …  
    253307}
    254308
    255 bool CredentialBackingStore::clear()
     309bool CredentialBackingStore::addNeverRemember(const KURL& url, const ProtectionSpace& protectionSpace)
     310{
     311    ASSERT(m_database.isOpen());
     312    ASSERT(m_database.tableExists("never_remember"));
     313
     314    if (!m_addNeverRememberStatement)
     315        return false;
     316
     317    m_addNeverRememberStatement->bindText(1, url.string());
     318    m_addNeverRememberStatement->bindText(2, protectionSpace.host());
     319    m_addNeverRememberStatement->bindInt(3, protectionSpace.port());
     320    m_addNeverRememberStatement->bindInt(4, static_cast<int>(protectionSpace.serverType()));
     321    m_addNeverRememberStatement->bindText(5, protectionSpace.realm());
     322    m_addNeverRememberStatement->bindInt(6, static_cast<int>(protectionSpace.authenticationScheme()));
     323
     324    int result = m_addNeverRememberStatement->step();
     325    m_addNeverRememberStatement->reset();
     326    HANDLE_SQL_EXEC_FAILURE(result != SQLResultDone, false,
     327        "Failed to add naver saved item info into table never_remember - %i", result);
     328
     329    return true;
     330}
     331
     332bool CredentialBackingStore::hasNeverRemember(const ProtectionSpace& protectionSpace)
     333{
     334    ASSERT(m_database.isOpen());
     335    ASSERT(m_database.tableExists("never_remember"));
     336
     337    if (!m_hasNeverRememberStatement)
     338        return false;
     339
     340    m_hasNeverRememberStatement->bindText(1, protectionSpace.host());
     341    m_hasNeverRememberStatement->bindInt(2, protectionSpace.port());
     342    m_hasNeverRememberStatement->bindInt(3, static_cast<int>(protectionSpace.serverType()));
     343    m_hasNeverRememberStatement->bindText(4, protectionSpace.realm());
     344    m_hasNeverRememberStatement->bindInt(5, static_cast<int>(protectionSpace.authenticationScheme()));
     345
     346    int result = m_hasNeverRememberStatement->step();
     347    int numOfRow = m_hasNeverRememberStatement->getColumnInt(0);
     348    m_hasNeverRememberStatement->reset();
     349    HANDLE_SQL_EXEC_FAILURE(result != SQLResultRow, false,
     350        "Failed to execute select to find naver saved site from table never_remember - %i", result);
     351
     352    if (numOfRow)
     353        return true;
     354    return false;
     355}
     356
     357KURL CredentialBackingStore::getNeverRemember(const ProtectionSpace& protectionSpace)
     358{
     359    ASSERT(m_database.isOpen());
     360    ASSERT(m_database.tableExists("never_remember"));
     361
     362    if (!m_getNeverRememberStatement)
     363        return KURL();
     364
     365    m_getNeverRememberStatement->bindText(1, protectionSpace.host());
     366    m_getNeverRememberStatement->bindInt(2, protectionSpace.port());
     367    m_getNeverRememberStatement->bindInt(3, static_cast<int>(protectionSpace.serverType()));
     368    m_getNeverRememberStatement->bindText(4, protectionSpace.realm());
     369    m_getNeverRememberStatement->bindInt(5, static_cast<int>(protectionSpace.authenticationScheme()));
     370
     371    int result = m_getNeverRememberStatement->step();
     372    String url = m_getNeverRememberStatement->getColumnText(0);
     373    m_getNeverRememberStatement->reset();
     374    HANDLE_SQL_EXEC_FAILURE(result != SQLResultRow, KURL(),
     375        "Failed to execute select never saved site info from table never_remember in getNeverRemember - %i", result);
     376
     377    return KURL(ParsedURLString, url);
     378}
     379
     380bool CredentialBackingStore::removeNeverRemember(const ProtectionSpace& protectionSpace)
     381{
     382    ASSERT(m_database.isOpen());
     383    ASSERT(m_database.tableExists("never_remember"));
     384
     385    if (!m_removeNeverRememberStatement)
     386        return false;
     387
     388    m_removeNeverRememberStatement->bindText(1, protectionSpace.host());
     389    m_removeNeverRememberStatement->bindInt(2, protectionSpace.port());
     390    m_removeNeverRememberStatement->bindInt(3, static_cast<int>(protectionSpace.serverType()));
     391    m_removeNeverRememberStatement->bindText(4, protectionSpace.realm());
     392    m_removeNeverRememberStatement->bindInt(5, static_cast<int>(protectionSpace.authenticationScheme()));
     393
     394    int result = m_removeNeverRememberStatement->step();
     395    m_removeNeverRememberStatement->reset();
     396    HANDLE_SQL_EXEC_FAILURE(result != SQLResultDone, false,
     397        "Failed to remove never saved site from table never_remember - %i", result);
     398
     399    return true;
     400}
     401
     402bool CredentialBackingStore::clearLogins()
    256403{
    257404    ASSERT(m_database.isOpen());
    … …  
    260407    HANDLE_SQL_EXEC_FAILURE(!m_database.executeCommand("DELETE * FROM logins"),
    261408        false, "Failed to clear table logins");
     409
     410    return true;
     411}
     412
     413bool CredentialBackingStore::clearNeverRemember()
     414{
     415    ASSERT(m_database.isOpen());
     416    ASSERT(m_database.tableExists("never_remember"));
     417
     418    HANDLE_SQL_EXEC_FAILURE(!m_database.executeCommand("DELETE * FROM never_remember"),
     419        false, "Failed to clear table never_remember");
    262420
    263421    return true;

  • trunk/Source/WebCore/platform/network/blackberry/CredentialBackingStore.h

    r101668 r109697  
    3838    bool addLogin(const KURL&, const ProtectionSpace&, const Credential&);
    3939    bool updateLogin(const KURL&, const ProtectionSpace&, const Credential&);
    40     bool hasLogin(const ProtectionSpace&);
     40    bool hasLogin(const KURL&, const ProtectionSpace&);
    4141    Credential getLogin(const ProtectionSpace&);
    42     bool removeLogin(const ProtectionSpace&);
    43     bool clear();
     42    Credential getLogin(const KURL&);
     43    bool removeLogin(const KURL&, const ProtectionSpace&);
     44    bool addNeverRemember(const KURL&, const ProtectionSpace&);
     45    bool hasNeverRemember(const ProtectionSpace&);
     46    KURL getNeverRemember(const ProtectionSpace&);
     47    bool removeNeverRemember(const ProtectionSpace&);
     48    bool clearLogins();
     49    bool clearNeverRemember();
    4450
    4551private:
    … …  
    4955
    5056    SQLiteDatabase m_database;
    51     SQLiteStatement* m_addStatement;
    52     SQLiteStatement* m_updateStatement;
    53     SQLiteStatement* m_hasStatement;
    54     SQLiteStatement* m_getStatement;
    55     SQLiteStatement* m_removeStatement;
     57    SQLiteStatement* m_addLoginStatement;
     58    SQLiteStatement* m_updateLoginStatement;
     59    SQLiteStatement* m_hasLoginStatement;
     60    SQLiteStatement* m_getLoginStatement;
     61    SQLiteStatement* m_getLoginByURLStatement;
     62    SQLiteStatement* m_removeLoginStatement;
     63    SQLiteStatement* m_addNeverRememberStatement;
     64    SQLiteStatement* m_hasNeverRememberStatement;
     65    SQLiteStatement* m_getNeverRememberStatement;
     66    SQLiteStatement* m_removeNeverRememberStatement;
    5667};
    5768
Note: See TracChangeset for help on using the changeset viewer.