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

content/renderer/dom_storage/dom_storage_dispatcher.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/renderer/dom_storage/dom_storage_dispatcher.h"
 
 #include <list>
 #include <map>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/lock.h"
-#include "content/common/dom_storage_messages.h"
+#include "content/common/dom_storage/dom_storage_messages.h"
+#include "content/common/dom_storage/dom_storage_types.h"
 #include "content/renderer/dom_storage/dom_storage_cached_area.h"
 #include "content/renderer/dom_storage/dom_storage_proxy.h"
 #include "content/renderer/dom_storage/webstoragearea_impl.h"
 #include "content/renderer/dom_storage/webstoragenamespace_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "third_party/WebKit/public/platform/Platform.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebStorageEventDispatcher.h"
-#include "webkit/common/dom_storage/dom_storage_types.h"
-
-using dom_storage::ValuesMap;
 
 namespace content {
 
 namespace {
 // MessageThrottlingFilter -------------------------------------------
 // Used to limit the number of ipc messages pending completion so we
 // don't overwhelm the main browser process. When the limit is reached,
 // a synchronous message is sent to flush all pending messages thru.
 // We expect to receive an 'ack' for each message sent. This object
 // observes receipt of the acks on the IPC thread to decrement a counter.
@@ skipping 68 matching lines @@
   // Methods for use by DomStorageDispatcher directly.
   DomStorageCachedArea* OpenCachedArea(
       int64 namespace_id, const GURL& origin);
   void CloseCachedArea(DomStorageCachedArea* area);
   DomStorageCachedArea* LookupCachedArea(
       int64 namespace_id, const GURL& origin);
   void CompleteOnePendingCallback(bool success);
   void Shutdown();
 
   // DomStorageProxy interface for use by DomStorageCachedArea.
-  virtual void LoadArea(int connection_id, ValuesMap* values,
+  virtual void LoadArea(int connection_id, DOMStorageValuesMap* values,
                         const CompletionCallback& callback) OVERRIDE;
   virtual void SetItem(int connection_id, const string16& key,
                        const string16& value, const GURL& page_url,
                        const CompletionCallback& callback) OVERRIDE;
   virtual void RemoveItem(int connection_id, const string16& key,
                           const GURL& page_url,
                           const CompletionCallback& callback) OVERRIDE;
   virtual void ClearArea(int connection_id,
                         const GURL& page_url,
                         const CompletionCallback& callback) OVERRIDE;
@@ skipping 93 matching lines @@
 
 void DomStorageDispatcher::ProxyImpl::Shutdown() {
   throttling_filter_->Shutdown();
   sender_->RemoveFilter(throttling_filter_.get());
   sender_ = NULL;
   cached_areas_.clear();
   pending_callbacks_.clear();
 }
 
 void DomStorageDispatcher::ProxyImpl::LoadArea(
-    int connection_id, ValuesMap* values,
+    int connection_id, DOMStorageValuesMap* values,
     const CompletionCallback& callback) {
   PushPendingCallback(callback);
   throttling_filter_->SendThrottled(new DOMStorageHostMsg_LoadStorageArea(
       connection_id, values));
 }
 
 void DomStorageDispatcher::ProxyImpl::SetItem(
     int connection_id, const string16& key,
     const string16& value, const GURL& page_url,
     const CompletionCallback& callback) {
@@ skipping 63 matching lines @@
   if (originated_in_process) {
     originating_area = WebStorageAreaImpl::FromConnectionId(
         params.connection_id);
   } else {
     DomStorageCachedArea* cached_area = proxy_->LookupCachedArea(
         params.namespace_id, params.origin);
     if (cached_area)
       cached_area->ApplyMutation(params.key, params.new_value);
   }
 
-  if (params.namespace_id == dom_storage::kLocalStorageNamespaceId) {
+  if (params.namespace_id == kLocalStorageNamespaceId) {
     WebKit::WebStorageEventDispatcher::dispatchLocalStorageEvent(
         params.key,
         params.old_value,
         params.new_value,
         params.origin,
         params.page_url,
         originating_area,
         originated_in_process);
   } else {
     WebStorageNamespaceImpl
         session_namespace_for_event_dispatch(params.namespace_id);
     WebKit::WebStorageEventDispatcher::dispatchSessionStorageEvent(
         params.key,
         params.old_value,
         params.new_value,
         params.origin,
         params.page_url,
         session_namespace_for_event_dispatch,
         originating_area,
         originated_in_process);
   }
 }
 
 void DomStorageDispatcher::OnAsyncOperationComplete(bool success) {
   proxy_->CompleteOnePendingCallback(success);
 }
 
 }  // namespace content