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

content/browser/dom_storage/dom_storage_namespace.cc

Index: content/browser/dom_storage/dom_storage_namespace.cc
diff --git a/webkit/browser/dom_storage/dom_storage_namespace.cc b/content/browser/dom_storage/dom_storage_namespace.cc
similarity index 69%
rename from webkit/browser/dom_storage/dom_storage_namespace.cc
rename to content/browser/dom_storage/dom_storage_namespace.cc
index fe3195bcbbfe811d03fc0b1e13914bb82b27122e..d7c595555dc59c40376b693410d9f9d27c1a1c1f 100644
--- a/webkit/browser/dom_storage/dom_storage_namespace.cc
+++ b/content/browser/dom_storage/dom_storage_namespace.cc
@@ -2,32 +2,32 @@
 // 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/dom_storage_namespace.h"
+#include "content/browser/dom_storage/dom_storage_namespace.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
-#include "webkit/browser/dom_storage/dom_storage_area.h"
-#include "webkit/browser/dom_storage/dom_storage_task_runner.h"
-#include "webkit/browser/dom_storage/session_storage_database.h"
-#include "webkit/common/dom_storage/dom_storage_types.h"
+#include "content/browser/dom_storage/dom_storage_area.h"
+#include "content/browser/dom_storage/dom_storage_task_runner.h"
+#include "content/browser/dom_storage/session_storage_database.h"
+#include "content/common/dom_storage/dom_storage_types.h"
 
