Replace web_cache_messages.h with Mojo service.

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 "components/web_cache/browser/web_cache_manager.h"
 
 #include <string.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/sys_info.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.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"
+#include "content/public/common/service_registry.h"
 
 using base::Time;
 using base::TimeDelta;
 
 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;
@@ skipping 47 matching lines @@
   //
   // However, there doesn't seem to be much harm in receiving the calls in this
   // order.
 
   active_renderers_.insert(renderer_id);
 
   RendererInfo* stats = &(stats_[renderer_id]);
   memset(stats, 0, sizeof(*stats));
   stats->access = Time::Now();
 
+  WebCacheServicePtr service;
+  content::RenderProcessHost* host =
+      content::RenderProcessHost::FromID(renderer_id);
+  DCHECK(host);
+  host->GetServiceRegistry()->ConnectToRemoteService(mojo::GetProxy(&service));
+
+  web_cache_services_[renderer_id] = std::move(service);
+
   // Revise our allocation strategy to account for this new renderer.
   ReviseAllocationStrategyLater();
 }
 
 void WebCacheManager::Remove(int renderer_id) {
   // Erase all knowledge of this renderer
   active_renderers_.erase(renderer_id);
   inactive_renderers_.erase(renderer_id);
   stats_.erase(renderer_id);
 
+  web_cache_services_.erase(renderer_id);
+
   // Reallocate the resources used by this renderer
   ReviseAllocationStrategyLater();
 }
 
 void WebCacheManager::ObserveActivity(int renderer_id) {
   StatsMap::iterator item = stats_.find(renderer_id);
   if (item == stats_.end())
     return;  // We might see stats for a renderer that has been destroyed.
 
   // Record activity.
@@ skipping 209 matching lines @@
       // tuning to be done here.
       uint64_t min_dead_capacity = 0;
 
       // We allow the dead objects to consume up to half of the cache capacity.
       uint64_t max_dead_capacity = capacity / 2;
       if (base::SysInfo::IsLowEndDevice()) {
         max_dead_capacity = std::min(static_cast<uint64_t>(512 * 1024u),
                                      max_dead_capacity);
       }
 
-      host->Send(new WebCacheMsg_SetCacheCapacities(min_dead_capacity,
-                                                    max_dead_capacity,
-                                                    capacity));
+      const WebCacheServicePtr& service =
+          web_cache_services_[allocation->first];
+      DCHECK(service.get());

[Anand Mistry (off Chromium), 2016/02/18 12:33:57]

I think you should be able to do:
DCHECK(service);

[leonhsl(Using Gerrit), 2016/02/19 08:37:41]

Done.

+      service->SetCacheCapacities(min_dead_capacity, max_dead_capacity,
+                                  capacity);
     }
     ++allocation;
   }
 }
 
 void WebCacheManager::ClearCacheForProcess(int render_process_id) {
   std::set<int> renderers;
   renderers.insert(render_process_id);
   ClearRendererCache(renderers, INSTANTLY);
 }
 
 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 WebCacheMsg_ClearCache(occasion == ON_NAVIGATION));
+    if (host) {
+      const WebCacheServicePtr& service = web_cache_services_[*iter];
+      DCHECK(service.get());
+      service->ClearCache(occasion == ON_NAVIGATION);
+    }
   }
 }
 
 void WebCacheManager::ReviseAllocationStrategy() {
   DCHECK(stats_.size() <=
       active_renderers_.size() + inactive_renderers_.size());
 
   // Check if renderers have gone inactive.
   FindInactiveRenderers();
 
@@ skipping 88 matching lines @@
       inactive_renderers_.insert(*iter);
       active_renderers_.erase(*iter);
       iter = active_renderers_.begin();
       continue;
     }
     ++iter;
   }
 }
 
 }  // namespace web_cache