Use WebIDBKeyPath type in WebKit API, implement IndexedDBKeyPath type.

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/utility_process_host_impl.h"
 #include "content/public/browser/utility_process_host_client.h"
 #include "content/common/indexed_db/indexed_db_key.h"
+#include "content/common/indexed_db/indexed_db_key_path.h"
 #include "content/common/utility_messages.h"
 #include "content/common/webkitplatformsupport_impl.h"
 #include "content/public/common/serialized_script_value.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKit.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebSerializedScriptValue.h"
 #include "webkit/glue/idb_bindings.h"
 #include "webkit/glue/web_io_operators.h"
 
 using content::BrowserThread;
 using content::UtilityProcessHost;
 using content::UtilityProcessHostClient;
 using WebKit::WebSerializedScriptValue;
+using WebKit::WebIDBKeyPath;
 
 // Enables calling WebKit::shutdown no matter where a "return" happens.
 class ScopedShutdownWebKit {
  public:
   ScopedShutdownWebKit() {
   }
 
   ~ScopedShutdownWebKit() {
     WebKit::shutdown();
   }
@@ skipping 23 matching lines @@
   // {}
   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;
-  bool error;
+  IndexedDBKeyPath key_path;
 
-  key_path = UTF8ToUTF16("foo");
-  error = webkit_glue::IDBKeysFromValuesAndKeyPath(
+  key_path.SetString(UTF8ToUTF16("foo"));
+  webkit_glue::IDBKeysFromValuesAndKeyPath(
       serialized_values, key_path, &values);
 
   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(
+  key_path.SetString(UTF8ToUTF16("PropertyNotAvailable"));
+  webkit_glue::IDBKeysFromValuesAndKeyPath(
       serialized_values, key_path, &values);
 
   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(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());
+  key_path.SetString(UTF8ToUTF16("!+Invalid[KeyPath[[["));
+  ASSERT_FALSE(key_path.IsValid());
 }
 
 class IDBKeyPathHelper : public UtilityProcessHostClient {
  public:
   IDBKeyPathHelper()
       : expected_id_(0),
         value_for_key_path_failed_(false) {
   }
 
   void CreateUtilityProcess() {
@@ skipping 34 matching lines @@
     value_for_key_path_failed_ = failed;
   }
 
   void SetExpectedValue(const content::SerializedScriptValue& expected_value) {
     expected_value_ = expected_value;
   }
 
   void CheckValuesForKeyPath(
       int id,
       const std::vector<content::SerializedScriptValue>& serialized_values,
-      const string16& key_path) {
+      const IndexedDBKeyPath& key_path) {
     if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(&IDBKeyPathHelper::CheckValuesForKeyPath, this, id,
                      serialized_values, key_path));
       return;
     }
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     bool ret = utility_process_host_->Send(
         new UtilityMsg_IDBKeysFromValuesAndKeyPath(
             id, serialized_values, key_path));
     ASSERT_TRUE(ret);
   }
 
   void CheckInjectValue(const IndexedDBKey& key,
                         const content::SerializedScriptValue& value,
-                        const string16& key_path) {
+                        const IndexedDBKeyPath& key_path) {
     if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(&IDBKeyPathHelper::CheckInjectValue, this, key, value,
                      key_path));
       return;
     }
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     bool ret = utility_process_host_->Send(new UtilityMsg_InjectIDBKey(
         key, value, key_path));
     ASSERT_TRUE(ret);
   }
 
   // UtilityProcessHostClient
   bool OnMessageReceived(const IPC::Message& message) {
     bool msg_is_ok = true;
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP_EX(IDBKeyPathHelper, message, msg_is_ok)
       IPC_MESSAGE_HANDLER(UtilityHostMsg_IDBKeysFromValuesAndKeyPath_Succeeded,
                           OnIDBKeysFromValuesAndKeyPathSucceeded)
-      IPC_MESSAGE_HANDLER(UtilityHostMsg_IDBKeysFromValuesAndKeyPath_Failed,
-                          OnIDBKeysFromValuesAndKeyPathFailed)
       IPC_MESSAGE_HANDLER(UtilityHostMsg_InjectIDBKey_Finished,
                           OnInjectIDBKeyFinished)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP_EX()
     return handled;
   }
 
   void OnIDBKeysFromValuesAndKeyPathSucceeded(
       int id, const std::vector<IndexedDBKey>& values) {
     EXPECT_EQ(expected_id_, id);
@@ skipping 58 matching lines @@
   }
 
   void SetExpectedValue(const content::SerializedScriptValue& expected_value) {
     key_path_helper_->SetExpectedValue(expected_value);
   }
 
   void CheckValuesForKeyPath(
       int id,
       const std::vector<content::SerializedScriptValue>&
           serialized_script_values,
-      const string16& key_path) {
+      const IndexedDBKeyPath& key_path) {
     key_path_helper_->CheckValuesForKeyPath(id, serialized_script_values,
                                             key_path);
     ui_test_utils::RunMessageLoop();
   }
 
   void CheckInjectValue(const IndexedDBKey& key,
                         const content::SerializedScriptValue& value,
-                        const string16& key_path) {
+                        const IndexedDBKeyPath& 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) {
@@ skipping 26 matching lines @@
   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);
