Move webkit/{browser,common}/dom_storage into content/

content/browser/dom_storage/session_storage_database.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 "webkit/browser/dom_storage/session_storage_database.h"
+#include "content/browser/dom_storage/session_storage_database.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/iterator.h"
 #include "third_party/leveldatabase/src/include/leveldb/options.h"
@@ skipping 26 matching lines @@
 // | namespace-1-origin1            | 1 (mapid)                          |
 // | namespace-1-origin2            | 2                                  |
 // | namespace-2-                   | dummy                              |
 // | namespace-2-origin1            | 1 (shallow copy)                   |
 // | namespace-2-origin2            | 2 (shallow copy)                   |
 // | namespace-3-                   | dummy                              |
 // | namespace-3-origin1            | 3 (deep copy)                      |
 // | namespace-3-origin2            | 2 (shallow copy)                   |
 // | next-map-id                    | 4                                  |
 
-namespace dom_storage {
+namespace content {
 
 SessionStorageDatabase::SessionStorageDatabase(const base::FilePath& file_path)
     : file_path_(file_path),
       db_error_(false),
       is_inconsistent_(false) {
 }
 
 SessionStorageDatabase::~SessionStorageDatabase() {
 }
 
 void SessionStorageDatabase::ReadAreaValues(const std::string& namespace_id,
                                             const GURL& origin,
-                                            ValuesMap* result) {
+                                            DOMStorageValuesMap* result) {
   // We don't create a database if it doesn't exist. In that case, there is
   // nothing to be added to the result.
   if (!LazyOpen(false))
     return;
 
   // While ReadAreaValues is in progress, another thread can call
   // CommitAreaChanges. CommitAreaChanges might update map ref count key while
   // this thread is iterating over the map ref count key. To protect the reading
   // operation, create a snapshot and read from it.
   leveldb::ReadOptions options;
   options.snapshot = db_->GetSnapshot();
 
   std::string map_id;
   bool exists;
   if (GetMapForArea(namespace_id, origin.spec(), options, &exists, &map_id) &&
       exists)
     ReadMap(map_id, options, result, false);
   db_->ReleaseSnapshot(options.snapshot);
 }
 
-bool SessionStorageDatabase::CommitAreaChanges(const std::string& namespace_id,
-                                               const GURL& origin,
-                                               bool clear_all_first,
-                                               const ValuesMap& changes) {
+bool SessionStorageDatabase::CommitAreaChanges(
+    const std::string& namespace_id,
+    const GURL& origin,
+    bool clear_all_first,
+    const DOMStorageValuesMap& changes) {
   // Even if |changes| is empty, we need to write the appropriate placeholders
   // in the database, so that it can be later shallow-copied succssfully.
   if (!LazyOpen(true))
     return false;
 
   leveldb::WriteBatch batch;
   // Ensure that the keys "namespace-" "namespace-N" (see the schema above)
   // exist.
   const bool kOkIfExists = true;
   if (!CreateNamespace(namespace_id, kOkIfExists, &batch))
@@ skipping 395 matching lines @@
   }
   batch->Put(next_map_id_key, base::Int64ToString(++next_map_id));
   std::string namespace_key = NamespaceKey(namespace_id, origin.spec());
   batch->Put(namespace_key, *map_id);
   batch->Put(MapRefCountKey(*map_id), "1");
   return true;
 }
 
 bool SessionStorageDatabase::ReadMap(const std::string& map_id,
                                      const leveldb::ReadOptions& options,
-                                     ValuesMap* result,
+                                     DOMStorageValuesMap* result,
                                      bool only_keys) {
   scoped_ptr<leveldb::Iterator> it(db_->NewIterator(options));
   std::string map_start_key = MapRefCountKey(map_id);
   it->Seek(map_start_key);
   // If the key is not found, the status of the iterator won't be IsNotFound(),
   // but the iterator will be invalid. The map needs to exist, otherwise we have
   // a stale map_id in the database.
   if (!ConsistencyCheck(it->Valid()))
     return false;
   if (!DatabaseErrorCheck(it->status().ok()))
@@ skipping 16 matching lines @@
       const char16* data_ptr =
           reinterpret_cast<const char16*>(it->value().data());
       (*result)[key16] =
           base::NullableString16(base::string16(data_ptr, len), false);
     }
   }
   return true;
 }
 
 void SessionStorageDatabase::WriteValuesToMap(const std::string& map_id,
-                                              const ValuesMap& values,
+                                              const DOMStorageValuesMap& values,
                                               leveldb::WriteBatch* batch) {
-  for (ValuesMap::const_iterator it = values.begin(); it != values.end();
+  for (DOMStorageValuesMap::const_iterator it = values.begin();
+       it != values.end();
        ++it) {
     base::NullableString16 value = it->second;
     std::string key = MapKey(map_id, UTF16ToUTF8(it->first));
     if (value.is_null()) {
       batch->Delete(key);
     } else {
       // Convert the raw data stored in base::string16 to raw data stored in
       // std::string.
       const char* data = reinterpret_cast<const char*>(value.string().data());
       size_t size = value.string().size() * 2;
@@ skipping 39 matching lines @@
     // Clear all keys in the map.
     if (!ClearMap(map_id, batch))
       return false;
     batch->Delete(MapRefCountKey(map_id));
   }
   return true;
 }
 
 bool SessionStorageDatabase::ClearMap(const std::string& map_id,
                                       leveldb::WriteBatch* batch) {
-  ValuesMap values;
+  DOMStorageValuesMap values;
   if (!ReadMap(map_id, leveldb::ReadOptions(), &values, true))
     return false;
-  for (ValuesMap::const_iterator it = values.begin(); it != values.end(); ++it)
+  for (DOMStorageValuesMap::const_iterator it = values.begin();
+       it != values.end(); ++it)
     batch->Delete(MapKey(map_id, UTF16ToUTF8(it->first)));
   return true;
 }
 
 bool SessionStorageDatabase::DeepCopyArea(
     const std::string& namespace_id, const GURL& origin, bool copy_data,
     std::string* map_id, leveldb::WriteBatch* batch) {
   // Example, data before deep copy:
   // | namespace-1- (1 = namespace id)| dummy               |
   // | namespace-1-origin1            | 1 (mapid)           |
   // | namespace-2-                   | dummy               |
   // | namespace-2-origin1            | 1 (mapid) << references the same map
   // | map-1-                         | 2 (refcount)        |
   // | map-1-a                        | b                   |
 
   // Example, data after deep copy copy:
   // | namespace-1-(1 = namespace id) | dummy               |
   // | namespace-1-origin1            | 1 (mapid)           |
   // | namespace-2-                   | dummy               |
   // | namespace-2-origin1            | 2 (mapid) << references the new map
   // | map-1-                         | 1 (dec. refcount)   |
   // | map-1-a                        | b                   |
   // | map-2-                         | 1 (refcount)        |
   // | map-2-a                        | b                   |
 
   // Read the values from the old map here. If we don't need to copy the data,
   // this can stay empty.
-  ValuesMap values;
+  DOMStorageValuesMap values;
   if (copy_data && !ReadMap(*map_id, leveldb::ReadOptions(), &values, false))
     return false;
   if (!DecreaseMapRefCount(*map_id, 1, batch))
     return false;
   // Create a new map (this will also break the association to the old map) and
   // write the old data into it. This will write the id of the created map into
   // |map_id|.
   if (!CreateMapForArea(namespace_id, origin, map_id, batch))
     return false;
   WriteValuesToMap(*map_id, values, batch);
@@ skipping 21 matching lines @@
 
 std::string SessionStorageDatabase::MapKey(const std::string& map_id,
                                            const std::string& key) {
   return base::StringPrintf("map-%s-%s", map_id.c_str(), key.c_str());
 }
 
 const char* SessionStorageDatabase::NextMapIdKey() {
   return "next-map-id";
 }
 
-}  // namespace dom_storage
+}  // namespace content