Move IndexedDBKey, IndexedDBKeyRange into content namespace

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::IndexedDBKey;
 using content::IndexedDBKeyPath;
 using content::UtilityProcessHostClient;
+using content::SerializedScriptValue;
 
 // 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 std::vector<SerializedScriptValue>& values,
       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(
+  SerializedScriptValue InjectIDBKeyIntoSerializedValue(
       const IndexedDBKey& key,
-      const content::SerializedScriptValue& value,
+      const SerializedScriptValue& value,
       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);
 
     // IPC message handlers
     void OnIDBKeysFromValuesAndKeyPathSucceeded(
         int id, const std::vector<IndexedDBKey>& keys);
     void OnIDBKeysFromValuesAndKeyPathFailed(int id);
-    void OnInjectIDBKeyFinished(const content::SerializedScriptValue& value);
+    void OnInjectIDBKeyFinished(const SerializedScriptValue& value);
 
    private:
     virtual ~Client() {}
 
     KeyUtilityClientImpl* parent_;
 
     DISALLOW_COPY_AND_ASSIGN(Client);
   };
 
   friend class base::RefCountedThreadSafe<KeyUtilityClientImpl>;
   ~KeyUtilityClientImpl();
 
   void GetRDHAndStartUtilityProcess();
   void StartUtilityProcessInternal();
   void EndUtilityProcessInternal();
   void CallStartIDBKeyFromValueAndKeyPathFromIOThread(
-      const std::vector<content::SerializedScriptValue>& values,
+      const std::vector<SerializedScriptValue>& values,
       const IndexedDBKeyPath& key_path);
   void CallStartInjectIDBKeyFromIOThread(
       const IndexedDBKey& key,
-      const content::SerializedScriptValue& value,
+      const SerializedScriptValue& value,
       const IndexedDBKeyPath& key_path);
 
   void SetKeys(const std::vector<IndexedDBKey>& keys);
   void FinishCreatingKeys();
-  void SetValueAfterInjection(const content::SerializedScriptValue& value);
+  void SetValueAfterInjection(const 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.
   enum State {
     STATE_UNINITIALIZED,
     STATE_INITIALIZED,
     STATE_CREATING_KEYS,
     STATE_INJECTING_KEY,
     STATE_SHUTDOWN,
   };
   State state_;
   std::vector<IndexedDBKey> keys_;
-  content::SerializedScriptValue value_after_injection_;
+  SerializedScriptValue value_after_injection_;
 
   // Used in the IO thread.
   base::WeakPtr<content::UtilityProcessHost> utility_process_host_;
   scoped_refptr<Client> client_;
 
   DISALLOW_COPY_AND_ASSIGN(KeyUtilityClientImpl);
 };
 
 // IndexedDBKeyUtilityClient definitions.
 
@@ skipping 15 matching lines @@
   IndexedDBKeyUtilityClient* instance = client_instance.Pointer();
   if (!instance->impl_)
     return;
 
   instance->is_shutdown_ = true;
   instance->impl_->Shutdown();
 }
 
 //  static
 void IndexedDBKeyUtilityClient::CreateIDBKeysFromSerializedValuesAndKeyPath(
-      const std::vector<content::SerializedScriptValue>& values,
+      const std::vector<SerializedScriptValue>& values,
       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
+SerializedScriptValue
 IndexedDBKeyUtilityClient::InjectIDBKeyIntoSerializedValue(
-    const IndexedDBKey& key, const content::SerializedScriptValue& value,
+    const IndexedDBKey& key, const SerializedScriptValue& value,
     const IndexedDBKeyPath& key_path) {
   IndexedDBKeyUtilityClient* instance = client_instance.Pointer();
 
   if (instance->is_shutdown_)
-    return content::SerializedScriptValue();
+    return SerializedScriptValue();
 
   if (!instance->impl_) {
     instance->impl_ = new KeyUtilityClientImpl();
     instance->impl_->StartUtilityProcess();
   }
 
   return instance->impl_->InjectIDBKeyIntoSerializedValue(key, value, key_path);
 }
 
 
@@ skipping 26 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   DCHECK(state_ == STATE_UNINITIALIZED);
 
   GetRDHAndStartUtilityProcess();
   waitable_event_.Wait();
 
   DCHECK(state_ == STATE_INITIALIZED);
 }
 
 void KeyUtilityClientImpl::CreateIDBKeysFromSerializedValuesAndKeyPath(
-    const std::vector<content::SerializedScriptValue>& values,
+    const std::vector<SerializedScriptValue>& values,
     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(
+SerializedScriptValue KeyUtilityClientImpl::InjectIDBKeyIntoSerializedValue(
         const IndexedDBKey& key,
-        const content::SerializedScriptValue& value,
+        const SerializedScriptValue& value,
         const IndexedDBKeyPath& key_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   if (state_ == STATE_SHUTDOWN)
-    return content::SerializedScriptValue();
+    return SerializedScriptValue();
 
   DCHECK(state_ == STATE_INITIALIZED);
 
   state_ = STATE_INJECTING_KEY;
   CallStartInjectIDBKeyFromIOThread(key, value, key_path);
 
   waitable_event_.Wait();
   DCHECK(state_ == STATE_INITIALIZED);
 
   return value_after_injection_;
@@ skipping 47 matching lines @@
   if (utility_process_host_) {
     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 std::vector<SerializedScriptValue>& values,
     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 SerializedScriptValue& value,
     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_)
     utility_process_host_->Send(new UtilityMsg_InjectIDBKey(
         key, value, key_path));
 }
 
 void KeyUtilityClientImpl::SetKeys(const std::vector<IndexedDBKey>& keys) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   keys_ = keys;
 }
 
 void KeyUtilityClientImpl::FinishCreatingKeys() {
   DCHECK(state_ == STATE_CREATING_KEYS);
   state_ = STATE_INITIALIZED;
   waitable_event_.Signal();
 }
 
 void KeyUtilityClientImpl::SetValueAfterInjection(
-    const content::SerializedScriptValue& value) {
+    const SerializedScriptValue& value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   value_after_injection_ = value;
 }
 
 void KeyUtilityClientImpl::FinishInjectingKey() {
   DCHECK(state_ == STATE_INJECTING_KEY);
   state_ = STATE_INITIALIZED;
   waitable_event_.Signal();
 }
 
@@ skipping 20 matching lines @@
   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) {
+    const SerializedScriptValue& value) {
   parent_->SetValueAfterInjection(value);
   parent_->FinishInjectingKey();
 }
 
 void KeyUtilityClientImpl::Client::OnIDBKeysFromValuesAndKeyPathFailed(
     int id) {
   parent_->FinishCreatingKeys();
 }