Move webCacheManager to //components.

components/web_cache/browser/web_cache_manager.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 "chrome/browser/renderer_host/web_cache_manager.h"
+#include "components/web_cache/browser/web_cache_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
-#include "chrome/browser/browser_process.h"
-#include "chrome/browser/chrome_notification_types.h"
-#include "chrome/common/chrome_constants.h"
-#include "chrome/common/pref_names.h"
-#include "chrome/common/render_messages.h"
+#include "components/web_cache/common/web_cache_messages.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 
 using base::Time;
 using base::TimeDelta;
 using blink::WebCache;
 
+namespace web_cache {
+
 static const int kReviseAllocationDelayMS = 200;
 
 // The default size limit of the in-memory cache is 8 MB
 static const int kDefaultMemoryCacheSize = 8 * 1024 * 1024;
 
 namespace {
 
 int GetDefaultCacheSize() {
   // Start off with a modest default
   int default_cache_size = kDefaultMemoryCacheSize;
 
   // Check how much physical memory the OS has
   int mem_size_mb = base::SysInfo::AmountOfPhysicalMemoryMB();
   if (mem_size_mb >= 1000)  // If we have a GB of memory, set a larger default.
     default_cache_size *= 4;
   else if (mem_size_mb >= 512)  // With 512 MB, set a slightly larger default.
     default_cache_size *= 2;
 
   UMA_HISTOGRAM_MEMORY_MB("Cache.MaxCacheSizeMB",
                           default_cache_size / 1024 / 1024);
 
   return default_cache_size;
 }
 
 }  // anonymous namespace
 
 // static
-void WebCacheManager::RegisterPrefs(PrefRegistrySimple* registry) {
-  registry->RegisterIntegerPref(prefs::kMemoryCacheSize, GetDefaultCacheSize());
-}
-
-// static
 WebCacheManager* WebCacheManager::GetInstance() {
   return Singleton<WebCacheManager>::get();
 }
 
 WebCacheManager::WebCacheManager()
     : global_size_limit_(GetDefaultGlobalSizeLimit()),
       weak_factory_(this) {
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CREATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
@@ skipping 104 matching lines @@
       break;
     }
     default:
       NOTREACHED();
       break;
   }
 }
 
 // static
 size_t WebCacheManager::GetDefaultGlobalSizeLimit() {
-  PrefService* perf_service = g_browser_process->local_state();
-  if (perf_service)
-    return perf_service->GetInteger(prefs::kMemoryCacheSize);
-
   return GetDefaultCacheSize();
 }
 
 void WebCacheManager::GatherStats(const std::set<int>& renderers,
                                   WebCache::UsageStats* stats) {
   DCHECK(stats);
 
   memset(stats, 0, sizeof(WebCache::UsageStats));
 
   std::set<int>::const_iterator iter = renderers.begin();
@@ skipping 119 matching lines @@
       // prefer to keep live objects around. There is probably some performance
       // tuning to be done here.
       size_t min_dead_capacity = 0;
 
       // We allow the dead objects to consume up to half of the cache capacity.
       size_t max_dead_capacity = capacity / 2;
       if (base::SysInfo::IsLowEndDevice()) {
         max_dead_capacity = std::min(static_cast<size_t>(512 * 1024),
                                      max_dead_capacity);
       }
-      host->Send(new ChromeViewMsg_SetCacheCapacities(min_dead_capacity,
-                                                      max_dead_capacity,
-                                                      capacity));
+      host->Send(new WebCacheMsg_SetCacheCapacities(min_dead_capacity,
+                                                    max_dead_capacity,
+                                                    capacity));
     }
     ++allocation;
   }
 }
 
 void WebCacheManager::ClearRendererCache(
     const std::set<int>& renderers,
     WebCacheManager::ClearCacheOccasion occasion) {
   std::set<int>::const_iterator iter = renderers.begin();
   for (; iter != renderers.end(); ++iter) {
     content::RenderProcessHost* host =
         content::RenderProcessHost::FromID(*iter);
     if (host)
-      host->Send(new ChromeViewMsg_ClearCache(occasion == ON_NAVIGATION));
+      host->Send(new WebCacheMsg_ClearCache(occasion == ON_NAVIGATION));
   }
 }
 
 void WebCacheManager::ReviseAllocationStrategy() {
   DCHECK(stats_.size() <=
       active_renderers_.size() + inactive_renderers_.size());
 
   // Check if renderers have gone inactive.
   FindInactiveRenderers();
 
@@ skipping 79 matching lines @@
     if (idle >= TimeDelta::FromMinutes(kRendererInactiveThresholdMinutes)) {
       // Moved to inactive status.  This invalidates our iterator.
       inactive_renderers_.insert(*iter);
       active_renderers_.erase(*iter);
       iter = active_renderers_.begin();
       continue;
     }
     ++iter;
   }
 }
+
+}  // namespace web_cache