Define the public version of the browser side RenderProcessHost interface. This interface is not ...

chrome/browser/renderer_host/web_cache_manager.cc

 // Copyright (c) 2011 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 <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/sys_info.h"
 #include "base/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
-#include "content/browser/renderer_host/browser_render_process_host.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/browser/render_process_host.h"
 
 using base::Time;
 using base::TimeDelta;
 using WebKit::WebCache;
 
 static const unsigned int kReviseAllocationDelayMS = 200 /* milliseconds */;
 
 // The default size limit of the in-memory cache is 8 MB
 static const int kDefaultMemoryCacheSize = 8 * 1024 * 1024;
 
@@ skipping 122 matching lines @@
   // the user navigates to a new website.
   ClearRendederCache(active_renderers_, ON_NAVIGATION);
   ClearRendederCache(inactive_renderers_, ON_NAVIGATION);
 }
 
 void WebCacheManager::Observe(int type,
                               const content::NotificationSource& source,
                               const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_RENDERER_PROCESS_CREATED: {
-      RenderProcessHost* process =
-          content::Source<RenderProcessHost>(source).ptr();
-      Add(process->id());
+      content::RenderProcessHost* process =
+          content::Source<content::RenderProcessHost>(source).ptr();
+      Add(process->GetID());
       break;
     }
     case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED: {
-      RenderProcessHost* process =
-          content::Source<RenderProcessHost>(source).ptr();
-      Remove(process->id());
+      content::RenderProcessHost* process =
+          content::Source<content::RenderProcessHost>(source).ptr();
+      Remove(process->GetID());
       break;
     }
     default:
       NOTREACHED();
       break;
   }
 }
 
 // static
 size_t WebCacheManager::GetDefaultGlobalSizeLimit() {
@@ skipping 116 matching lines @@
     // Record the allocation in our strategy.
     strategy->push_back(Allocation(*iter, cache_size));
     ++iter;
   }
 }
 
 void WebCacheManager::EnactStrategy(const AllocationStrategy& strategy) {
   // Inform each render process of its cache allocation.
   AllocationStrategy::const_iterator allocation = strategy.begin();
   while (allocation != strategy.end()) {
-    RenderProcessHost* host = RenderProcessHost::FromID(allocation->first);
+    content::RenderProcessHost* host =
+        content::RenderProcessHost::FromID(allocation->first);
     if (host) {
       // This is the capacity this renderer has been allocated.
       size_t capacity = allocation->second;
 
       // We don't reserve any space for dead objects in the cache.  Instead, we
       // 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 all of the cache, if the renderer
       // so desires.  If we wanted this memory, we would have set the total
       // capacity lower.
       size_t max_dead_capacity = capacity;
 
       host->Send(new ChromeViewMsg_SetCacheCapacities(min_dead_capacity,
                                                       max_dead_capacity,
                                                       capacity));
     }
     ++allocation;
   }
 }
 
 void WebCacheManager::ClearRendederCache(
     const std::set<int>& renderers,
     WebCacheManager::ClearCacheOccasion occasion) {
   std::set<int>::const_iterator iter = renderers.begin();
   for (; iter != renderers.end(); ++iter) {
-    RenderProcessHost* host = RenderProcessHost::FromID(*iter);
+    content::RenderProcessHost* host =
+        content::RenderProcessHost::FromID(*iter);
     if (host)
       host->Send(new ChromeViewMsg_ClearCache(occasion == ON_NAVIGATION));
   }
 }
 
 void WebCacheManager::ReviseAllocationStrategy() {
   DCHECK(stats_.size() <=
       active_renderers_.size() + inactive_renderers_.size());
 
   // Check if renderers have gone inactive.
@@ skipping 81 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;
   }
 }