IndexedDB: Rethrow exceptions thrown by getters during keypath eval

Source/bindings/modules/v8/V8BindingForModules.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 248 matching lines @@
         return true;
     if (value->IsArray() && name == "length")
         return true;
     if (V8Blob::hasInstance(value, isolate))
         return name == "size" || name == "type";
     if (V8File::hasInstance(value, isolate))
         return name == "name" || name == "lastModified" || name =="lastModifiedDate";
     return false;
 }
 
-// Get an object's property ("own" or via prototype chain) of the given name.
-// Has a special case for String's length property and otherwise fails for
-// non-objects since it casts to object to call Has() and Get().
-static bool get(v8::Isolate* isolate, v8::Local<v8::Value> value, const String& name, v8::Local<v8::Value>& result)
-{
-    if (value->IsString() && name == "length") {
-        int32_t length = value.As<v8::String>()->Length();
-        result = v8::Number::New(isolate, length);
-        return true;
-    }
-    if (!value->IsObject())
-        return false;
-    v8::Local<v8::Object> object = value.As<v8::Object>();
-    v8::Local<v8::String> key = v8String(isolate, name);
-    v8::Local<v8::Context> context = isolate->GetCurrentContext();
-    if (!v8CallBoolean(object->Has(context, key)))
-        return false;
-    if (!object->Get(context, key).ToLocal(&result))
-        return false;
-    return true;
-}
-
 // Assumes a valid key path.
 static Vector<String> parseKeyPath(const String& keyPath)
 {
     Vector<String> elements;
     IDBKeyPathParseError error;
     IDBParseKeyPath(keyPath, elements, error);
     ASSERT(error == IDBKeyPathParseErrorNone);
     return elements;
 }
 
 static IDBKey* createIDBKeyFromValueAndKeyPath(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, const String& keyPath, ExceptionState& exceptionState, bool allowExperimentalTypes)
 {
     Vector<String> keyPathElements = parseKeyPath(keyPath);
     ASSERT(isolate->InContext());
 
     v8::HandleScope handleScope(isolate);
-    v8::Local<v8::Value> currentValue(v8Value);
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+    v8::TryCatch block;
     for (size_t i = 0; i < keyPathElements.size(); ++i) {
-        v8::Local<v8::Value> parentValue(currentValue);
-        if (!get(isolate, parentValue, keyPathElements[i], currentValue))
+        if (v8Value->IsString() && keyPathElements[i] == "length") {
+            int32_t length = v8Value.As<v8::String>()->Length();
+            v8Value = v8::Number::New(isolate, length);
+        } else if (!v8Value->IsObject()) {
             return nullptr;
+        } else {
+            v8::Local<v8::Object> object = v8Value.As<v8::Object>();
+            v8::Local<v8::String> key = v8String(isolate, keyPathElements[i]);
+            if (!v8CallBoolean(object->Has(context, key)))
+                return nullptr;
+            if (!v8Call(object->Get(context, key), v8Value, block)) {
+                exceptionState.rethrowV8Exception(block.Exception());
+                return nullptr;
+            }
+        }
     }
-    return createIDBKeyFromValue(isolate, currentValue, exceptionState, allowExperimentalTypes);
+    return createIDBKeyFromValue(isolate, v8Value, exceptionState, allowExperimentalTypes);
 }
 
 static IDBKey* createIDBKeyFromValueAndKeyPath(v8::Isolate* isolate, v8::Local<v8::Value> value, const IDBKeyPath& keyPath, ExceptionState& exceptionState, bool allowExperimentalTypes = false)
 {
     ASSERT(!keyPath.isNull());
     v8::HandleScope handleScope(isolate);
     if (keyPath.type() == IDBKeyPath::ArrayType) {
         IDBKey::KeyArray result;
         const Vector<String>& array = keyPath.array();
         for (size_t i = 0; i < array.size(); ++i) {
@@ skipping 74 matching lines @@
         ASSERT_NOT_REACHED();
         return false;
     }
 
     v8::HandleScope handleScope(isolate);
     v8::Local<v8::Context> context = isolate->GetCurrentContext();
 
     // For an object o = {} which should have keypath 'a.b.c' and key k, this
     // populates o to be {a:{b:{}}}. This is only applied to deserialized
     // values which were validated before serialization, so various
-    // assumptions can be made.
+    // assumptions can be made, e.g. there are no getters/setters on the
+    // object itself (though there might be on the prototype chain).
     for (size_t i = 0; i < keyPathElements.size() - 1; ++i) {
         const String& keyPathElement = keyPathElements[i];
         ASSERT(value->IsObject());
         ASSERT(!isImplicitProperty(isolate, value, keyPathElement));
         v8::Local<v8::Object> object = value.As<v8::Object>();
         v8::Local<v8::String> property = v8String(isolate, keyPathElement);
         bool hasOwnProperty;
         if (!v8Call(object->HasOwnProperty(context, property), hasOwnProperty))
             return false;
         if (hasOwnProperty) {
@@ skipping 120 matching lines @@
     ASSERT(!exceptionState.hadException());
     if (expectedKey && expectedKey->isEqual(value->primaryKey()))
         return;
 
     bool injected = injectV8KeyIntoV8Value(isolate, keyValue.v8Value(), scriptValue.v8Value(), value->keyPath());
     ASSERT_UNUSED(injected, injected);
 }
 #endif
 
 } // namespace blink