Implement Web Restrictions in WebView.

android_webview/renderer/aw_content_renderer_client.cc

 // Copyright 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 "android_webview/renderer/aw_content_renderer_client.h"
 
 #include <vector>
 
 #include "android_webview/common/aw_resource.h"
 #include "android_webview/common/aw_switches.h"
 #include "android_webview/common/render_view_messages.h"
 #include "android_webview/common/url_constants.h"
 #include "android_webview/grit/aw_resources.h"
 #include "android_webview/grit/aw_strings.h"
 #include "android_webview/renderer/aw_content_settings_client.h"
 #include "android_webview/renderer/aw_key_systems.h"
 #include "android_webview/renderer/aw_message_port_client.h"
 #include "android_webview/renderer/aw_print_web_view_helper_delegate.h"
 #include "android_webview/renderer/aw_render_frame_ext.h"
 #include "android_webview/renderer/aw_render_view_ext.h"
 #include "android_webview/renderer/print_render_frame_observer.h"
 #include "base/command_line.h"
 #include "base/i18n/rtl.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/content/renderer/autofill_agent.h"
 #include "components/autofill/content/renderer/password_autofill_agent.h"
 #include "components/printing/renderer/print_web_view_helper.h"
+#include "components/supervised_user_error_page/gin_wrapper.h"
+#include "components/supervised_user_error_page/supervised_user_error_page_android.h"
 #include "components/visitedlink/renderer/visitedlink_slave.h"
+#include "components/web_restrictions/interfaces/web_restrictions.mojom.h"
+#include "content/public/common/service_registry.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/renderer/document_state.h"
 #include "content/public/renderer/navigation_state.h"
 #include "content/public/renderer/render_frame.h"
+#include "content/public/renderer/render_frame_observer.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
 #include "net/base/escape.h"
 #include "net/base/net_errors.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
+#include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebNavigationType.h"
 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "url/gurl.h"
 #include "url/url_constants.h"
 
 using content::RenderThread;
 
+namespace {

[Bernhard Bauer, 2016/05/19 10:00:15]

Nit: Empty lines inside the namespace.

[aberent, 2016/05/19 15:44:02]

Done.

+class ErrorPageObserver : public content::RenderFrameObserver {
+ public:
+  ErrorPageObserver(content::RenderFrame* render_frame,
+                    const std::string& url,
+                    const web_restrictions::mojom::WebRestrictionsPtr&
+                        web_restrictions_service)
+      : content::RenderFrameObserver(render_frame),
+        url_(url),
+        web_restrictions_service_(web_restrictions_service) {}
+
+  void DidClearWindowObject() override {
+    supervised_user_error_page::GinWrapper::InstallWhenFrameReady(
+        render_frame(), url_, web_restrictions_service_);
+  }
+
+ private:
+  std::string url_;
+  const web_restrictions::mojom::WebRestrictionsPtr& web_restrictions_service_;
+};
+}
+
 namespace android_webview {
 
-AwContentRendererClient::AwContentRendererClient() {}
+AwContentRendererClient::AwContentRendererClient() : weak_ptr_factory_(this) {}
 
 AwContentRendererClient::~AwContentRendererClient() {}
 
 void AwContentRendererClient::RenderThreadStarted() {
   RenderThread* thread = RenderThread::Get();
   aw_render_thread_observer_.reset(new AwRenderThreadObserver);
   thread->AddObserver(aw_render_thread_observer_.get());
 
   visited_link_slave_.reset(new visitedlink::VisitedLinkSlave);
   thread->AddObserver(visited_link_slave_.get());
@@ skipping 94 matching lines @@
       render_view, std::unique_ptr<printing::PrintWebViewHelper::Delegate>(
                        new AwPrintWebViewHelperDelegate()));
 }
 
 bool AwContentRendererClient::HasErrorPage(int http_status_code,
                           std::string* error_domain) {
   return http_status_code >= 400;
 }
 
 void AwContentRendererClient::GetNavigationErrorStrings(
-    content::RenderFrame* /* render_frame */,
+    content::RenderFrame* render_frame,
     const blink::WebURLRequest& failed_request,
     const blink::WebURLError& error,
     std::string* error_html,
     base::string16* error_description) {
   if (error_html) {
-    std::string url =
-        net::EscapeForHTML(GURL(failed_request.url()).possibly_invalid_spec());
+    GURL gurl(failed_request.url());
+    std::string url = net::EscapeForHTML(gurl.possibly_invalid_spec());
     std::string err =
         base::UTF16ToUTF8(base::StringPiece16(error.localizedDescription));
 
     std::vector<std::string> replacements;
     replacements.push_back(
         l10n_util::GetStringUTF8(IDS_AW_WEBPAGE_NOT_AVAILABLE));
     if (err.empty()) {
       replacements.push_back(l10n_util::GetStringFUTF8(
           IDS_AW_WEBPAGE_TEMPORARILY_DOWN, base::UTF8ToUTF16(url)));
       replacements.push_back(l10n_util::GetStringUTF8(
           IDS_AW_WEBPAGE_TEMPORARILY_DOWN_SUGGESTIONS));
     } else {
       replacements.push_back(l10n_util::GetStringFUTF8(
           IDS_AW_WEBPAGE_CAN_NOT_BE_LOADED, base::UTF8ToUTF16(url)));
       replacements.push_back(err);
     }
     if (base::i18n::IsRTL())
       replacements.push_back("direction: rtl;");
     else
       replacements.push_back("");
     *error_html = base::ReplaceStringPlaceholders(
         ResourceBundle::GetSharedInstance().GetRawDataResource(
             IDR_AW_LOAD_ERROR_HTML),
         replacements, nullptr);
+    if (error.reason == net::ERR_BLOCKED_BY_ADMINISTRATOR) {
+      // This needs more information
+      render_frame->GetServiceRegistry()->ConnectToRemoteService(
+          mojo::GetProxy(&web_restrictions_service_));
+      web_restrictions::mojom::ClientResultPtr result;
+      if (web_restrictions_service_->GetResult(mojo::String(url), &result)) {
+        *error_html =
+            supervised_user_error_page::BuildHtmlFromWebRestrictionsResult(
+                result, RenderThread::Get()->GetLocale());
+        if (result->intParams["Allow access requests"]) {

[Bernhard Bauer, 2016/05/19 10:00:15]

Extract the string (and the others) to constants?

[aberent, 2016/05/19 15:44:02]

Actually I have just taken this if statement out. Installing the GIN wrapper is
harmless if we don't allow access requests, and extra logic gives more
opportunity for bugs.

I don't know where the other strings in this file come from, and they are
nothing to do with this CL, so I don't want to touch them.

+          supervised_user_error_page::GinWrapper::InstallWhenFrameReady(
+              render_frame, url, web_restrictions_service_);
+        }
+      }
+    }
   }
   if (error_description) {
     if (error.localizedDescription.isEmpty())
       *error_description = base::ASCIIToUTF16(net::ErrorToString(error.reason));
     else
       *error_description = error.localizedDescription;
   }
 }
 
 unsigned long long AwContentRendererClient::VisitedLinkHash(
@@ skipping 28 matching lines @@
   for (const auto& extension : kMediaPlayerExtensions) {
     if (base::EndsWith(url.path(), extension,
                        base::CompareCase::INSENSITIVE_ASCII)) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace android_webview