Merge 143347

Source/WebCore/Modules/indexeddb/IDBLevelDBCoding.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 317 matching lines @@
     Vector<char> ret = encodeVarInt(s.length());
     ret.append(encodeString(s));
     return ret;
 }
 
 const char* decodeStringWithLength(const char* p, const char* limit, String& foundString)
 {
     ASSERT(limit >= p);
     int64_t len;
     p = decodeVarInt(p, limit, len);
-    if (!p)
-        return 0;
-    if (p + len * 2 > limit)
+    if (!p || len < 0 || p + len * 2 > limit)
         return 0;
 
     foundString = decodeString(p, p + len * 2);
     p += len * 2;
     return p;
 }
 
-int compareEncodedStringsWithLength(const char*& p, const char* limitP, const char*& q, const char* limitQ)
+int compareEncodedStringsWithLength(const char*& p, const char* limitP, const char*& q, const char* limitQ, bool& ok)
 {
     ASSERT(&p != &q);
     ASSERT(limitP >= p);
     ASSERT(limitQ >= q);
     int64_t lenP, lenQ;
     p = decodeVarInt(p, limitP, lenP);
     q = decodeVarInt(q, limitQ, lenQ);
+    if (!p || !q || lenP < 0 || lenQ < 0) {
+        ok = false;
+        return 0;
+    }
     ASSERT(p && q);
     ASSERT(lenP >= 0);
     ASSERT(lenQ >= 0);
     ASSERT(p + lenP * 2 <= limitP);
     ASSERT(q + lenQ * 2 <= limitQ);
 
     const char* startP = p;
     const char* startQ = q;
     p += lenP * 2;
     q += lenQ * 2;
 
-    if (p > limitP || q > limitQ)
+    if (p > limitP || q > limitQ) {
+        ok = false;
         return 0;
+    }
 
+    ok = true;
     const size_t lmin = static_cast<size_t>(lenP < lenQ ? lenP : lenQ);
     if (int x = memcmp(startP, startQ, lmin * 2))
         return x;
 
     if (lenP == lenQ)
         return 0;
 
     return (lenP > lenQ) ? 1 : -1;
 }
 
