Convert some NetError[Tab]Helper messages to mojom

chrome/renderer/net/net_error_helper.cc

 // Copyright (c) 2013 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/renderer/net/net_error_helper.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
@@ skipping 64 matching lines @@
   if (render_frame->IsMainFrame())
     return NetErrorHelperCore::MAIN_FRAME;
   return NetErrorHelperCore::SUB_FRAME;
 }
 
 }  // namespace
 
 NetErrorHelper::NetErrorHelper(RenderFrame* render_frame)
     : RenderFrameObserver(render_frame),
       content::RenderFrameObserverTracker<NetErrorHelper>(render_frame),
+      network_diagnostics_client_binding_(this),
       weak_controller_delegate_factory_(this) {
   RenderThread::Get()->AddObserver(this);
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   bool auto_reload_enabled =
       command_line->HasSwitch(switches::kEnableOfflineAutoReload);
   bool auto_reload_visible_only =
       command_line->HasSwitch(switches::kEnableOfflineAutoReloadVisibleOnly);
   // TODO(mmenke): Consider only creating a NetErrorHelperCore for main frames.
   // subframes don't need any of the NetErrorHelperCore's extra logic.
   core_.reset(new NetErrorHelperCore(this,
                                      auto_reload_enabled,
                                      auto_reload_visible_only,
                                      !render_frame->IsHidden()));
+
+  render_frame->AddRoutedInterface(
+      base::Bind(&NetErrorHelper::OnNetworkDiagnosticsClientRequest,
+                 base::Unretained(this)));
 }
 
 NetErrorHelper::~NetErrorHelper() {
   RenderThread::Get()->RemoveObserver(this);
 }
 
 void NetErrorHelper::ButtonPressed(
     error_page::NetErrorHelperCore::Button button) {
   core_->ExecuteButtonPress(button);
 }
@@ skipping 37 matching lines @@
 
 void NetErrorHelper::WasHidden() {
   core_->OnWasHidden();
 }
 
 bool NetErrorHelper::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
 
   IPC_BEGIN_MESSAGE_MAP(NetErrorHelper, message)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_NetErrorInfo, OnNetErrorInfo)
-    IPC_MESSAGE_HANDLER(ChromeViewMsg_SetCanShowNetworkDiagnosticsDialog,
-                        OnSetCanShowNetworkDiagnosticsDialog);
     IPC_MESSAGE_HANDLER(ChromeViewMsg_SetNavigationCorrectionInfo,
                         OnSetNavigationCorrectionInfo);
 #if defined(OS_ANDROID)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_SetHasOfflinePages, OnSetHasOfflinePages)
 #endif
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
@@ skipping 11 matching lines @@
                                   bool is_ignoring_cache,
                                   std::string* error_html) {
   core_->GetErrorHTML(GetFrameType(render_frame()), error, is_failed_post,
                       is_ignoring_cache, error_html);
 }
 
 bool NetErrorHelper::ShouldSuppressErrorPage(const GURL& url) {
   return core_->ShouldSuppressErrorPage(GetFrameType(render_frame()), url);
 }
 
+mojom::NetworkDiagnostics* NetErrorHelper::GetRemoteNetworkDiagnostics() {
+  if (!remote_network_diagnostics_)
+    render_frame()->GetRemoteRoutedInterface(&remote_network_diagnostics_);
+  return remote_network_diagnostics_.get();
+}
+
 void NetErrorHelper::GenerateLocalizedErrorPage(
     const blink::WebURLError& error,
     bool is_failed_post,
     bool can_show_network_diagnostics_dialog,
     bool has_offline_pages,
     std::unique_ptr<ErrorPageParams> params,
     bool* reload_button_shown,
     bool* show_saved_copy_button_shown,
     bool* show_cached_copy_button_shown,
     bool* show_offline_pages_button_shown,
@@ skipping 117 matching lines @@
       base::StringPiece16(web_frame->dataSource()->request().httpMethod()),
       "POST"));
 
   blink::WebURLRequest request(page_url);
   request.setCachePolicy(blink::WebCachePolicy::ReturnCacheDataDontLoad);
   request.setRequestorOrigin(blink::WebSecurityOrigin::createUnique());
   web_frame->loadRequest(request);
 }
 
 void NetErrorHelper::DiagnoseError(const GURL& page_url) {
-  render_frame()->Send(new ChromeViewHostMsg_RunNetworkDiagnostics(
-      render_frame()->GetRoutingID(), page_url));
+  GetRemoteNetworkDiagnostics()->RunNetworkDiagnostics(page_url);
 }
 
 void NetErrorHelper::ShowOfflinePages() {
 #if defined(OS_ANDROID)
   render_frame()->Send(new ChromeViewHostMsg_ShowOfflinePages(
       render_frame()->GetRoutingID()));
 #endif  // defined(OS_ANDROID)
 }
 
 void NetErrorHelper::OnNetErrorInfo(int status_num) {
   DCHECK(status_num >= 0 && status_num < error_page::DNS_PROBE_MAX);
 
   DVLOG(1) << "Received status " << DnsProbeStatusToString(status_num);
 
   core_->OnNetErrorInfo(static_cast<DnsProbeStatus>(status_num));
 }
 
-void NetErrorHelper::OnSetCanShowNetworkDiagnosticsDialog(
-    bool can_use_local_diagnostics_service) {
-  core_->OnSetCanShowNetworkDiagnosticsDialog(
-      can_use_local_diagnostics_service);
-}
-
 void NetErrorHelper::OnSetNavigationCorrectionInfo(
     const GURL& navigation_correction_url,
     const std::string& language,
     const std::string& country_code,
     const std::string& api_key,
     const GURL& search_url) {
   core_->OnSetNavigationCorrectionInfo(navigation_correction_url, language,
                                        country_code, api_key, search_url);
 }
 
 void NetErrorHelper::OnNavigationCorrectionsFetched(
     const blink::WebURLResponse& response,
     const std::string& data) {
   // The fetcher may only be deleted after |data| is passed to |core_|.  Move
   // it to a temporary to prevent any potential re-entrancy issues.
   std::unique_ptr<content::ResourceFetcher> fetcher(
       correction_fetcher_.release());
   bool success = (!response.isNull() && response.httpStatusCode() == 200);
   core_->OnNavigationCorrectionsFetched(success ? data : "",
                                         base::i18n::IsRTL());
 }
 
 void NetErrorHelper::OnTrackingRequestComplete(
     const blink::WebURLResponse& response,
     const std::string& data) {
   tracking_fetcher_.reset();
 }
 
+void NetErrorHelper::OnNetworkDiagnosticsClientRequest(
+    mojom::NetworkDiagnosticsClientAssociatedRequest request) {
+  DCHECK(!network_diagnostics_client_binding_.is_bound());
+  network_diagnostics_client_binding_.Bind(std::move(request));
+}
+
+void NetErrorHelper::SetCanShowNetworkDiagnosticsDialog(bool can_show) {
+  core_->OnSetCanShowNetworkDiagnosticsDialog(can_show);
+}
+
 #if defined(OS_ANDROID)
 void NetErrorHelper::OnSetHasOfflinePages(bool has_offline_pages) {
   core_->OnSetHasOfflinePages(has_offline_pages);
 }
 #endif  // defined(OS_ANDROID)