Use WebIDBKeyPath type in WebKit API, implement IndexedDBKeyPath type.

content/browser/in_process_webkit/indexed_db_key_utility_client.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 "content/browser/in_process_webkit/indexed_db_key_utility_client.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/synchronization/waitable_event.h"
 #include "content/browser/utility_process_host_impl.h"
 #include "content/common/indexed_db/indexed_db_key.h"
+#include "content/common/indexed_db/indexed_db_key_path.h"
 #include "content/common/indexed_db/indexed_db_messages.h"
 #include "content/common/utility_messages.h"
 #include "content/public/browser/utility_process_host_client.h"
 #include "content/public/common/serialized_script_value.h"
 
 using content::BrowserThread;
 using content::UtilityProcessHostClient;
 
 // This class is used to obtain IndexedDBKeys from SerializedScriptValues
 // given an IDBKeyPath. It uses UtilityProcess to do this inside a sandbox
 // (a V8 lock is required there). At this level, all methods are synchronous
 // as required by the caller. The public API is used on WEBKIT thread,
 // but internally it moves around to UI and IO as needed.
 class KeyUtilityClientImpl
     : public base::RefCountedThreadSafe<KeyUtilityClientImpl> {
  public:
   KeyUtilityClientImpl();
 
   // Starts the UtilityProcess. Must be called before any other method.
   void StartUtilityProcess();
 
   // Stops the UtilityProcess. No further keys can be created after this.
   void Shutdown();
 
   // Synchronously obtain the |keys| from |values| for the given |key_path|.
   void CreateIDBKeysFromSerializedValuesAndKeyPath(
       const std::vector<content::SerializedScriptValue>& values,
-      const string16& key_path,
+      const IndexedDBKeyPath& key_path,
       std::vector<IndexedDBKey>* keys);
 
   // Synchronously inject |key| into |value| using the given |key_path|,
   // returning the new value.
   content::SerializedScriptValue InjectIDBKeyIntoSerializedValue(
       const IndexedDBKey& key,
       const content::SerializedScriptValue& value,
-      const string16& key_path);
+      const IndexedDBKeyPath& key_path);
 
  private:
   class Client : public UtilityProcessHostClient {
    public:
     explicit Client(KeyUtilityClientImpl* parent);
 
     // UtilityProcessHostClient
     virtual void OnProcessCrashed(int exit_code);
     virtual bool OnMessageReceived(const IPC::Message& message);
 
@@ skipping 10 matching lines @@
   };
 
   friend class base::RefCountedThreadSafe<KeyUtilityClientImpl>;
   ~KeyUtilityClientImpl();
 
   void GetRDHAndStartUtilityProcess();
   void StartUtilityProcessInternal();
   void EndUtilityProcessInternal();
   void CallStartIDBKeyFromValueAndKeyPathFromIOThread(
       const std::vector<content::SerializedScriptValue>& values,
-      const string16& key_path);
+      const IndexedDBKeyPath& key_path);
   void CallStartInjectIDBKeyFromIOThread(
       const IndexedDBKey& key,
       const content::SerializedScriptValue& value,
-      const string16& key_path);
+      const IndexedDBKeyPath& key_path);
 
   void SetKeys(const std::vector<IndexedDBKey>& keys);
   void FinishCreatingKeys();
   void SetValueAfterInjection(const content::SerializedScriptValue& value);
   void FinishInjectingKey();
 
   base::WaitableEvent waitable_event_;
 
   // Used in both IO and WEBKIT threads, but guarded by WaitableEvent, i.e.,
   // these members are only set / read when the other thread is blocked.