@@ skipping 75 matching lines @@
     unsigned char type = *p++;
 
     switch (type) {
     case IDBKeyNullTypeByte:
         foundKey = IDBKey::createInvalid();
         return p;
 
     case IDBKeyArrayTypeByte: {
         int64_t length;
         p = decodeVarInt(p, limit, length);
-        if (!p)
-            return 0;
-        if (length < 0)
+        if (!p || length < 0)
             return 0;
         IDBKey::KeyArray array;
         while (length--) {
             RefPtr<IDBKey> key;
             p = decodeIDBKey(p, limit, key);
             if (!p)
                 return 0;
             array.append(key);
         }
         foundKey = IDBKey::createArray(array);
@@ skipping 37 matching lines @@
 
     unsigned char type = *p++;
 
     switch (type) {
     case IDBKeyNullTypeByte:
     case IDBKeyMinKeyTypeByte:
         break;
     case IDBKeyArrayTypeByte: {
         int64_t length;
         p = decodeVarInt(p, limit, length);
-        if (!p)
-            return 0;
-        if (length < 0)
+        if (!p || length < 0)
             return 0;
         while (length--) {
             p = extractEncodedIDBKey(p, limit);
             if (!p)
                 return 0;
         }
         break;
     }
     case IDBKeyStringTypeByte: {
         int64_t length;
         p = decodeVarInt(p, limit, length);
-        if (!p)
-            return 0;
-        if (p + length * 2 > limit)
+        if (!p || length < 0 || p + length * 2 > limit)
             return 0;
         p += length * 2;
         break;
     }
     case IDBKeyDateTypeByte:
     case IDBKeyNumberTypeByte:
         if (p + sizeof(double) > limit)
             return 0;
         p += sizeof(double);
         break;
@@ skipping 23 matching lines @@
     case IDBKeyNumberTypeByte:
         return IDBKey::NumberType;
     case IDBKeyMinKeyTypeByte:
         return IDBKey::MinType;
     }
 
     ASSERT_NOT_REACHED();
     return IDBKey::InvalidType;
 }
 
-int compareEncodedIDBKeys(const char*& ptrA, const char* limitA, const char*& ptrB, const char* limitB)
+int compareEncodedIDBKeys(const char*& ptrA, const char* limitA, const char*& ptrB, const char* limitB, bool& ok)
 {
+    ok = true;
     ASSERT(&ptrA != &ptrB);
     ASSERT(ptrA < limitA);
     ASSERT(ptrB < limitB);
     unsigned char typeA = *ptrA++;
     unsigned char typeB = *ptrB++;
 
     if (int x = IDBKey::compareTypes(keyTypeByteToKeyType(typeA), keyTypeByteToKeyType(typeB)))
         return x;
 
     switch (typeA) {
     case IDBKeyNullTypeByte:
     case IDBKeyMinKeyTypeByte:
         // Null type or max type; no payload to compare.
         return 0;
     case IDBKeyArrayTypeByte: {
         int64_t lengthA, lengthB;
         ptrA = decodeVarInt(ptrA, limitA, lengthA);
-        if (!ptrA)
+        ptrB = decodeVarInt(ptrB, limitB, lengthB);
+        if (!ptrA || !ptrB || lengthA < 0 || lengthB < 0) {
+            ok = false;
             return 0;
-        ptrB = decodeVarInt(ptrB, limitB, lengthB);
-        if (!ptrB)
-            return 0;
-        if (lengthA < 0 || lengthB < 0)
-            return 0;
+        }
         for (int64_t i = 0; i < lengthA && i < lengthB; ++i) {
-            if (int cmp = compareEncodedIDBKeys(ptrA, limitA, ptrB, limitB))
-                return cmp;
+            int result = compareEncodedIDBKeys(ptrA, limitA, ptrB, limitB, ok);
+            if (!ok || result)
+                return result;
         }
         if (lengthA < lengthB)
             return -1;
         if (lengthA > lengthB)
             return 1;
         return 0;
     }
     case IDBKeyStringTypeByte:
-        return compareEncodedStringsWithLength(ptrA, limitA, ptrB, limitB);
+        return compareEncodedStringsWithLength(ptrA, limitA, ptrB, limitB, ok);
     case IDBKeyDateTypeByte:
     case IDBKeyNumberTypeByte: {
         double d, e;
         ptrA = decodeDouble(ptrA, limitA, &d);
+        ptrB = decodeDouble(ptrB, limitB, &e);
         ASSERT(ptrA);
-        ptrB = decodeDouble(ptrB, limitB, &e);
         ASSERT(ptrB);
+        if (!ptrA || !ptrB) {
+            ok = false;
+            return 0;
+        }
         if (d < e)
             return -1;
         if (d > e)
             return 1;
         return 0;
     }
     }
 
     ASSERT_NOT_REACHED();
     return 0;
 }
 
-int compareEncodedIDBKeys(const Vector<char>& keyA, const Vector<char>& keyB)
+int compareEncodedIDBKeys(const Vector<char>& keyA, const Vector<char>& keyB, bool& ok)
 {
     ASSERT(keyA.size() >= 1);
     ASSERT(keyB.size() >= 1);
 
     const char* ptrA = keyA.data();
     const char* limitA = ptrA + keyA.size();
     const char* ptrB = keyB.data();
     const char* limitB = ptrB + keyB.size();
 
-    return compareEncodedIDBKeys(ptrA, limitA, ptrB, limitB);
+    return compareEncodedIDBKeys(ptrA, limitA, ptrB, limitB, ok);
 }
 
 Vector<char> encodeIDBKeyPath(const IDBKeyPath& keyPath)
 {
     // May be typed, or may be a raw string. An invalid leading
     // byte is used to identify typed coding. New records are
     // always written as typed.
     Vector<char, DefaultInlineBufferSize> ret;
     ret.append(IDBKeyPathTypeCodedByte1);
     ret.append(IDBKeyPathTypeCodedByte2);
@@ skipping 53 matching lines @@
         return IDBKeyPath(array);
     }
     }
     ASSERT_NOT_REACHED();
     return IDBKeyPath();
 }
 
 namespace {
 
 template<typename KeyType>
-int compare(const LevelDBSlice& a, const LevelDBSlice& b, bool ignoreDuplicates = false)
+int compare(const LevelDBSlice& a, const LevelDBSlice& b, bool ignoreDuplicates, bool& ok)
 {
     KeyType keyA;
     KeyType keyB;
 
     const char* ptrA = KeyType::decode(a.begin(), a.end(), &keyA);
-    ASSERT_UNUSED(ptrA, ptrA);
+    ASSERT(ptrA);
+    if (!ptrA) {
+        ok = false;
+        return 0;
+    }
     const char* ptrB = KeyType::decode(b.begin(), b.end(), &keyB);
-    ASSERT_UNUSED(ptrB, ptrB);
+    ASSERT(ptrB);
+    if (!ptrB) {
+        ok = false;
+        return 0;
+    }
 
+    ok = true;
     return keyA.compare(keyB);
 }
 
 template<>
-int compare<ExistsEntryKey>(const LevelDBSlice& a, const LevelDBSlice& b, bool ignoreDuplicates)
+int compare<ExistsEntryKey>(const LevelDBSlice& a, const LevelDBSlice& b, bool ignoreDuplicates, bool& ok)
 {
     KeyPrefix prefixA;
     KeyPrefix prefixB;
     const char* ptrA = KeyPrefix::decode(a.begin(), a.end(), &prefixA);
     const char* ptrB = KeyPrefix::decode(b.begin(), b.end(), &prefixB);
     ASSERT(ptrA);
     ASSERT(ptrB);
     ASSERT(prefixA.m_databaseId);
     ASSERT(prefixA.m_objectStoreId);
     ASSERT(prefixA.m_indexId == ExistsEntryKey::SpecialIndexNumber);
     ASSERT(prefixB.m_databaseId);
     ASSERT(prefixB.m_objectStoreId);
     ASSERT(prefixB.m_indexId == ExistsEntryKey::SpecialIndexNumber);
     ASSERT(ptrA != a.end());
     ASSERT(ptrB != b.end());
     // Prefixes are not compared - it is assumed this was already done.
     ASSERT(!prefixA.compare(prefixB));
 
-    return compareEncodedIDBKeys(ptrA, a.end(), ptrB, b.end());
+    return compareEncodedIDBKeys(ptrA, a.end(), ptrB, b.end(), ok);
 }
 
 template<>
-int compare<ObjectStoreDataKey>(const LevelDBSlice& a, const LevelDBSlice& b, bool ignoreDuplicates)
+int compare<ObjectStoreDataKey>(const LevelDBSlice& a, const LevelDBSlice& b, bool ignoreDuplicates, bool& ok)
 {
     KeyPrefix prefixA;
     KeyPrefix prefixB;
     const char* ptrA = KeyPrefix::decode(a.begin(), a.end(), &prefixA);
     const char* ptrB = KeyPrefix::decode(b.begin(), b.end(), &prefixB);
     ASSERT(ptrA);
     ASSERT(ptrB);
     ASSERT(prefixA.m_databaseId);
     ASSERT(prefixA.m_objectStoreId);
     ASSERT(prefixA.m_indexId == ObjectStoreDataKey::SpecialIndexNumber);
     ASSERT(prefixB.m_databaseId);
     ASSERT(prefixB.m_objectStoreId);
     ASSERT(prefixB.m_indexId == ObjectStoreDataKey::SpecialIndexNumber);
     ASSERT(ptrA != a.end());
     ASSERT(ptrB != b.end());
     // Prefixes are not compared - it is assumed this was already done.
     ASSERT(!prefixA.compare(prefixB));
 
-    return compareEncodedIDBKeys(ptrA, a.end(), ptrB, b.end());
+    return compareEncodedIDBKeys(ptrA, a.end(), ptrB, b.end(), ok);
 }
 
 template<>
-int compare<IndexDataKey>(const LevelDBSlice& a, const LevelDBSlice& b, bool ignoreDuplicates)
+int compare<IndexDataKey>(const LevelDBSlice& a, const LevelDBSlice& b, bool ignoreDuplicates, bool& ok)
 {
     KeyPrefix prefixA;
     KeyPrefix prefixB;
     const char* ptrA = KeyPrefix::decode(a.begin(), a.end(), &prefixA);
     const char* ptrB = KeyPrefix::decode(b.begin(), b.end(), &prefixB);
     ASSERT(ptrA);
     ASSERT(ptrB);
     ASSERT(prefixA.m_databaseId);
     ASSERT(prefixA.m_objectStoreId);
     ASSERT(prefixA.m_indexId >= MinimumIndexId);
     ASSERT(prefixB.m_databaseId);
     ASSERT(prefixB.m_objectStoreId);
     ASSERT(prefixB.m_indexId >= MinimumIndexId);
     ASSERT(ptrA != a.end());
     ASSERT(ptrB != b.end());
     // Prefixes are not compared - it is assumed this was already done.
     ASSERT(!prefixA.compare(prefixB));
 
     // index key
-    if (int x = compareEncodedIDBKeys(ptrA, a.end(), ptrB, b.end()))
-        return x;
+    int result = compareEncodedIDBKeys(ptrA, a.end(), ptrB, b.end(), ok);
+    if (!ok || result)
+        return result;
     if (ignoreDuplicates)
         return 0;
 
     // sequence number [optional]
     int64_t sequenceNumberA = -1;
     int64_t sequenceNumberB = -1;
     if (ptrA != a.end())
         ptrA = decodeVarInt(ptrA, a.end(), sequenceNumberA);
     if (ptrB != b.end())
         ptrB = decodeVarInt(ptrB, b.end(), sequenceNumberB);
 
-    // primar key [optional]
+    // primary key [optional]
     if (!ptrA || !ptrB)
         return 0;
     if (ptrA == a.end() && ptrB == b.end())
         return 0;
     if (ptrA == a.end())
         return -1;
     if (ptrB == b.end())
         return 1;
 
-    if (int x = compareEncodedIDBKeys(ptrA, a.end(), ptrB, b.end()))
-        return x;
+    result = compareEncodedIDBKeys(ptrA, a.end(), ptrB, b.end(), ok);
+    if (!ok || result)
+        return result;
 
     return compareInts(sequenceNumberA, sequenceNumberB);
 }
 
-}
-
-int compare(const LevelDBSlice& a, const LevelDBSlice& b, bool indexKeys)
+int compare(const LevelDBSlice& a, const LevelDBSlice& b, bool indexKeys, bool& ok)
 {
     const char* ptrA = a.begin();
     const char* ptrB = b.begin();
     const char* endA = a.end();
     const char* endB = b.end();
 
     KeyPrefix prefixA;
     KeyPrefix prefixB;
 
     ptrA = KeyPrefix::decode(ptrA, endA, &prefixA);
     ptrB = KeyPrefix::decode(ptrB, endB, &prefixB);
     ASSERT(ptrA);
     ASSERT(ptrB);
+    if (!ptrA || !ptrB) {
+        ok = false;
+        return 0;
+    }
 
+    ok = true;
     if (int x = prefixA.compare(prefixB))
         return x;
 
     if (prefixA.type() == KeyPrefix::GlobalMetaData) {
         ASSERT(ptrA != endA);
         ASSERT(ptrB != endB);
 
         unsigned char typeByteA = *ptrA++;
         unsigned char typeByteB = *ptrB++;
 
         if (int x = typeByteA - typeByteB)
             return x;
         if (typeByteA < MaxSimpleGlobalMetaDataTypeByte)
             return 0;
 
+        const bool ignoreDuplicates = false;
         if (typeByteA == DatabaseFreeListTypeByte)
-            return compare<DatabaseFreeListKey>(a, b);
+            return compare<DatabaseFreeListKey>(a, b, ignoreDuplicates, ok);
         if (typeByteA == DatabaseNameTypeByte)
-            return compare<DatabaseNameKey>(a, b);
+            return compare<DatabaseNameKey>(a, b, ignoreDuplicates, ok);
     }
 
     if (prefixA.type() == KeyPrefix::DatabaseMetaData) {
         ASSERT(ptrA != endA);
         ASSERT(ptrB != endB);
 
         unsigned char typeByteA = *ptrA++;
         unsigned char typeByteB = *ptrB++;
 
         if (int x = typeByteA - typeByteB)
             return x;
         if (typeByteA < DatabaseMetaDataKey::MaxSimpleMetaDataType)
             return 0;
 
+        const bool ignoreDuplicates = false;
         if (typeByteA == ObjectStoreMetaDataTypeByte)
-            return compare<ObjectStoreMetaDataKey>(a, b);
+            return compare<ObjectStoreMetaDataKey>(a, b, ignoreDuplicates, ok);
         if (typeByteA == IndexMetaDataTypeByte)
-            return compare<IndexMetaDataKey>(a, b);
+            return compare<IndexMetaDataKey>(a, b, ignoreDuplicates, ok);
         if (typeByteA == ObjectStoreFreeListTypeByte)
-            return compare<ObjectStoreFreeListKey>(a, b);
+            return compare<ObjectStoreFreeListKey>(a, b, ignoreDuplicates, ok);
         if (typeByteA == IndexFreeListTypeByte)
-            return compare<IndexFreeListKey>(a, b);
+            return compare<IndexFreeListKey>(a, b, ignoreDuplicates, ok);
         if (typeByteA == ObjectStoreNamesTypeByte)
-            return compare<ObjectStoreNamesKey>(a, b);
+            return compare<ObjectStoreNamesKey>(a, b, ignoreDuplicates, ok);
         if (typeByteA == IndexNamesKeyTypeByte)
-            return compare<IndexNamesKey>(a, b);
+            return compare<IndexNamesKey>(a, b, ignoreDuplicates, ok);
     }
 
     if (prefixA.type() == KeyPrefix::ObjectStoreData) {
         if (ptrA == endA && ptrB == endB)
             return 0;
         if (ptrA == endA)
             return -1;
         if (ptrB == endB)
             return 1; // FIXME: This case of non-existing user keys should not have to be handled this way.
 
-        return compare<ObjectStoreDataKey>(a, b);
+        const bool ignoreDuplicates = false;
+        return compare<ObjectStoreDataKey>(a, b, ignoreDuplicates, ok);
     }
     if (prefixA.type() == KeyPrefix::ExistsEntry) {
         if (ptrA == endA && ptrB == endB)
             return 0;
         if (ptrA == endA)
             return -1;
         if (ptrB == endB)
             return 1; // FIXME: This case of non-existing user keys should not have to be handled this way.
 
-        return compare<ExistsEntryKey>(a, b);
+        const bool ignoreDuplicates = false;
+        return compare<ExistsEntryKey>(a, b, ignoreDuplicates, ok);
     }
     if (prefixA.type() == KeyPrefix::IndexData) {
         if (ptrA == endA && ptrB == endB)
             return 0;
         if (ptrA == endA)
             return -1;
         if (ptrB == endB)
             return 1; // FIXME: This case of non-existing user keys should not have to be handled this way.
 
         bool ignoreDuplicates = indexKeys;
-        return compare<IndexDataKey>(a, b, ignoreDuplicates);
+        return compare<IndexDataKey>(a, b, ignoreDuplicates, ok);
     }
 
     ASSERT_NOT_REACHED();
+    ok = false;
     return 0;
 }
 
