Distinguish null IDBKey (no value) and invalid IDBKey (value is not valid key)

content/browser/indexed_db/idbbindingutilities_browsertest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/bind.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/utility_process_host.h"
@@ skipping 19 matching lines @@
 
   ~ScopedShutdownWebKit() {
     WebKit::shutdown();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ScopedShutdownWebKit);
 };
 
 // Sanity test, check the function call directly outside the sandbox.
-// TODO(jsbell): Disabled to land WK76487; http://crbug.com/110956 has fix.
-TEST(IDBKeyPathWithoutSandbox, DISABLED_Value) {
+TEST(IDBKeyPathWithoutSandbox, Value) {
   content::WebKitPlatformSupportImpl webkit_platform_support;
   WebKit::initialize(&webkit_platform_support);
   ScopedShutdownWebKit shutdown_webkit;
 
-  char16 data[] = {0x0353,0x6f66,0x536f,0x7a03,0x6f6f,0x017b};
+  // {foo: "zoo"}
+  char16 data_foo_zoo[] = {0x0353,0x6f66,0x536f,0x7a03,0x6f6f,0x017b};
   std::vector<WebSerializedScriptValue> serialized_values;
   serialized_values.push_back(
-      WebSerializedScriptValue::fromString(string16(data, arraysize(data))));
+      WebSerializedScriptValue::fromString(string16(data_foo_zoo,
+                                                    arraysize(data_foo_zoo))));
+
+  // {foo: null}
+  char16 data_foo_null[] = {0x0353, 0x6f66, 0x306f, 0x017b};
+  serialized_values.push_back(content::SerializedScriptValue(
+      false, false, string16(data_foo_null, arraysize(data_foo_null))));
+
+  // {}
+  char16 data_object[] = {0x017b};
+  serialized_values.push_back(content::SerializedScriptValue(
+      false, false, string16(data_object, arraysize(data_object))));
+
+  // null
   serialized_values.push_back(
       WebSerializedScriptValue::fromString(string16()));
 
   std::vector<WebKit::WebIDBKey> values;
-  string16 key_path(UTF8ToUTF16("foo"));
-  bool error = webkit_glue::IDBKeysFromValuesAndKeyPath(
+  string16 key_path;
+  bool error;
+
+  key_path = UTF8ToUTF16("foo");
+  error = webkit_glue::IDBKeysFromValuesAndKeyPath(
       serialized_values, key_path, &values);
 
-  ASSERT_EQ(size_t(2), values.size());
+  ASSERT_EQ(size_t(4), values.size());
   ASSERT_EQ(WebKit::WebIDBKey::StringType, values[0].type());
   ASSERT_EQ(UTF8ToUTF16("zoo"), values[0].string());
   ASSERT_EQ(WebKit::WebIDBKey::InvalidType, values[1].type());
+  ASSERT_EQ(WebKit::WebIDBKey::NullType, values[2].type());
+  ASSERT_EQ(WebKit::WebIDBKey::NullType, values[3].type());
   ASSERT_FALSE(error);
 
   values.clear();
   key_path = UTF8ToUTF16("PropertyNotAvailable");
   error = webkit_glue::IDBKeysFromValuesAndKeyPath(
       serialized_values, key_path, &values);
 
-  ASSERT_EQ(size_t(2), values.size());
-  ASSERT_EQ(WebKit::WebIDBKey::InvalidType, values[0].type());
-  ASSERT_EQ(WebKit::WebIDBKey::InvalidType, values[1].type());
+  ASSERT_EQ(size_t(4), values.size());
+  ASSERT_EQ(WebKit::WebIDBKey::NullType, values[0].type());
+  ASSERT_EQ(WebKit::WebIDBKey::NullType, values[1].type());
+  ASSERT_EQ(WebKit::WebIDBKey::NullType, values[2].type());
+  ASSERT_EQ(WebKit::WebIDBKey::NullType, values[3].type());
   ASSERT_FALSE(error);
 
   values.clear();
   key_path = UTF8ToUTF16("!+Invalid[KeyPath[[[");
   error = webkit_glue::IDBKeysFromValuesAndKeyPath(
       serialized_values, key_path, &values);
 
   ASSERT_TRUE(error);
-  ASSERT_EQ(size_t(2), values.size());
-  ASSERT_EQ(WebKit::WebIDBKey::InvalidType, values[0].type());
-  ASSERT_EQ(WebKit::WebIDBKey::InvalidType, values[1].type());
+  ASSERT_EQ(size_t(4), values.size());
+  ASSERT_EQ(WebKit::WebIDBKey::NullType, values[0].type());
+  ASSERT_EQ(WebKit::WebIDBKey::NullType, values[1].type());
+  ASSERT_EQ(WebKit::WebIDBKey::NullType, values[2].type());
+  ASSERT_EQ(WebKit::WebIDBKey::NullType, values[3].type());
 }
 
 class IDBKeyPathHelper : public UtilityProcessHost::Client {
  public:
   IDBKeyPathHelper()
       : expected_id_(0),
         utility_process_host_(NULL),
         value_for_key_path_failed_(false) {
   }
 
@@ skipping 170 matching lines @@
                         const content::SerializedScriptValue& value,
                         const string16& key_path) {
     key_path_helper_->CheckInjectValue(key, value, key_path);
     ui_test_utils::RunMessageLoop();
   }
 
  private:
   scoped_refptr<IDBKeyPathHelper> key_path_helper_;
 };
 