+
+  IndexedDBKeyPath key_path;
+  key_path.SetString(UTF8ToUTF16("foo"));
   scoped_helper.CheckValuesForKeyPath(
-      kId, serialized_values, UTF8ToUTF16("foo"));
+      kId, serialized_values, key_path);
 }
 
 IN_PROC_BROWSER_TEST_F(InProcessBrowserTest, IDBKeyPathPropertyNotAvailable) {
   ScopedIDBKeyPathHelper scoped_helper;
   const int kId = 7;
   std::vector<IndexedDBKey> expected_keys;
   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);
 
   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"));
+  IndexedDBKeyPath key_path;
+  key_path.SetString(UTF8ToUTF16("PropertyNotAvailable"));
+  scoped_helper.CheckValuesForKeyPath(kId, serialized_values, key_path);
 }
 
 IN_PROC_BROWSER_TEST_F(InProcessBrowserTest, IDBKeyPathMultipleCalls) {
   ScopedIDBKeyPathHelper scoped_helper;
   const int kId = 7;
   std::vector<IndexedDBKey> expected_keys;
 
   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);
+  scoped_helper.SetExpectedKeys(kId, expected_keys, false);
 
   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[[["));
+  IndexedDBKeyPath key_path;
+  key_path.SetString(UTF8ToUTF16("PropertyNotAvailable"));
+  scoped_helper.CheckValuesForKeyPath(kId, serialized_values, key_path);
 
   // 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(null_value);
   scoped_helper.SetExpectedKeys(kId + 1, expected_keys, false);
-  scoped_helper.CheckValuesForKeyPath(kId + 1, serialized_values,
-                                      UTF8ToUTF16("foo"));
+  key_path.SetString(UTF8ToUTF16("foo"));
+  scoped_helper.CheckValuesForKeyPath(kId + 1, serialized_values, key_path);
 }
 
 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)));
   IndexedDBKey key;
   key.SetString(UTF8ToUTF16("myNewKey"));
 
   ScopedIDBKeyPathHelper scoped_helper;
 
   // {foo: 'zoo', bar: 'myNewKey'}
   const char16 expected_data[] = {0x01ff, 0x003f, 0x3f6f, 0x5301, 0x6603,
                                   0x6f6f, 0x013f, 0x0353, 0x6f7a, 0x3f6f,
                                   0x5301, 0x6203, 0x7261, 0x013f, 0x0853,
                                   0x796d, 0x654e, 0x4b77, 0x7965, 0x027b};
   content::SerializedScriptValue expected_value(
       false, false, string16(expected_data, arraysize(expected_data)));
   scoped_helper.SetExpectedValue(expected_value);
-  scoped_helper.CheckInjectValue(key, value, UTF8ToUTF16("bar"));
+  IndexedDBKeyPath key_path;
+  key_path.SetString(UTF8ToUTF16("bar"));
+  scoped_helper.CheckInjectValue(key, value, key_path);
 
   // Should fail - can't apply properties to string value of key foo
   const content::SerializedScriptValue failure_value;
   scoped_helper.SetExpectedValue(failure_value);
-  scoped_helper.CheckInjectValue(key, value, UTF8ToUTF16("foo.bad.path"));
+  key_path.SetString(UTF8ToUTF16("foo.bad.path"));
+  scoped_helper.CheckInjectValue(key, value, key_path);
 
   // {foo: 'zoo', bar: {baz: 'myNewKey'}}
   const char16 expected_data2[] = {0x01ff, 0x003f, 0x3f6f, 0x5301, 0x6603,
                                    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"));
+  key_path.SetString(UTF8ToUTF16("bar.baz"));
+  scoped_helper.CheckInjectValue(key, value, key_path);
 }