+}
+
+int compare(const LevelDBSlice& a, const LevelDBSlice& b, bool indexKeys)
+{
+    bool ok;
+    int result = compare(a, b, indexKeys, ok);
+    ASSERT(ok);
+    if (!ok)
+        return 0;
+    return result;
+}
 
 KeyPrefix::KeyPrefix()
     : m_databaseId(InvalidType)
     , m_objectStoreId(InvalidType)
     , m_indexId(InvalidType)
 {
 }
 
 KeyPrefix::KeyPrefix(int64_t databaseId, int64_t objectStoreId, int64_t indexId)
     : m_databaseId(databaseId)
@@ skipping 586 matching lines @@
     ret.append(encodedUserKey);
 
     return ret;
 }
 
 Vector<char> ObjectStoreDataKey::encode(int64_t databaseId, int64_t objectStoreId, const IDBKey& userKey)
 {
     return encode(databaseId, objectStoreId, encodeIDBKey(userKey));
 }
 
-int ObjectStoreDataKey::compare(const ObjectStoreDataKey& other)
+int ObjectStoreDataKey::compare(const ObjectStoreDataKey& other, bool& ok)
 {
-    return compareEncodedIDBKeys(m_encodedUserKey, other.m_encodedUserKey);
+    return compareEncodedIDBKeys(m_encodedUserKey, other.m_encodedUserKey, ok);
 }
 
 PassRefPtr<IDBKey> ObjectStoreDataKey::userKey() const
 {
     RefPtr<IDBKey> key;
     decodeIDBKey(m_encodedUserKey.begin(), m_encodedUserKey.end(), key);
     return key;
 }
 
 const int64_t ObjectStoreDataKey::SpecialIndexNumber = ObjectStoreDataIndexId;