@@ skipping 36 matching lines @@
   if (!instance->impl_)
     return;
 
   instance->is_shutdown_ = true;
   instance->impl_->Shutdown();
 }
 
 //  static
 void IndexedDBKeyUtilityClient::CreateIDBKeysFromSerializedValuesAndKeyPath(
       const std::vector<content::SerializedScriptValue>& values,
-      const string16& key_path,
+      const IndexedDBKeyPath& key_path,
       std::vector<IndexedDBKey>* keys) {
   IndexedDBKeyUtilityClient* instance = client_instance.Pointer();
 
   if (instance->is_shutdown_) {
     keys->clear();
     return;
   }
 
   if (!instance->impl_) {
     instance->impl_ = new KeyUtilityClientImpl();
     instance->impl_->StartUtilityProcess();
   }
 
   instance->impl_->CreateIDBKeysFromSerializedValuesAndKeyPath(values, key_path,
                                                                keys);
 }
 
 //  static
 content::SerializedScriptValue
 IndexedDBKeyUtilityClient::InjectIDBKeyIntoSerializedValue(
     const IndexedDBKey& key, const content::SerializedScriptValue& value,
-    const string16& key_path) {
+    const IndexedDBKeyPath& key_path) {
   IndexedDBKeyUtilityClient* instance = client_instance.Pointer();
 
   if (instance->is_shutdown_)
     return content::SerializedScriptValue();
 
   if (!instance->impl_) {
     instance->impl_ = new KeyUtilityClientImpl();
     instance->impl_->StartUtilityProcess();
   }
 
@@ skipping 31 matching lines @@
   DCHECK(state_ == STATE_UNINITIALIZED);
 
   GetRDHAndStartUtilityProcess();
   waitable_event_.Wait();
 
   DCHECK(state_ == STATE_INITIALIZED);
 }
 
 void KeyUtilityClientImpl::CreateIDBKeysFromSerializedValuesAndKeyPath(
     const std::vector<content::SerializedScriptValue>& values,
-    const string16& key_path,
+    const IndexedDBKeyPath& key_path,
     std::vector<IndexedDBKey>* keys) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   if (state_ == STATE_SHUTDOWN) {
     keys->clear();
     return;
   }
 
   DCHECK(state_ == STATE_INITIALIZED);
 
   state_ = STATE_CREATING_KEYS;
   CallStartIDBKeyFromValueAndKeyPathFromIOThread(values, key_path);
   waitable_event_.Wait();
   DCHECK(state_ == STATE_INITIALIZED);
 
   *keys = keys_;
 }
 
 content::SerializedScriptValue
     KeyUtilityClientImpl::InjectIDBKeyIntoSerializedValue(
         const IndexedDBKey& key,
         const content::SerializedScriptValue& value,
-        const string16& key_path) {
+        const IndexedDBKeyPath& key_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   if (state_ == STATE_SHUTDOWN)
     return content::SerializedScriptValue();
 
   DCHECK(state_ == STATE_INITIALIZED);
 
   state_ = STATE_INJECTING_KEY;
   CallStartInjectIDBKeyFromIOThread(key, value, key_path);
 
   waitable_event_.Wait();
@@ skipping 51 matching lines @@
     utility_process_host_->EndBatchMode();
     utility_process_host_.reset();
   }
   client_ = NULL;
   state_ = STATE_SHUTDOWN;
   waitable_event_.Signal();
 }
 
 void KeyUtilityClientImpl::CallStartIDBKeyFromValueAndKeyPathFromIOThread(
     const std::vector<content::SerializedScriptValue>& values,
-    const string16& key_path) {
+    const IndexedDBKeyPath& key_path) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&KeyUtilityClientImpl::
             CallStartIDBKeyFromValueAndKeyPathFromIOThread,
                    this, values, key_path));
     return;
   }
 
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (utility_process_host_) {
     utility_process_host_->Send(new UtilityMsg_IDBKeysFromValuesAndKeyPath(
         0, values, key_path));
   }
 }
 
 void KeyUtilityClientImpl::CallStartInjectIDBKeyFromIOThread(
     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(&KeyUtilityClientImpl::CallStartInjectIDBKeyFromIOThread,
                    this, key, value, key_path));
     return;
   }
 
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (utility_process_host_)
@@ skipping 33 matching lines @@
     parent_->FinishCreatingKeys();
   parent_->Shutdown();
 }
 
 bool KeyUtilityClientImpl::Client::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(KeyUtilityClientImpl::Client, message)
     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()
   return handled;
 }
 
 void KeyUtilityClientImpl::Client::OnIDBKeysFromValuesAndKeyPathSucceeded(
     int id, const std::vector<IndexedDBKey>& keys) {
   parent_->SetKeys(keys);
   parent_->FinishCreatingKeys();
 }
 
 void KeyUtilityClientImpl::Client::OnInjectIDBKeyFinished(
     const content::SerializedScriptValue& value) {
   parent_->SetValueAfterInjection(value);
   parent_->FinishInjectingKey();
 }
 
 void KeyUtilityClientImpl::Client::OnIDBKeysFromValuesAndKeyPathFailed(
     int id) {
   parent_->FinishCreatingKeys();
 }