Use Optional::valueOr() instead of Optional::value_or()
[WebKit-https.git] / Source / WebCore / Modules / indexeddb / IDBDatabaseIdentifier.h
index 31e41aa..e6eb4bf 100644 (file)
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef IDBDatabaseIdentifier_h
-#define IDBDatabaseIdentifier_h
+#pragma once
 
 #if ENABLE(INDEXED_DATABASE)
 
 #include "SecurityOriginData.h"
-#include <wtf/Ref.h>
-#include <wtf/RefCounted.h>
+#include <pal/SessionID.h>
 #include <wtf/text/StringHash.h>
 #include <wtf/text/WTFString.h>
 
@@ -40,47 +38,43 @@ class SecurityOrigin;
 
 class IDBDatabaseIdentifier {
 public:
-    IDBDatabaseIdentifier()
-    {
-        m_openingOrigin.port = -2;
-        m_mainFrameOrigin.port = -2;
-    }
-
+    IDBDatabaseIdentifier() { }
     IDBDatabaseIdentifier(WTF::HashTableDeletedValueType)
+        : m_databaseName(WTF::HashTableDeletedValue)
     {
-        m_openingOrigin.port = -1;
-        m_mainFrameOrigin.port = -1;
     }
 
+    WEBCORE_EXPORT IDBDatabaseIdentifier(const String& databaseName, const PAL::SessionID&, SecurityOriginData&& openingOrigin, SecurityOriginData&& mainFrameOrigin);
+
     IDBDatabaseIdentifier isolatedCopy() const;
 
     bool isHashTableDeletedValue() const
     {
-        return m_openingOrigin.port == -1 && m_mainFrameOrigin.port == -1;
+        return m_databaseName.isHashTableDeletedValue();
     }
 
     unsigned hash() const
     {
         unsigned nameHash = StringHash::hash(m_databaseName);
+        unsigned sessionIDHash = WTF::SessionIDHash::hash(m_sessionID);
         unsigned openingProtocolHash = StringHash::hash(m_openingOrigin.protocol);
         unsigned openingHostHash = StringHash::hash(m_openingOrigin.host);
         unsigned mainFrameProtocolHash = StringHash::hash(m_mainFrameOrigin.protocol);
         unsigned mainFrameHostHash = StringHash::hash(m_mainFrameOrigin.host);
         
-        unsigned hashCodes[7] = { nameHash, openingProtocolHash, openingHostHash, static_cast<unsigned>(m_openingOrigin.port), mainFrameProtocolHash, mainFrameHostHash, static_cast<unsigned>(m_mainFrameOrigin.port) };
+        unsigned hashCodes[8] = { nameHash, sessionIDHash, openingProtocolHash, openingHostHash, m_openingOrigin.port.valueOr(0), mainFrameProtocolHash, mainFrameHostHash, m_mainFrameOrigin.port.valueOr(0) };
         return StringHasher::hashMemory<sizeof(hashCodes)>(hashCodes);
     }
 
-    IDBDatabaseIdentifier(const String& databaseName, const SecurityOrigin& openingOrigin, const SecurityOrigin& mainFrameOrigin);
-
     bool isValid() const
     {
-        return !m_databaseName.isNull() && m_openingOrigin.port >= 0 && m_mainFrameOrigin.port >= 0;
+        return !m_databaseName.isNull()
+            && !m_databaseName.isHashTableDeletedValue();
     }
 
     bool isEmpty() const
     {
-        return m_openingOrigin.port == -2 && m_mainFrameOrigin.port == -2;
+        return m_databaseName.isNull();
     }
 
     bool operator==(const IDBDatabaseIdentifier& other) const
@@ -91,19 +85,26 @@ public:
     }
 
     const String& databaseName() const { return m_databaseName; }
+    const PAL::SessionID& sessionID() const { return m_sessionID; }
 
     String databaseDirectoryRelativeToRoot(const String& rootDirectory) const;
     static String databaseDirectoryRelativeToRoot(const SecurityOriginData& topLevelOrigin, const SecurityOriginData& openingOrigin, const String& rootDirectory);
 
     template<class Encoder> void encode(Encoder&) const;
-    template<class Decoder> static bool decode(Decoder&, IDBDatabaseIdentifier&);
+    template<class Decoder> static Optional<IDBDatabaseIdentifier> decode(Decoder&);
 
-#ifndef NDEBUG
+#if !LOG_DISABLED
     String debugString() const;
 #endif
 
+    bool isRelatedToOrigin(const SecurityOriginData& other) const
+    {
+        return m_openingOrigin == other || m_mainFrameOrigin == other;
+    }
+
 private:
     String m_databaseName;
+    PAL::SessionID m_sessionID;
     SecurityOriginData m_openingOrigin;
     SecurityOriginData m_mainFrameOrigin;
 };
@@ -123,22 +124,38 @@ struct IDBDatabaseIdentifierHashTraits : WTF::SimpleClassHashTraits<IDBDatabaseI
 template<class Encoder>
 void IDBDatabaseIdentifier::encode(Encoder& encoder) const
 {
-    encoder << m_databaseName << m_openingOrigin << m_mainFrameOrigin;
+    encoder << m_databaseName << m_sessionID << m_openingOrigin << m_mainFrameOrigin;
 }
 
 template<class Decoder>
-bool IDBDatabaseIdentifier::decode(Decoder& decoder, IDBDatabaseIdentifier& identifier)
+Optional<IDBDatabaseIdentifier> IDBDatabaseIdentifier::decode(Decoder& decoder)
 {
-    if (!decoder.decode(identifier.m_databaseName))
-        return false;
-
-    if (!decoder.decode(identifier.m_openingOrigin))
-        return false;
-
-    if (!decoder.decode(identifier.m_mainFrameOrigin))
-        return false;
-
-    return true;
+    Optional<String> databaseName;
+    decoder >> databaseName;
+    if (!databaseName)
+        return WTF::nullopt;
+
+    Optional<PAL::SessionID> sessionID;
+    decoder >> sessionID;
+    if (!sessionID)
+        return WTF::nullopt;
+    
+    Optional<SecurityOriginData> openingOrigin;
+    decoder >> openingOrigin;
+    if (!openingOrigin)
+        return WTF::nullopt;
+
+    Optional<SecurityOriginData> mainFrameOrigin;
+    decoder >> mainFrameOrigin;
+    if (!mainFrameOrigin)
+        return WTF::nullopt;
+
+    IDBDatabaseIdentifier identifier;
+    identifier.m_databaseName = WTFMove(*databaseName); // FIXME: When decoding from IPC, databaseName can be null, and the non-empty constructor asserts that this is not the case.
+    identifier.m_sessionID = WTFMove(*sessionID);
+    identifier.m_openingOrigin = WTFMove(*openingOrigin);
+    identifier.m_mainFrameOrigin = WTFMove(*mainFrameOrigin);
+    return WTFMove(identifier);
 }
 
 } // namespace WebCore
@@ -153,4 +170,3 @@ template<> struct DefaultHash<WebCore::IDBDatabaseIdentifier> {
 } // namespace WTF
 
 #endif // ENABLE(INDEXED_DATABASE)
-#endif // IDBDatabaseIdentifier_h