Convert ChromeViewMsg_SetAllowRunningInsecureContent to use mojo.

chrome/renderer/content_settings_observer.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/renderer/content_settings_observer.h"
 
 #include "chrome/common/render_messages.h"
 #include "chrome/common/ssl_insecure_content.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/renderer/document_state.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
 #include "extensions/features/features.h"
+#include "services/service_manager/public/cpp/interface_registry.h"
 #include "third_party/WebKit/public/platform/URLConversion.h"
 #include "third_party/WebKit/public/platform/WebContentSettingCallbacks.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrameClient.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "url/origin.h"
@@ skipping 73 matching lines @@
       extension_dispatcher_(extension_dispatcher),
 #endif
       allow_running_insecure_content_(false),
       content_setting_rules_(NULL),
       is_interstitial_page_(false),
       current_request_id_(0),
       should_whitelist_(should_whitelist) {
   ClearBlockedContentSettings();
   render_frame->GetWebFrame()->setContentSettingsClient(this);
 
+  render_frame->GetInterfaceRegistry()->AddInterface(
+      base::Bind(&ContentSettingsObserver::OnInsecureContentRendererRequest,
+                 base::Unretained(this)));
+
   content::RenderFrame* main_frame =
       render_frame->GetRenderView()->GetMainRenderFrame();
   // TODO(nasko): The main frame is not guaranteed to be in the same process
   // with this frame with --site-per-process. This code needs to be updated
   // to handle this case. See https://crbug.com/496670.
   if (main_frame && main_frame != render_frame) {
     // Copy all the settings from the main render frame to avoid race conditions
     // when initializing this data. See https://crbug.com/333308.
     ContentSettingsObserver* parent = ContentSettingsObserver::Get(main_frame);
     allow_running_insecure_content_ = parent->allow_running_insecure_content_;
@@ skipping 34 matching lines @@
     blocked = true;
     Send(new ChromeViewHostMsg_ContentBlocked(routing_id(), settings_type,
                                               details));
   }
 }
 
 bool ContentSettingsObserver::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ContentSettingsObserver, message)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_SetAsInterstitial, OnSetAsInterstitial)
-    IPC_MESSAGE_HANDLER(ChromeViewMsg_SetAllowRunningInsecureContent,
-                        OnSetAllowRunningInsecureContent)
-    IPC_MESSAGE_HANDLER(ChromeViewMsg_ReloadFrame, OnReloadFrame);
     IPC_MESSAGE_HANDLER(ChromeViewMsg_RequestFileSystemAccessAsyncResponse,
                         OnRequestFileSystemAccessAsyncResponse)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   if (handled)
     return true;
 
   // Don't swallow LoadBlockedPlugins messages, as they're sent to every
   // blocked plugin.
   IPC_BEGIN_MESSAGE_MAP(ContentSettingsObserver, message)
@@ skipping 24 matching lines @@
   // If we start failing this DCHECK, please makes sure we don't regress
   // this bug: http://code.google.com/p/chromium/issues/detail?id=79304
   DCHECK(frame->document().getSecurityOrigin().toString() == "null" ||
          !url.SchemeIs(url::kDataScheme));
 }
 
 void ContentSettingsObserver::OnDestruct() {
   delete this;
 }
 
+void ContentSettingsObserver::SetAllowRunningInsecureContent() {
+  allow_running_insecure_content_ = true;
+
+  // Reload if we are the main frame.
+  blink::WebLocalFrame* frame = render_frame()->GetWebFrame();
+  if (!frame->parent())
+    frame->reload(blink::WebFrameLoadType::ReloadMainResource);
+}
+
+void ContentSettingsObserver::OnInsecureContentRendererRequest(
+    chrome::mojom::InsecureContentRendererRequest request) {
+  insecure_content_renderer_bindings_.AddBinding(this, std::move(request));
+}
+
 bool ContentSettingsObserver::allowDatabase(const WebString& name,
                                             const WebString& display_name,
                                             unsigned estimated_size) {
   WebFrame* frame = render_frame()->GetWebFrame();
   if (frame->getSecurityOrigin().isUnique() ||
       frame->top()->getSecurityOrigin().isUnique())
     return false;
 
   bool result = false;
   Send(new ChromeViewHostMsg_AllowDatabase(
@@ skipping 209 matching lines @@
 
 void ContentSettingsObserver::OnLoadBlockedPlugins(
     const std::string& identifier) {
   temporarily_allowed_plugins_.insert(identifier);
 }
 
 void ContentSettingsObserver::OnSetAsInterstitial() {
   is_interstitial_page_ = true;
 }
 
-void ContentSettingsObserver::OnSetAllowRunningInsecureContent(bool allow) {
-  allow_running_insecure_content_ = allow;
-}
-
-void ContentSettingsObserver::OnReloadFrame() {
-  DCHECK(!render_frame()->GetWebFrame()->parent()) <<
-      "Should only be called on the main frame";
-  render_frame()->GetWebFrame()->reload(
-      blink::WebFrameLoadType::ReloadMainResource);
-}
-
 void ContentSettingsObserver::OnRequestFileSystemAccessAsyncResponse(
     int request_id,
     bool allowed) {
   PermissionRequestMap::iterator it = permission_requests_.find(request_id);
   if (it == permission_requests_.end())
     return;
 
   WebContentSettingCallbacks callbacks = it->second;
   permission_requests_.erase(it);
 
@@ skipping 72 matching lines @@
 #endif
 
   // If the scheme is file:, an empty file name indicates a directory listing,
   // which requires JavaScript to function properly.
   if (protocol == url::kFileScheme &&
       document_url.protocolIs(url::kFileScheme)) {
     return GURL(document_url).ExtractFileName().empty();
   }
   return false;
 }