Migrate chrome_net_benchmarking_message_filter to mojo

chrome/browser/chrome_net_benchmarking_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 "chrome/browser/chrome_net_benchmarking_message_filter.h"
+#include "chrome/browser/chrome_net_benchmarking_impl.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "chrome/browser/net/predictor.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/common/benchmarking_messages.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/chrome_net_benchmarking.mojom.h"
+#include "content/public/browser/browser_thread.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/dns/host_cache.h"
 #include "net/dns/host_resolver.h"
 #include "net/http/http_cache.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
+using content::BrowserThread;
+
 namespace {
 
-void ClearCacheCallback(ChromeNetBenchmarkingMessageFilter* filter,
-                        IPC::Message* reply_msg,
-                        int result) {
-  ChromeViewHostMsg_ClearCache::WriteReplyParams(reply_msg, result);
-  filter->Send(reply_msg);
+void ClearPredictorCacheOnUIThread(Profile* profile) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  // TODO(623967): Ensure that the profile or predictor are not accessed after
+  // they have been shut down.
+  chrome_browser_net::Predictor* predictor = profile->GetNetworkPredictor();
+  if (predictor)
+    predictor->DiscardAllResultsAndClearPrefsOnUIThread();
 }
 
 }  // namespace
 
-ChromeNetBenchmarkingMessageFilter::ChromeNetBenchmarkingMessageFilter(
+ChromeNetBenchmarkingImpl::ChromeNetBenchmarkingImpl(
     Profile* profile,
     net::URLRequestContextGetter* request_context)
-    : BrowserMessageFilter(ChromeBenchmarkingMsgStart),
-      profile_(profile),
-      request_context_(request_context) {
+    : profile_(profile), request_context_(request_context) {}
+
+ChromeNetBenchmarkingImpl::~ChromeNetBenchmarkingImpl() {
 }
 
-ChromeNetBenchmarkingMessageFilter::~ChromeNetBenchmarkingMessageFilter() {
+// static
+void ChromeNetBenchmarkingImpl::Create(
+    Profile* profile,
+    net::URLRequestContextGetter* request_context,
+    chrome::mojom::ChromeNetBenchmarkingRequest request) {
+  mojo::MakeStrongBinding(
+      base::MakeUnique<ChromeNetBenchmarkingImpl>(profile, request_context),
+      std::move(request));
 }
 
-bool ChromeNetBenchmarkingMessageFilter::OnMessageReceived(
-    const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(ChromeNetBenchmarkingMessageFilter, message)
-    IPC_MESSAGE_HANDLER(ChromeViewHostMsg_CloseCurrentConnections,
-                        OnCloseCurrentConnections)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(ChromeViewHostMsg_ClearCache, OnClearCache)
-    IPC_MESSAGE_HANDLER(ChromeViewHostMsg_ClearHostResolverCache,
-                        OnClearHostResolverCache)
-    IPC_MESSAGE_HANDLER(ChromeViewHostMsg_ClearPredictorCache,
-                        OnClearPredictorCache)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
-}
-
-void ChromeNetBenchmarkingMessageFilter::OverrideThreadForMessage(
-    const IPC::Message& message,
-    content::BrowserThread::ID* thread) {
-  if (message.type() == ChromeViewHostMsg_ClearPredictorCache::ID)
-    *thread = content::BrowserThread::UI;
-}
-
-void ChromeNetBenchmarkingMessageFilter::OnClearCache(IPC::Message* reply_msg) {
+void ChromeNetBenchmarkingImpl::ClearCache(
+    const ClearCacheCallback& callback) {
   // This function is disabled unless the user has enabled
   // benchmarking extensions.
   if (!CheckBenchmarkingEnabled()) {

[Sam McNally, 2016/12/05 06:57:09]

Check this in Create() instead and if not enabled, early return.

[dvallet, 2016/12/07 02:21:02]

Done. I've remove te NOTREACHED message since I guess now we'll not be binding
the IPC methods when Benchmarking is disabled

     NOTREACHED() << "Received unexpected benchmarking IPC";
+    // No callback called.
     return;
   }
   int rv = -1;
 
   disk_cache::Backend* backend = request_context_->GetURLRequestContext()->
       http_transaction_factory()->GetCache()->GetCurrentBackend();
   if (backend) {
-    net::CompletionCallback callback =
-        base::Bind(&ClearCacheCallback, base::RetainedRef(this), reply_msg);
     rv = backend->DoomAllEntries(callback);
     if (rv == net::ERR_IO_PENDING) {
-      // The callback will send the reply.
+      // Callback is handled by backend.
       return;
     }
   }
-  ChromeViewHostMsg_ClearCache::WriteReplyParams(reply_msg, rv);
-  Send(reply_msg);
+  callback.Run(rv);
 }
 
-void ChromeNetBenchmarkingMessageFilter::OnClearHostResolverCache() {
+void ChromeNetBenchmarkingImpl::ClearHostResolverCache() {
   // This function is disabled unless the user has enabled
   // benchmarking extensions.
   if (!CheckBenchmarkingEnabled()) {
     NOTREACHED() << "Received unexpected benchmarking IPC";
     return;
   }
   net::HostCache* cache =
       request_context_->GetURLRequestContext()->host_resolver()->GetHostCache();
   if (cache) {
     cache->clear();
   }
 }
 
-void ChromeNetBenchmarkingMessageFilter::OnCloseCurrentConnections() {
+void ChromeNetBenchmarkingImpl::CloseCurrentConnections() {
   // This function is disabled unless the user has enabled
   // benchmarking extensions.
   if (!CheckBenchmarkingEnabled()) {
     NOTREACHED() << "Received unexpected benchmarking IPC";
     return;
   }
   request_context_->GetURLRequestContext()->
       http_transaction_factory()->GetCache()->CloseAllConnections();
 }
 
-void ChromeNetBenchmarkingMessageFilter::OnSetCacheMode(bool enabled) {
+void ChromeNetBenchmarkingImpl::SetCacheMode(bool enabled) {
   // This function is disabled unless the user has enabled
   // benchmarking extensions.
   if (!CheckBenchmarkingEnabled()) {
     NOTREACHED() << "Received unexpected benchmarking IPC";
     return;
   }
   net::HttpCache::Mode mode = enabled ?
       net::HttpCache::NORMAL : net::HttpCache::DISABLE;
   net::HttpCache* http_cache = request_context_->GetURLRequestContext()->
       http_transaction_factory()->GetCache();
   http_cache->set_mode(mode);
 }
 
-void ChromeNetBenchmarkingMessageFilter::OnClearPredictorCache() {
+void ChromeNetBenchmarkingImpl::ClearPredictorCache() {
   // This function is disabled unless the user has enabled
   // benchmarking extensions.
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!CheckBenchmarkingEnabled()) {
     NOTREACHED() << "Received unexpected benchmarking IPC";
     return;
   }
-  // TODO(623967): Ensure that the profile or predictor are not accessed after
-  // they have been shut down.
-  chrome_browser_net::Predictor* predictor = profile_->GetNetworkPredictor();
-  if (predictor)
-    predictor->DiscardAllResultsAndClearPrefsOnUIThread();
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&ClearPredictorCacheOnUIThread, profile_));
 }
 
-bool ChromeNetBenchmarkingMessageFilter::CheckBenchmarkingEnabled() const {
+bool ChromeNetBenchmarkingImpl::CheckBenchmarkingEnabled() const {
   static bool checked = false;
   static bool result = false;
   if (!checked) {
     const base::CommandLine& command_line =
         *base::CommandLine::ForCurrentProcess();
     result = command_line.HasSwitch(switches::kEnableNetBenchmarking);
     checked = true;
   }
   return result;
 }