@@ skipping 18 matching lines @@
     Vector<char> ret = prefix.encode();
     ret.append(encodedKey);
     return ret;
 }
 
 Vector<char> ExistsEntryKey::encode(int64_t databaseId, int64_t objectStoreId, const IDBKey& userKey)
 {
     return encode(databaseId, objectStoreId, encodeIDBKey(userKey));
 }
 
-int ExistsEntryKey::compare(const ExistsEntryKey& other)
+int ExistsEntryKey::compare(const ExistsEntryKey& other, bool& ok)
 {
-    return compareEncodedIDBKeys(m_encodedUserKey, other.m_encodedUserKey);
+    return compareEncodedIDBKeys(m_encodedUserKey, other.m_encodedUserKey, ok);
 }
 
 PassRefPtr<IDBKey> ExistsEntryKey::userKey() const
 {
     RefPtr<IDBKey> key;
     decodeIDBKey(m_encodedUserKey.begin(), m_encodedUserKey.end(), key);
     return key;
 }
 
 const int64_t ExistsEntryKey::SpecialIndexNumber = ExistsEntryIndexId;
@@ skipping 60 matching lines @@
 Vector<char> IndexDataKey::encodeMinKey(int64_t databaseId, int64_t objectStoreId, int64_t indexId)
 {
     return encode(databaseId, objectStoreId, indexId, minIDBKey(), minIDBKey());
 }
 
 Vector<char> IndexDataKey::encodeMaxKey(int64_t databaseId, int64_t objectStoreId, int64_t indexId)
 {
     return encode(databaseId, objectStoreId, indexId, maxIDBKey(), maxIDBKey(), INT64_MAX);
 }
 
