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

content/browser/dom_storage/dom_storage_context_proxy.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/dom_storage/dom_storage_context_impl.h"
+#include "content/browser/dom_storage/dom_storage_context_proxy.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "content/browser/dom_storage/dom_storage_area.h"
+#include "content/browser/dom_storage/dom_storage_context_impl.h"
+#include "content/browser/dom_storage/dom_storage_task_runner.h"
 #include "content/browser/dom_storage/session_storage_namespace_impl.h"
 #include "content/public/browser/browser_thread.h"
-#include "webkit/browser/dom_storage/dom_storage_area.h"
-#include "webkit/browser/dom_storage/dom_storage_context.h"
-#include "webkit/browser/dom_storage/dom_storage_task_runner.h"
-
-using dom_storage::DomStorageArea;
-using dom_storage::DomStorageContext;
-using dom_storage::DomStorageTaskRunner;
-using dom_storage::DomStorageWorkerPoolTaskRunner;
 
 namespace content {
 namespace {
 
 const char kLocalStorageDirectory[] = "Local Storage";
 const char kSessionStorageDirectory[] = "Session Storage";
 
 void InvokeLocalStorageUsageCallbackHelper(
       const DOMStorageContext::GetLocalStorageUsageCallback& callback,
-      const std::vector<dom_storage::LocalStorageUsageInfo>* infos) {
+      const std::vector<LocalStorageUsageInfo>* infos) {
   callback.Run(*infos);
 }
 
 void GetLocalStorageUsageHelper(
     base::MessageLoopProxy* reply_loop,
-    DomStorageContext* context,
+    DOMStorageContextImpl* context,
     const DOMStorageContext::GetLocalStorageUsageCallback& callback) {
-  std::vector<dom_storage::LocalStorageUsageInfo>* infos =
-      new std::vector<dom_storage::LocalStorageUsageInfo>;
+  std::vector<LocalStorageUsageInfo>* infos =
+      new std::vector<LocalStorageUsageInfo>;
   context->GetLocalStorageUsage(infos, true);
   reply_loop->PostTask(
       FROM_HERE,
       base::Bind(&InvokeLocalStorageUsageCallbackHelper,
                  callback, base::Owned(infos)));
 }
 
 void InvokeSessionStorageUsageCallbackHelper(
       const DOMStorageContext::GetSessionStorageUsageCallback& callback,
-      const std::vector<dom_storage::SessionStorageUsageInfo>* infos) {
+      const std::vector<SessionStorageUsageInfo>* infos) {
   callback.Run(*infos);
 }
 
 void GetSessionStorageUsageHelper(
     base::MessageLoopProxy* reply_loop,
-    DomStorageContext* context,
+    DOMStorageContextImpl* context,
     const DOMStorageContext::GetSessionStorageUsageCallback& callback) {
-  std::vector<dom_storage::SessionStorageUsageInfo>* infos =
-      new std::vector<dom_storage::SessionStorageUsageInfo>;
+  std::vector<SessionStorageUsageInfo>* infos =
+      new std::vector<SessionStorageUsageInfo>;
   context->GetSessionStorageUsage(infos);
   reply_loop->PostTask(
       FROM_HERE,
       base::Bind(&InvokeSessionStorageUsageCallbackHelper,
                  callback, base::Owned(infos)));
 }
 
 }  // namespace
 
-DOMStorageContextImpl::DOMStorageContextImpl(
+DOMStorageContextProxy::DOMStorageContextProxy(
     const base::FilePath& data_path,
     quota::SpecialStoragePolicy* special_storage_policy) {
   base::SequencedWorkerPool* worker_pool = BrowserThread::GetBlockingPool();
-  context_ = new dom_storage::DomStorageContext(
+  context_ = new DOMStorageContextImpl(
       data_path.empty() ? data_path
                         : data_path.AppendASCII(kLocalStorageDirectory),
       data_path.empty() ? data_path
                         : data_path.AppendASCII(kSessionStorageDirectory),
       special_storage_policy,
-      new DomStorageWorkerPoolTaskRunner(
+      new DOMStorageWorkerPoolTaskRunner(
           worker_pool,
           worker_pool->GetNamedSequenceToken("dom_storage_primary"),
           worker_pool->GetNamedSequenceToken("dom_storage_commit"),
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO)
               .get()));
 }
 
-DOMStorageContextImpl::~DOMStorageContextImpl() {
+DOMStorageContextProxy::~DOMStorageContextProxy() {
 }
 
-void DOMStorageContextImpl::GetLocalStorageUsage(
+void DOMStorageContextProxy::GetLocalStorageUsage(
     const GetLocalStorageUsageCallback& callback) {
   DCHECK(context_.get());
   context_->task_runner()
       ->PostShutdownBlockingTask(FROM_HERE,
-                                 DomStorageTaskRunner::PRIMARY_SEQUENCE,
+                                 DOMStorageTaskRunner::PRIMARY_SEQUENCE,
                                  base::Bind(&GetLocalStorageUsageHelper,
                                             base::MessageLoopProxy::current(),
                                             context_,
                                             callback));
 }
 
-void DOMStorageContextImpl::GetSessionStorageUsage(
+void DOMStorageContextProxy::GetSessionStorageUsage(
     const GetSessionStorageUsageCallback& callback) {
   DCHECK(context_.get());
   context_->task_runner()
       ->PostShutdownBlockingTask(FROM_HERE,
-                                 DomStorageTaskRunner::PRIMARY_SEQUENCE,
+                                 DOMStorageTaskRunner::PRIMARY_SEQUENCE,
                                  base::Bind(&GetSessionStorageUsageHelper,
                                             base::MessageLoopProxy::current(),
                                             context_,
                                             callback));
 }
 
-void DOMStorageContextImpl::DeleteLocalStorage(const GURL& origin) {
+void DOMStorageContextProxy::DeleteLocalStorage(const GURL& origin) {
   DCHECK(context_.get());
   context_->task_runner()->PostShutdownBlockingTask(
       FROM_HERE,
-      DomStorageTaskRunner::PRIMARY_SEQUENCE,
-      base::Bind(&DomStorageContext::DeleteLocalStorage, context_, origin));
+      DOMStorageTaskRunner::PRIMARY_SEQUENCE,
+      base::Bind(&DOMStorageContextImpl::DeleteLocalStorage, context_, origin));
 }
 
-void DOMStorageContextImpl::DeleteSessionStorage(
-    const dom_storage::SessionStorageUsageInfo& usage_info) {
+void DOMStorageContextProxy::DeleteSessionStorage(
+    const SessionStorageUsageInfo& usage_info) {
   DCHECK(context_.get());
   context_->task_runner()->PostShutdownBlockingTask(
       FROM_HERE,
-      DomStorageTaskRunner::PRIMARY_SEQUENCE,
-      base::Bind(
-          &DomStorageContext::DeleteSessionStorage, context_, usage_info));
+      DOMStorageTaskRunner::PRIMARY_SEQUENCE,
+      base::Bind(&DOMStorageContextImpl::DeleteSessionStorage,
+                 context_, usage_info));
 }
 
-void DOMStorageContextImpl::SetSaveSessionStorageOnDisk() {
+void DOMStorageContextProxy::SetSaveSessionStorageOnDisk() {
   DCHECK(context_.get());
   context_->SetSaveSessionStorageOnDisk();
 }
 
 scoped_refptr<SessionStorageNamespace>
-DOMStorageContextImpl::RecreateSessionStorage(
+DOMStorageContextProxy::RecreateSessionStorage(
     const std::string& persistent_id) {
   return scoped_refptr<SessionStorageNamespace>(
       new SessionStorageNamespaceImpl(this, persistent_id));
 }
 
-void DOMStorageContextImpl::StartScavengingUnusedSessionStorage() {
+void DOMStorageContextProxy::StartScavengingUnusedSessionStorage() {
   DCHECK(context_.get());
   context_->task_runner()->PostShutdownBlockingTask(
       FROM_HERE,
-      DomStorageTaskRunner::PRIMARY_SEQUENCE,
-      base::Bind(&DomStorageContext::StartScavengingUnusedSessionStorage,
+      DOMStorageTaskRunner::PRIMARY_SEQUENCE,
+      base::Bind(&DOMStorageContextImpl::StartScavengingUnusedSessionStorage,
                  context_));
 }
 
-void DOMStorageContextImpl::PurgeMemory() {
+void DOMStorageContextProxy::PurgeMemory() {
   DCHECK(context_.get());
   context_->task_runner()->PostShutdownBlockingTask(
       FROM_HERE,
-      DomStorageTaskRunner::PRIMARY_SEQUENCE,
-      base::Bind(&DomStorageContext::PurgeMemory, context_));
+      DOMStorageTaskRunner::PRIMARY_SEQUENCE,
+      base::Bind(&DOMStorageContextImpl::PurgeMemory, context_));
 }
 
-void DOMStorageContextImpl::SetForceKeepSessionState() {
+void DOMStorageContextProxy::SetForceKeepSessionState() {
   DCHECK(context_.get());
   context_->task_runner()->PostShutdownBlockingTask(
       FROM_HERE,
-      DomStorageTaskRunner::PRIMARY_SEQUENCE,
-      base::Bind(&DomStorageContext::SetForceKeepSessionState, context_));
+      DOMStorageTaskRunner::PRIMARY_SEQUENCE,
+      base::Bind(&DOMStorageContextImpl::SetForceKeepSessionState, context_));
 }
 
-void DOMStorageContextImpl::Shutdown() {
+void DOMStorageContextProxy::Shutdown() {
   DCHECK(context_.get());
   context_->task_runner()->PostShutdownBlockingTask(
       FROM_HERE,
-      DomStorageTaskRunner::PRIMARY_SEQUENCE,
-      base::Bind(&DomStorageContext::Shutdown, context_));
+      DOMStorageTaskRunner::PRIMARY_SEQUENCE,
+      base::Bind(&DOMStorageContextImpl::Shutdown, context_));
 }
 
 }  // namespace content