Move hash.h/cc from net/disk_cache to base.

net/disk_cache/backend_impl.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 "net/disk_cache/backend_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
+#include "base/hash.h"
 #include "base/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_counters.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/threading/worker_pool.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/entry_impl.h"
 #include "net/disk_cache/errors.h"
 #include "net/disk_cache/experiments.h"
 #include "net/disk_cache/file.h"
-#include "net/disk_cache/hash.h"
 #include "net/disk_cache/mem_backend_impl.h"
 
 // This has to be defined before including histogram_macros.h from this file.
 #define NET_DISK_CACHE_BACKEND_IMPL_CC_
 #include "net/disk_cache/histogram_macros.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
@@ skipping 618 matching lines @@
 
 void BackendImpl::SyncEndEnumeration(void* iter) {
   scoped_ptr<Rankings::Iterator> iterator(
       reinterpret_cast<Rankings::Iterator*>(iter));
 }
 
 void BackendImpl::SyncOnExternalCacheHit(const std::string& key) {
   if (disabled_)
     return;
 
-  uint32 hash = Hash(key);
+  uint32 hash = base::Hash(key);
   bool error;
   EntryImpl* cache_entry = MatchEntry(key, hash, false, Addr(), &error);
   if (cache_entry) {
     if (ENTRY_NORMAL == cache_entry->entry()->Data()->state) {
       UpdateRank(cache_entry, false);
     }
     cache_entry->Release();
   }
 }
 
 EntryImpl* BackendImpl::OpenEntryImpl(const std::string& key) {
   if (disabled_)
     return NULL;
 
   TimeTicks start = TimeTicks::Now();
-  uint32 hash = Hash(key);
+  uint32 hash = base::Hash(key);
   Trace("Open hash 0x%x", hash);
 
   bool error;
   EntryImpl* cache_entry = MatchEntry(key, hash, false, Addr(), &error);
   if (!cache_entry) {
     stats_.OnEvent(Stats::OPEN_MISS);
     return NULL;
   }
 
   if (ENTRY_NORMAL != cache_entry->entry()->Data()->state) {
@@ skipping 12 matching lines @@
   stats_.OnEvent(Stats::OPEN_HIT);
   SIMPLE_STATS_COUNTER("disk_cache.hit");
   return cache_entry;
 }
 
 EntryImpl* BackendImpl::CreateEntryImpl(const std::string& key) {
   if (disabled_ || key.empty())
     return NULL;
 
   TimeTicks start = TimeTicks::Now();
-  uint32 hash = Hash(key);
+  uint32 hash = base::Hash(key);
   Trace("Create hash 0x%x", hash);
 
   scoped_refptr<EntryImpl> parent;
   Addr entry_address(data_->table[hash & mask_]);
   if (entry_address.is_initialized()) {
     // We have an entry already. It could be the one we are looking for, or just
     // a hash conflict.
     bool error;
     EntryImpl* old_entry = MatchEntry(key, hash, false, Addr(), &error);
     if (old_entry)
@@ skipping 1483 matching lines @@
     if (total_memory > kMaxBuffersSize || total_memory <= 0)
       total_memory = kMaxBuffersSize;
 
     done = true;
   }
 
   return static_cast<int>(total_memory);
 }
 
 }  // namespace disk_cache