+// Cases:
 IN_PROC_BROWSER_TEST_F(InProcessBrowserTest, IDBKeyPathExtract) {
   ScopedIDBKeyPathHelper scoped_helper;
   const int kId = 7;
   std::vector<IndexedDBKey> expected_keys;
-  IndexedDBKey value;
-  value.SetString(UTF8ToUTF16("zoo"));
-  expected_keys.push_back(value);
+  std::vector<content::SerializedScriptValue> serialized_values;
 
-  IndexedDBKey invalid_value;
-  invalid_value.SetInvalid();
-  expected_keys.push_back(invalid_value);
+  IndexedDBKey string_zoo_key;
+  string_zoo_key.SetString(UTF8ToUTF16("zoo"));
+  IndexedDBKey null_key;
+  null_key.SetNull();
+  IndexedDBKey invalid_key;
+  invalid_key.SetInvalid();
+
+  // keypath: "foo", value: {foo: "zoo"}, expected: "zoo"
+  char16 data_foo_zoo[] = {0x0353,0x6f66,0x536f,0x7a03,0x6f6f,0x017b};
+  serialized_values.push_back(content::SerializedScriptValue(
+      false, false, string16(data_foo_zoo, arraysize(data_foo_zoo))));
+  expected_keys.push_back(string_zoo_key);
+
+  // keypath: "foo", value: {foo: null}, expected: invalid
+  char16 data_foo_null[] = {0x0353, 0x6f66, 0x306f, 0x017b};
+  serialized_values.push_back(content::SerializedScriptValue(
+      false, false, string16(data_foo_null, arraysize(data_foo_null))));
+  expected_keys.push_back(invalid_key);
+
+  // keypath: "foo", value: {}, expected: null
+  char16 data_object[] = {0x017b};
+  serialized_values.push_back(content::SerializedScriptValue(
+      false, false, string16(data_object, arraysize(data_object))));
+  expected_keys.push_back(null_key);
+
+  // keypath: "foo", value: null, expected: null
+  serialized_values.push_back(
+      content::SerializedScriptValue(true, false, string16()));
+  expected_keys.push_back(null_key);
 
   scoped_helper.SetExpectedKeys(kId, expected_keys, false);
-
-  char16 data[] = {0x0353,0x6f66,0x536f,0x7a03,0x6f6f,0x017b};
-  std::vector<content::SerializedScriptValue> serialized_values;
-  serialized_values.push_back(content::SerializedScriptValue(
-      false, false, string16(data, arraysize(data))));
-  serialized_values.push_back(
-      content::SerializedScriptValue(true, false, string16()));
   scoped_helper.CheckValuesForKeyPath(
       kId, serialized_values, UTF8ToUTF16("foo"));
 }
 
 IN_PROC_BROWSER_TEST_F(InProcessBrowserTest, IDBKeyPathPropertyNotAvailable) {
   ScopedIDBKeyPathHelper scoped_helper;
   const int kId = 7;
   std::vector<IndexedDBKey> expected_keys;
-  IndexedDBKey invalid_value;
-  invalid_value.SetInvalid();
-  expected_keys.push_back(invalid_value);
-  expected_keys.push_back(invalid_value);
+  IndexedDBKey null_value;
+  null_value.SetNull();
+  expected_keys.push_back(null_value);
+  expected_keys.push_back(null_value);
 
   scoped_helper.SetExpectedKeys(kId, expected_keys, false);
 
-  char16 data[] = {0x0353,0x6f66,0x536f,0x7a03,0x6f6f,0x017b};
   std::vector<content::SerializedScriptValue> serialized_values;
+  // {foo: "zoo", bar: null}
+  char16 data[] = {0x0353, 0x6f66, 0x536f, 0x7a03, 0x6f6f, 0x0353, 0x6162,
+                   0x3072, 0x027b};
   serialized_values.push_back(content::SerializedScriptValue(
       false, false, string16(data, arraysize(data))));
+
+  // null
   serialized_values.push_back(
       content::SerializedScriptValue(true, false, string16()));
+
   scoped_helper.CheckValuesForKeyPath(kId, serialized_values,
                                       UTF8ToUTF16("PropertyNotAvailable"));
 }
 
 IN_PROC_BROWSER_TEST_F(InProcessBrowserTest, IDBKeyPathMultipleCalls) {
   ScopedIDBKeyPathHelper scoped_helper;
   const int kId = 7;
   std::vector<IndexedDBKey> expected_keys;
-  IndexedDBKey invalid_value;
-  invalid_value.SetInvalid();
-  expected_keys.push_back(invalid_value);
-  expected_keys.push_back(invalid_value);
 
+  IndexedDBKey null_value;
+  null_value.SetNull();
+  expected_keys.push_back(null_value);
+  expected_keys.push_back(null_value);
   scoped_helper.SetExpectedKeys(kId, expected_keys, true);
 
-  char16 data[] = {0x0353,0x6f66,0x536f,0x7a03,0x6f6f,0x017b};
   std::vector<content::SerializedScriptValue> serialized_values;
+
+  // {foo: "zoo", bar: null}
+  char16 data[] = {0x0353, 0x6f66, 0x536f, 0x7a03, 0x6f6f, 0x0353, 0x6162,
+                   0x3072, 0x027b};
   serialized_values.push_back(content::SerializedScriptValue(
       false, false, string16(data, arraysize(data))));
+
+  // null
   serialized_values.push_back(
       content::SerializedScriptValue(true, false, string16()));
+
   scoped_helper.CheckValuesForKeyPath(kId, serialized_values,
                                       UTF8ToUTF16("!+Invalid[KeyPath[[["));
 
   // Call again with the Utility process in batch mode and with valid keys.
   expected_keys.clear();
   IndexedDBKey value;
   value.SetString(UTF8ToUTF16("zoo"));
   expected_keys.push_back(value);
-  expected_keys.push_back(invalid_value);
+  expected_keys.push_back(null_value);
   scoped_helper.SetExpectedKeys(kId + 1, expected_keys, false);
   scoped_helper.CheckValuesForKeyPath(kId + 1, serialized_values,
                                       UTF8ToUTF16("foo"));
 }
 
 IN_PROC_BROWSER_TEST_F(InProcessBrowserTest, InjectIDBKey) {
   // {foo: 'zoo'}
   const char16 initial_data[] = {0x0353,0x6f66,0x536f,0x7a03,0x6f6f,0x017b};
   content::SerializedScriptValue value(
       false, false, string16(initial_data, arraysize(initial_data)));
@@ skipping 22 matching lines @@
                                    0x6f6f, 0x013f, 0x0353, 0x6f7a, 0x3f6f,
                                    0x5301, 0x6203, 0x7261, 0x013f, 0x3f6f,
                                    0x5302, 0x6203, 0x7a61, 0x023f, 0x0853,
                                    0x796d, 0x654e, 0x4b77, 0x7965, 0x017b,
                                    0x027b};
   content::SerializedScriptValue expected_value2(
       false, false, string16(expected_data2, arraysize(expected_data2)));
   scoped_helper.SetExpectedValue(expected_value2);
   scoped_helper.CheckInjectValue(key, value, UTF8ToUTF16("bar.baz"));
 }