-int IndexDataKey::compare(const IndexDataKey& other, bool ignoreDuplicates)
+int IndexDataKey::compare(const IndexDataKey& other, bool ignoreDuplicates, bool& ok)
 {
     ASSERT(m_databaseId >= 0);
     ASSERT(m_objectStoreId >= 0);
     ASSERT(m_indexId >= 0);
-    if (int x = compareEncodedIDBKeys(m_encodedUserKey, other.m_encodedUserKey))
-        return x;
+    int result = compareEncodedIDBKeys(m_encodedUserKey, other.m_encodedUserKey, ok);
+    if (!ok || result)
+        return result;
     if (ignoreDuplicates)
         return 0;
-    if (int x = compareEncodedIDBKeys(m_encodedPrimaryKey, other.m_encodedPrimaryKey))
-        return x;
+    result = compareEncodedIDBKeys(m_encodedPrimaryKey, other.m_encodedPrimaryKey, ok);
+    if (!ok || result)
+        return result;
     return compareInts(m_sequenceNumber, other.m_sequenceNumber);
 }
 
 int64_t IndexDataKey::databaseId() const
 {
     ASSERT(m_databaseId >= 0);
     return m_databaseId;
 }
 
 int64_t IndexDataKey::objectStoreId() const
@@ skipping 20 matching lines @@
     RefPtr<IDBKey> key;
     decodeIDBKey(m_encodedPrimaryKey.begin(), m_encodedPrimaryKey.end(), key);
     return key;
 }
 
 } // namespace IDBLevelDBCoding
 } // namespace WebCore
 
 #endif // USE(LEVELDB)
 #endif // ENABLE(INDEXED_DATABASE)