Move nullable_string16.h to the string subdirectory.

webkit/renderer/dom_storage/dom_storage_cached_area.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/renderer/dom_storage/dom_storage_cached_area.h"
 
 #include "base/basictypes.h"
 #include "base/time.h"
 #include "base/metrics/histogram.h"
 #include "webkit/common/dom_storage/dom_storage_map.h"
 #include "webkit/renderer/dom_storage/dom_storage_proxy.h"
 
 namespace dom_storage {
 
 DomStorageCachedArea::DomStorageCachedArea(
     int64 namespace_id, const GURL& origin, DomStorageProxy* proxy)
     : ignore_all_mutations_(false),
       namespace_id_(namespace_id), origin_(origin),
       proxy_(proxy), weak_factory_(this) {
 }
 
 DomStorageCachedArea::~DomStorageCachedArea() {
 }
 
 unsigned DomStorageCachedArea::GetLength(int connection_id) {
   PrimeIfNeeded(connection_id);
   return map_->Length();
 }
 
-NullableString16 DomStorageCachedArea::GetKey(
+base::NullableString16 DomStorageCachedArea::GetKey(
     int connection_id, unsigned index) {
   PrimeIfNeeded(connection_id);
   return map_->Key(index);
 }
 
-NullableString16 DomStorageCachedArea::GetItem(
+base::NullableString16 DomStorageCachedArea::GetItem(
     int connection_id, const base::string16& key) {
   PrimeIfNeeded(connection_id);
   return map_->GetItem(key);
 }
 
 bool DomStorageCachedArea::SetItem(
     int connection_id, const base::string16& key,
     const base::string16& value, const GURL& page_url) {
   // A quick check to reject obviously overbudget items to avoid
   // the priming the cache.
   if (key.length() + value.length() > dom_storage::kPerAreaQuota)
     return false;
 
   PrimeIfNeeded(connection_id);
-  NullableString16 unused;
+  base::NullableString16 unused;
   if (!map_->SetItem(key, value, &unused))
     return false;
 
   // Ignore mutations to 'key' until OnSetItemComplete.
   ignore_key_mutations_[key]++;
   proxy_->SetItem(
       connection_id, key, value, page_url,
       base::Bind(&DomStorageCachedArea::OnSetItemComplete,
                  weak_factory_.GetWeakPtr(), key));
   return true;
@@ skipping 21 matching lines @@
 
   // Ignore all mutations until OnClearComplete time.
   ignore_all_mutations_ = true;
   proxy_->ClearArea(
       connection_id, page_url,
       base::Bind(&DomStorageCachedArea::OnClearComplete,
                  weak_factory_.GetWeakPtr()));
 }
 
 void DomStorageCachedArea::ApplyMutation(
-    const NullableString16& key, const NullableString16& new_value) {
+    const base::NullableString16& key,
+    const base::NullableString16& new_value) {
   if (!map_.get() || ignore_all_mutations_)
     return;
 
   if (key.is_null()) {
     // It's a clear event.
     scoped_refptr<DomStorageMap> old = map_;
     map_ = new DomStorageMap(dom_storage::kPerAreaQuota);
 
     // We have to retain local additions which happened after this
     // clear operation from another process.
     std::map<base::string16, int>::iterator iter =
         ignore_key_mutations_.begin();
     while (iter != ignore_key_mutations_.end()) {
-      NullableString16 value = old->GetItem(iter->first);
+      base::NullableString16 value = old->GetItem(iter->first);
       if (!value.is_null()) {
-        NullableString16 unused;
+        base::NullableString16 unused;
         map_->SetItem(iter->first, value.string(), &unused);
       }
       ++iter;
     }
     return;
   }
 
   // We have to retain local changes.
   if (should_ignore_key_mutation(key.string()))
     return;
 
   if (new_value.is_null()) {
     // It's a remove item event.
     base::string16 unused;
     map_->RemoveItem(key.string(), &unused);
     return;
   }
 
   // It's a set item event.
   // We turn off quota checking here to accomodate the over budget
   // allowance that's provided in the browser process.
-  NullableString16 unused;
+  base::NullableString16 unused;
   map_->set_quota(kint32max);
   map_->SetItem(key.string(), new_value.string(), &unused);
   map_->set_quota(dom_storage::kPerAreaQuota);
 }
 
 size_t DomStorageCachedArea::MemoryBytesUsedByCache() const {
   return map_.get() ? map_->bytes_used() : 0;
 }
 
 void DomStorageCachedArea::Prime(int connection_id) {
@@ skipping 79 matching lines @@
     ignore_key_mutations_.erase(found);
 }
 
 void DomStorageCachedArea::OnClearComplete(bool success) {
   DCHECK(success);
   DCHECK(ignore_all_mutations_);
   ignore_all_mutations_ = false;
 }
 
 }  // namespace dom_storage