-namespace dom_storage {
+namespace content {
 
-DomStorageNamespace::DomStorageNamespace(
+DOMStorageNamespace::DOMStorageNamespace(
     const base::FilePath& directory,
-    DomStorageTaskRunner* task_runner)
+    DOMStorageTaskRunner* task_runner)
     : namespace_id_(kLocalStorageNamespaceId),
       directory_(directory),
       task_runner_(task_runner) {
 }
 
-DomStorageNamespace::DomStorageNamespace(
+DOMStorageNamespace::DOMStorageNamespace(
     int64 namespace_id,
     const std::string& persistent_namespace_id,
     SessionStorageDatabase* session_storage_database,
-    DomStorageTaskRunner* task_runner)
+    DOMStorageTaskRunner* task_runner)
     : namespace_id_(namespace_id),
       persistent_namespace_id_(persistent_namespace_id),
       task_runner_(task_runner),
@@ -35,19 +35,19 @@ DomStorageNamespace::DomStorageNamespace(
   DCHECK_NE(kLocalStorageNamespaceId, namespace_id);
 }
 
-DomStorageNamespace::~DomStorageNamespace() {
+DOMStorageNamespace::~DOMStorageNamespace() {
 }
 
-DomStorageArea* DomStorageNamespace::OpenStorageArea(const GURL& origin) {
+DOMStorageArea* DOMStorageNamespace::OpenStorageArea(const GURL& origin) {
   if (AreaHolder* holder = GetAreaHolder(origin)) {
     ++(holder->open_count_);
     return holder->area_.get();
   }
-  DomStorageArea* area;
+  DOMStorageArea* area;
   if (namespace_id_ == kLocalStorageNamespaceId) {
-    area = new DomStorageArea(origin, directory_, task_runner_.get());
+    area = new DOMStorageArea(origin, directory_, task_runner_.get());
   } else {
-    area = new DomStorageArea(
+    area = new DOMStorageArea(
         namespace_id_, persistent_namespace_id_, origin,
         session_storage_database_.get(), task_runner_.get());
   }
@@ -55,7 +55,7 @@ DomStorageArea* DomStorageNamespace::OpenStorageArea(const GURL& origin) {
   return area;
 }
 
-void DomStorageNamespace::CloseStorageArea(DomStorageArea* area) {
+void DOMStorageNamespace::CloseStorageArea(DOMStorageArea* area) {
   AreaHolder* holder = GetAreaHolder(area->origin());
   DCHECK(holder);
   DCHECK_EQ(holder->area_.get(), area);
@@ -64,25 +64,25 @@ void DomStorageNamespace::CloseStorageArea(DomStorageArea* area) {
   // The in-process-webkit based impl didn't do this either, but would be nice.
 }
 
-DomStorageArea* DomStorageNamespace::GetOpenStorageArea(const GURL& origin) {
+DOMStorageArea* DOMStorageNamespace::GetOpenStorageArea(const GURL& origin) {
   AreaHolder* holder = GetAreaHolder(origin);
   if (holder && holder->open_count_)
     return holder->area_.get();
   return NULL;
 }
 
-DomStorageNamespace* DomStorageNamespace::Clone(
+DOMStorageNamespace* DOMStorageNamespace::Clone(
     int64 clone_namespace_id,
     const std::string& clone_persistent_namespace_id) {
   DCHECK_NE(kLocalStorageNamespaceId, namespace_id_);
   DCHECK_NE(kLocalStorageNamespaceId, clone_namespace_id);
-  DomStorageNamespace* clone = new DomStorageNamespace(
+  DOMStorageNamespace* clone = new DOMStorageNamespace(
       clone_namespace_id, clone_persistent_namespace_id,
       session_storage_database_.get(), task_runner_.get());
   AreaMap::const_iterator it = areas_.begin();
   // Clone the in-memory structures.
   for (; it != areas_.end(); ++it) {
-    DomStorageArea* area = it->second.area_->ShallowCopy(
+    DOMStorageArea* area = it->second.area_->ShallowCopy(
         clone_namespace_id, clone_persistent_namespace_id);
     clone->areas_[it->first] = AreaHolder(area, 0);
   }
@@ -90,7 +90,7 @@ DomStorageNamespace* DomStorageNamespace::Clone(
   if (session_storage_database_.get()) {
     task_runner_->PostShutdownBlockingTask(
         FROM_HERE,
-        DomStorageTaskRunner::COMMIT_SEQUENCE,
+        DOMStorageTaskRunner::COMMIT_SEQUENCE,
         base::Bind(base::IgnoreResult(&SessionStorageDatabase::CloneNamespace),
                    session_storage_database_.get(), persistent_namespace_id_,
                    clone_persistent_namespace_id));
@@ -98,7 +98,7 @@ DomStorageNamespace* DomStorageNamespace::Clone(
   return clone;
 }
 
-void DomStorageNamespace::DeleteLocalStorageOrigin(const GURL& origin) {
+void DOMStorageNamespace::DeleteLocalStorageOrigin(const GURL& origin) {
   DCHECK(!session_storage_database_.get());
   AreaHolder* holder = GetAreaHolder(origin);
   if (holder) {
@@ -106,19 +106,19 @@ void DomStorageNamespace::DeleteLocalStorageOrigin(const GURL& origin) {
     return;
   }
   if (!directory_.empty()) {
-    scoped_refptr<DomStorageArea> area =
-        new DomStorageArea(origin, directory_, task_runner_.get());
+    scoped_refptr<DOMStorageArea> area =
+        new DOMStorageArea(origin, directory_, task_runner_.get());
     area->DeleteOrigin();
   }
 }
 
-void DomStorageNamespace::DeleteSessionStorageOrigin(const GURL& origin) {
-  DomStorageArea* area = OpenStorageArea(origin);
+void DOMStorageNamespace::DeleteSessionStorageOrigin(const GURL& origin) {
+  DOMStorageArea* area = OpenStorageArea(origin);
   area->FastClear();
   CloseStorageArea(area);
 }
 
-void DomStorageNamespace::PurgeMemory(PurgeOption option) {
+void DOMStorageNamespace::PurgeMemory(PurgeOption option) {
   if (directory_.empty())
     return;  // We can't purge w/o backing on disk.
   AreaMap::iterator it = areas_.begin();
@@ -147,13 +147,13 @@ void DomStorageNamespace::PurgeMemory(PurgeOption option) {
   }
 }
 
-void DomStorageNamespace::Shutdown() {
+void DOMStorageNamespace::Shutdown() {
   AreaMap::const_iterator it = areas_.begin();
   for (; it != areas_.end(); ++it)
     it->second.area_->Shutdown();
 }
 
-unsigned int DomStorageNamespace::CountInMemoryAreas() const {
+unsigned int DOMStorageNamespace::CountInMemoryAreas() const {
   unsigned int area_count = 0;
   for (AreaMap::const_iterator it = areas_.begin(); it != areas_.end(); ++it) {
     if (it->second.area_->IsLoadedInMemory())
@@ -162,8 +162,8 @@ unsigned int DomStorageNamespace::CountInMemoryAreas() const {
   return area_count;
 }
 
-DomStorageNamespace::AreaHolder*
-DomStorageNamespace::GetAreaHolder(const GURL& origin) {
+DOMStorageNamespace::AreaHolder*
+DOMStorageNamespace::GetAreaHolder(const GURL& origin) {
   AreaMap::iterator found = areas_.find(origin);
   if (found == areas_.end())
     return NULL;
@@ -172,16 +172,16 @@ DomStorageNamespace::GetAreaHolder(const GURL& origin) {
 
 // AreaHolder
 
-DomStorageNamespace::AreaHolder::AreaHolder()
+DOMStorageNamespace::AreaHolder::AreaHolder()
     : open_count_(0) {
 }
 
-DomStorageNamespace::AreaHolder::AreaHolder(
-    DomStorageArea* area, int count)
+DOMStorageNamespace::AreaHolder::AreaHolder(
+    DOMStorageArea* area, int count)
     : area_(area), open_count_(count) {
 }
 
-DomStorageNamespace::AreaHolder::~AreaHolder() {
+DOMStorageNamespace::AreaHolder::~AreaHolder() {
 }
 
-}  // namespace dom_storage
+}  // namespace content