The Tor Browser: dom/indexedDB/KeyPath.cpp@b8a032363ba2 (annotated)

dom/indexedDB/KeyPath.cpp@b8a032363ba2 (annotated)

dom/indexedDB/KeyPath.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "KeyPath.h"
 #include "IDBObjectStore.h"
 #include "Key.h"
 #include "ReportInternalError.h"
 #include "nsCharSeparatedTokenizer.h"
 #include "nsJSUtils.h"
 #include "xpcpublic.h"
 #include "mozilla/dom/BindingDeclarations.h"
 USING_INDEXEDDB_NAMESPACE
 namespace {
 inline
 bool
 IgnoreWhitespace(char16_t c)
 {
   return false;
 }
 typedef nsCharSeparatedTokenizerTemplate<IgnoreWhitespace> KeyPathTokenizer;
 bool
 IsValidKeyPathString(JSContext* aCx, const nsAString& aKeyPath)
 {
   NS_ASSERTION(!aKeyPath.IsVoid(), "What?");
   KeyPathTokenizer tokenizer(aKeyPath, '.');
   while (tokenizer.hasMoreTokens()) {
     nsString token(tokenizer.nextToken());
     if (!token.Length()) {
       return false;
     }
     JS::Rooted<JS::Value> stringVal(aCx);
     if (!xpc::StringToJsval(aCx, token, &stringVal)) {
       return false;
     }
     NS_ASSERTION(stringVal.toString(), "This should never happen");
     JS::Rooted<JSString*> str(aCx, stringVal.toString());
     bool isIdentifier = false;
     if (!JS_IsIdentifier(aCx, str, &isIdentifier) || !isIdentifier) {
       return false;
     }
   }
   // If the very last character was a '.', the tokenizer won't give us an empty
   // token, but the keyPath is still invalid.
   if (!aKeyPath.IsEmpty() &&
       aKeyPath.CharAt(aKeyPath.Length() - 1) == '.') {
     return false;
   }
   return true;
 }
 enum KeyExtractionOptions {
   DoNotCreateProperties,
   CreateProperties
 };
 nsresult
 GetJSValFromKeyPathString(JSContext* aCx,
                           const JS::Value& aValue,
                           const nsAString& aKeyPathString,
                           JS::Value* aKeyJSVal,
                           KeyExtractionOptions aOptions,
                           KeyPath::ExtractOrCreateKeyCallback aCallback,
                           void* aClosure)
 {
   NS_ASSERTION(aCx, "Null pointer!");
   NS_ASSERTION(IsValidKeyPathString(aCx, aKeyPathString),
                "This will explode!");
   NS_ASSERTION(!(aCallback || aClosure) || aOptions == CreateProperties,
                "This is not allowed!");
   NS_ASSERTION(aOptions != CreateProperties || aCallback,
                "If properties are created, there must be a callback!");
   nsresult rv = NS_OK;
   *aKeyJSVal = aValue;
   KeyPathTokenizer tokenizer(aKeyPathString, '.');
   nsString targetObjectPropName;
   JS::Rooted<JSObject*> targetObject(aCx, nullptr);
   JS::Rooted<JSObject*> obj(aCx,
     JSVAL_IS_PRIMITIVE(aValue) ? nullptr : JSVAL_TO_OBJECT(aValue));
   while (tokenizer.hasMoreTokens()) {
     const nsDependentSubstring& token = tokenizer.nextToken();
     NS_ASSERTION(!token.IsEmpty(), "Should be a valid keypath");
     const jschar* keyPathChars = token.BeginReading();
     const size_t keyPathLen = token.Length();
     bool hasProp;
     if (!targetObject) {
       // We're still walking the chain of existing objects
       if (!obj) {
         return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
       }
       bool ok = JS_HasUCProperty(aCx, obj, keyPathChars, keyPathLen,
                                  &hasProp);
       IDB_ENSURE_TRUE(ok, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
       if (hasProp) {
         // Get if the property exists...
         JS::Rooted<JS::Value> intermediate(aCx);
         bool ok = JS_GetUCProperty(aCx, obj, keyPathChars, keyPathLen, &intermediate);
         IDB_ENSURE_TRUE(ok, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
         // Treat explicitly undefined as an error.
         if (intermediate == JSVAL_VOID) {
           return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
         }
         if (tokenizer.hasMoreTokens()) {
           // ...and walk to it if there are more steps...
           if (JSVAL_IS_PRIMITIVE(intermediate)) {
             return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
           }
           obj = JSVAL_TO_OBJECT(intermediate);
         }
         else {
           // ...otherwise use it as key
           *aKeyJSVal = intermediate;
         }
       }
       else {
         // If the property doesn't exist, fall into below path of starting
         // to define properties, if allowed.
         if (aOptions == DoNotCreateProperties) {
           return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
         }
         targetObject = obj;
         targetObjectPropName = token;
       }
     }
     if (targetObject) {
       // We have started inserting new objects or are about to just insert
       // the first one.
       *aKeyJSVal = JSVAL_VOID;
       if (tokenizer.hasMoreTokens()) {
         // If we're not at the end, we need to add a dummy object to the
         // chain.
         JS::Rooted<JSObject*> dummy(aCx, JS_NewObject(aCx, nullptr, JS::NullPtr(),
                                                       JS::NullPtr()));
         if (!dummy) {
           IDB_REPORT_INTERNAL_ERR();
           rv = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
           break;
         }
         if (!JS_DefineUCProperty(aCx, obj, token.BeginReading(),
                                  token.Length(),
                                  OBJECT_TO_JSVAL(dummy), nullptr, nullptr,
                                  JSPROP_ENUMERATE)) {
           IDB_REPORT_INTERNAL_ERR();
           rv = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
           break;
         }
         obj = dummy;
       }
       else {
         JS::Rooted<JSObject*> dummy(aCx, JS_NewObject(aCx, &IDBObjectStore::sDummyPropJSClass,
                                                       JS::NullPtr(), JS::NullPtr()));
         if (!dummy) {
           IDB_REPORT_INTERNAL_ERR();
           rv = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
           break;
         }
         if (!JS_DefineUCProperty(aCx, obj, token.BeginReading(),
                                  token.Length(), OBJECT_TO_JSVAL(dummy),
                                  nullptr, nullptr, JSPROP_ENUMERATE)) {
           IDB_REPORT_INTERNAL_ERR();
           rv = NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
           break;
         }
         obj = dummy;
       }
     }
   }
   // We guard on rv being a success because we need to run the property
   // deletion code below even if we should not be running the callback.
   if (NS_SUCCEEDED(rv) && aCallback) {
     rv = (*aCallback)(aCx, aClosure);
   }
   if (targetObject) {
     // If this fails, we lose, and the web page sees a magical property
     // appear on the object :-(
     bool succeeded;
     if (!JS_DeleteUCProperty2(aCx, targetObject,
                               targetObjectPropName.get(),
                               targetObjectPropName.Length(),
                               &succeeded)) {
       IDB_REPORT_INTERNAL_ERR();
       return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
     }
     IDB_ENSURE_TRUE(succeeded, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
   }
   NS_ENSURE_SUCCESS(rv, rv);
   return rv;
 }
 } // anonymous namespace
 // static
 nsresult
 KeyPath::Parse(JSContext* aCx, const nsAString& aString, KeyPath* aKeyPath)
 {
   KeyPath keyPath(0);
   keyPath.SetType(STRING);
   if (!keyPath.AppendStringWithValidation(aCx, aString)) {
     return NS_ERROR_FAILURE;
   }
   *aKeyPath = keyPath;
   return NS_OK;
 }
 //static
 nsresult
 KeyPath::Parse(JSContext* aCx, const mozilla::dom::Sequence<nsString>& aStrings,
                KeyPath* aKeyPath)
 {
   KeyPath keyPath(0);
   keyPath.SetType(ARRAY);
   for (uint32_t i = 0; i < aStrings.Length(); ++i) {
     if (!keyPath.AppendStringWithValidation(aCx, aStrings[i])) {
       return NS_ERROR_FAILURE;
     }
   }
   *aKeyPath = keyPath;
   return NS_OK;
 }
 // static
 nsresult
 KeyPath::Parse(JSContext* aCx, const JS::Value& aValue_, KeyPath* aKeyPath)
 {
   JS::Rooted<JS::Value> aValue(aCx, aValue_);
   KeyPath keyPath(0);
   aKeyPath->SetType(NONEXISTENT);
   // See if this is a JS array.
   if (JS_IsArrayObject(aCx, aValue)) {
     JS::Rooted<JSObject*> obj(aCx, JSVAL_TO_OBJECT(aValue));
     uint32_t length;
     if (!JS_GetArrayLength(aCx, obj, &length)) {
       return NS_ERROR_FAILURE;
     }
     if (!length) {
       return NS_ERROR_FAILURE;
     }
     keyPath.SetType(ARRAY);
     for (uint32_t index = 0; index < length; index++) {
       JS::Rooted<JS::Value> val(aCx);
       JSString* jsstr;
       nsDependentJSString str;
       if (!JS_GetElement(aCx, obj, index, &val) ||
           !(jsstr = JS::ToString(aCx, val)) ||
           !str.init(aCx, jsstr)) {
         return NS_ERROR_FAILURE;
       }
       if (!keyPath.AppendStringWithValidation(aCx, str)) {
         return NS_ERROR_FAILURE;
       }
     }
   }
   // Otherwise convert it to a string.
   else if (!JSVAL_IS_NULL(aValue) && !JSVAL_IS_VOID(aValue)) {
     JSString* jsstr;
     nsDependentJSString str;
     if (!(jsstr = JS::ToString(aCx, aValue)) ||
         !str.init(aCx, jsstr)) {
       return NS_ERROR_FAILURE;
     }
     keyPath.SetType(STRING);
     if (!keyPath.AppendStringWithValidation(aCx, str)) {
       return NS_ERROR_FAILURE;
     }
   }
   *aKeyPath = keyPath;
   return NS_OK;
 }
 void
 KeyPath::SetType(KeyPathType aType)
 {
   mType = aType;
   mStrings.Clear();
 }
 bool
 KeyPath::AppendStringWithValidation(JSContext* aCx, const nsAString& aString)
 {
   if (!IsValidKeyPathString(aCx, aString)) {
     return false;
   }
   if (IsString()) {
     NS_ASSERTION(mStrings.Length() == 0, "Too many strings!");
     mStrings.AppendElement(aString);
     return true;
   }
   if (IsArray()) {
     mStrings.AppendElement(aString);
     return true;
   }
   NS_NOTREACHED("What?!");
   return false;
 }
 nsresult
 KeyPath::ExtractKey(JSContext* aCx, const JS::Value& aValue, Key& aKey) const
 {
   uint32_t len = mStrings.Length();
   JS::Rooted<JS::Value> value(aCx);
   aKey.Unset();
   for (uint32_t i = 0; i < len; ++i) {
     nsresult rv = GetJSValFromKeyPathString(aCx, aValue, mStrings[i],
                                             value.address(),
                                             DoNotCreateProperties, nullptr,
                                             nullptr);
     if (NS_FAILED(rv)) {
       return rv;
     }
     if (NS_FAILED(aKey.AppendItem(aCx, IsArray() && i == 0, value))) {
       NS_ASSERTION(aKey.IsUnset(), "Encoding error should unset");
       return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
     }
   }
   aKey.FinishArray();
   return NS_OK;
 }
 nsresult
 KeyPath::ExtractKeyAsJSVal(JSContext* aCx, const JS::Value& aValue,
                            JS::Value* aOutVal) const
 {
   NS_ASSERTION(IsValid(), "This doesn't make sense!");
   if (IsString()) {
     return GetJSValFromKeyPathString(aCx, aValue, mStrings[0], aOutVal,
                                      DoNotCreateProperties, nullptr, nullptr);
   }
   const uint32_t len = mStrings.Length();
   JS::Rooted<JSObject*> arrayObj(aCx, JS_NewArrayObject(aCx, len));
   if (!arrayObj) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
   JS::Rooted<JS::Value> value(aCx);
   for (uint32_t i = 0; i < len; ++i) {
     nsresult rv = GetJSValFromKeyPathString(aCx, aValue, mStrings[i],
                                             value.address(),
                                             DoNotCreateProperties, nullptr,
                                             nullptr);
     if (NS_FAILED(rv)) {
       return rv;
     }
     if (!JS_SetElement(aCx, arrayObj, i, value)) {
       IDB_REPORT_INTERNAL_ERR();
       return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
     }
   }
   *aOutVal = OBJECT_TO_JSVAL(arrayObj);
   return NS_OK;
 }
 nsresult
 KeyPath::ExtractOrCreateKey(JSContext* aCx, const JS::Value& aValue,
                             Key& aKey, ExtractOrCreateKeyCallback aCallback,
                             void* aClosure) const
 {
   NS_ASSERTION(IsString(), "This doesn't make sense!");
   JS::Rooted<JS::Value> value(aCx);
   aKey.Unset();
   nsresult rv = GetJSValFromKeyPathString(aCx, aValue, mStrings[0],
                                           value.address(),
                                           CreateProperties, aCallback,
                                           aClosure);
   if (NS_FAILED(rv)) {
     return rv;
   }
   if (NS_FAILED(aKey.AppendItem(aCx, false, value))) {
     NS_ASSERTION(aKey.IsUnset(), "Should be unset");
     return JSVAL_IS_VOID(value) ? NS_OK : NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
   }
   aKey.FinishArray();
   return NS_OK;
 }
 void
 KeyPath::SerializeToString(nsAString& aString) const
 {
   NS_ASSERTION(IsValid(), "Check to see if I'm valid first!");
   if (IsString()) {
     aString = mStrings[0];
     return;
   }
   if (IsArray()) {
     // We use a comma in the beginning to indicate that it's an array of
     // key paths. This is to be able to tell a string-keypath from an
     // array-keypath which contains only one item.
     // It also makes serializing easier :-)
     uint32_t len = mStrings.Length();
     for (uint32_t i = 0; i < len; ++i) {
       aString.Append(NS_LITERAL_STRING(",") + mStrings[i]);
     }
     return;
   }
   NS_NOTREACHED("What?");
 }
 // static
 KeyPath
 KeyPath::DeserializeFromString(const nsAString& aString)
 {
   KeyPath keyPath(0);
   if (!aString.IsEmpty() && aString.First() == ',') {
     keyPath.SetType(ARRAY);
     // We use a comma in the beginning to indicate that it's an array of
     // key paths. This is to be able to tell a string-keypath from an
     // array-keypath which contains only one item.
     nsCharSeparatedTokenizerTemplate<IgnoreWhitespace> tokenizer(aString, ',');
     tokenizer.nextToken();
     while (tokenizer.hasMoreTokens()) {
       keyPath.mStrings.AppendElement(tokenizer.nextToken());
     }
     return keyPath;
   }
   keyPath.SetType(STRING);
   keyPath.mStrings.AppendElement(aString);
   return keyPath;
 }
 nsresult
 KeyPath::ToJSVal(JSContext* aCx, JS::MutableHandle<JS::Value> aValue) const
 {
   if (IsArray()) {
     uint32_t len = mStrings.Length();
     JS::Rooted<JSObject*> array(aCx, JS_NewArrayObject(aCx, len));
     if (!array) {
       IDB_WARNING("Failed to make array!");
       return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
     }
     for (uint32_t i = 0; i < len; ++i) {
       JS::Rooted<JS::Value> val(aCx);
       nsString tmp(mStrings[i]);
       if (!xpc::StringToJsval(aCx, tmp, &val)) {
         IDB_REPORT_INTERNAL_ERR();
         return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
       }
       if (!JS_SetElement(aCx, array, i, val)) {
         IDB_REPORT_INTERNAL_ERR();
         return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
       }
     }
     aValue.setObject(*array);
     return NS_OK;
   }
   if (IsString()) {
     nsString tmp(mStrings[0]);
     if (!xpc::StringToJsval(aCx, tmp, aValue)) {
       IDB_REPORT_INTERNAL_ERR();
       return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
     }
     return NS_OK;
   }
   aValue.setNull();
   return NS_OK;
 }
 nsresult
 KeyPath::ToJSVal(JSContext* aCx, JS::Heap<JS::Value>& aValue) const
 {
   JS::Rooted<JS::Value> value(aCx);
   nsresult rv = ToJSVal(aCx, &value);
   if (NS_SUCCEEDED(rv)) {
     aValue = value;
   }
   return rv;
 }
 bool
 KeyPath::IsAllowedForObjectStore(bool aAutoIncrement) const
 {
   // Any keypath that passed validation is allowed for non-autoIncrement
   // objectStores.
   if (!aAutoIncrement) {
     return true;
   }
   // Array keypaths are not allowed for autoIncrement objectStores.
   if (IsArray()) {
     return false;
   }
   // Neither are empty strings.
   if (IsEmpty()) {
     return false;
   }
   // Everything else is ok.
   return true;
 }

The Tor Browser / annotate

dom/indexedDB/KeyPath.cpp@b8a032363ba2 (annotated)

dom/indexedDB/KeyPath.cpp