Basic adaptations for 64-based

Change-Id: I11e2da206e4e59872a38c178f57a5879c1bbf229
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

3 files changed, 65 insertions, 41 deletions

diff --git a/src/core/renderer/content_renderer_client_qt.cpp b/src/core/renderer/content_renderer_client_qt.cpp
index a77bcf785..63b99c7bc 100644
--- a/src/core/renderer/content_renderer_client_qt.cpp
+++ b/src/core/renderer/content_renderer_client_qt.cpp
@@ -80,6 +80,7 @@
 #include "renderer/user_resource_controller.h"
 #include "renderer/web_channel_ipc_transport.h"
 #include "services/service_manager/public/cpp/binder_registry.h"
+#include "services/service_manager/public/cpp/connector.h"
 
 #include "components/grit/components_resources.h"
 
@@ -115,7 +116,7 @@ void ContentRendererClientQt::RenderThreadStarted()
     renderThread->AddObserver(UserResourceController::instance());
 
 #if BUILDFLAG(ENABLE_SPELLCHECK)
-    m_spellCheck.reset(new SpellCheck());
+    m_spellCheck.reset(new SpellCheck(this));
     renderThread->AddObserver(m_spellCheck.data());
 #endif
 }
@@ -134,7 +135,7 @@ void ContentRendererClientQt::RenderFrameCreated(content::RenderFrame* render_fr
     UserResourceController::instance()->renderFrameCreated(render_frame);
 
 #if BUILDFLAG(ENABLE_SPELLCHECK)
-    new SpellCheckProvider(render_frame, m_spellCheck.data());
+    new SpellCheckProvider(render_frame, m_spellCheck.data(), this);
 #endif
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
     new printing::PrintRenderFrameHelper(
@@ -182,22 +183,26 @@ bool ContentRendererClientQt::ShouldSuppressErrorPage(content::RenderFrame *fram
     return !(frame->GetWebkitPreferences().enable_error_page);
 }
 
-std::string domain2String(blink::WebURLError::Domain domain)
+// To tap into the chromium localized strings. Ripped from the chrome layer (highly simplified).
+void ContentRendererClientQt::GetNavigationErrorStrings(content::RenderFrame* renderFrame, const blink::WebURLRequest &failedRequest,
+                                                        const blink::WebURLError &web_error,
+                                                        std::string *errorHtml, base::string16 *errorDescription)
 {
-    switch (domain) {
-    case blink::WebURLError::Domain::kEmpty:
-        return "(null)";
-    case blink::WebURLError::Domain::kNet:
-        return "net";
-    case blink::WebURLError::Domain::kTest:
-        return "testing";
-    }
-    Q_UNREACHABLE();
-    return std::string();
+    GetNavigationErrorStringsInternal(renderFrame, failedRequest,
+                                      error_page::Error::NetError(web_error.url(), web_error.reason(), web_error.has_copy_in_cache()),
+                                      errorHtml, errorDescription);
 }
 
-// To tap into the chromium localized strings. Ripped from the chrome layer (highly simplified).
-void ContentRendererClientQt::GetNavigationErrorStrings(content::RenderFrame* renderFrame, const blink::WebURLRequest &failedRequest, const blink::WebURLError &error, std::string *errorHtml, base::string16 *errorDescription)
+void ContentRendererClientQt::GetNavigationErrorStringsForHttpStatusError(content::RenderFrame* renderFrame, const blink::WebURLRequest& failedRequest,
+                                                                          const GURL& unreachable_url, int http_status,
+                                                                          std::string* errorHtml, base::string16* errorDescription)
+{
+    GetNavigationErrorStringsInternal(renderFrame, failedRequest,
+                                      error_page::Error::HttpError(unreachable_url, http_status),
+                                      errorHtml, errorDescription);
+}
+
+void ContentRendererClientQt::GetNavigationErrorStringsInternal(content::RenderFrame */*renderFrame*/, const blink::WebURLRequest &failedRequest, const error_page::Error &error, std::string *errorHtml, base::string16 *errorDescription)
 {
     const bool isPost = QByteArray::fromStdString(failedRequest.HttpMethod().Utf8()) == QByteArrayLiteral("POST");
 
@@ -211,8 +216,8 @@ void ContentRendererClientQt::GetNavigationErrorStrings(content::RenderFrame* re
         // NetErrorHelper::GetErrorStringsForDnsProbe, but that one is harder to untangle.
 
         error_page::LocalizedError::GetStrings(
-            error.reason, domain2String(error.domain), error.unreachable_url, isPost,
-            error.stale_copy_in_cache, false, false,
+            error.reason(), error.domain(), error.url(), isPost,
+            error.stale_copy_in_cache(), false, false,
             locale, std::unique_ptr<error_page::ErrorPageParams>(), &errorStrings);
         resourceId = IDR_NET_ERROR_HTML;
 
@@ -224,7 +229,7 @@ void ContentRendererClientQt::GetNavigationErrorStrings(content::RenderFrame* re
     }
 
     if (errorDescription)
-        *errorDescription = error_page::LocalizedError::GetErrorDetails(domain2String(error.domain), error.reason, isPost);
+        *errorDescription = error_page::LocalizedError::GetErrorDetails(error.domain(), error.reason(), isPost);
 }
 
 unsigned long long ContentRendererClientQt::VisitedLinkHash(const char *canonicalUrl, size_t length)
@@ -237,6 +242,13 @@ bool ContentRendererClientQt::IsLinkVisited(unsigned long long linkHash)
     return m_visitedLinkSlave->IsVisited(linkHash);
 }
 
+void ContentRendererClientQt::GetInterface(const std::string &interface_name, mojo::ScopedMessagePipeHandle interface_pipe)
+{
+    content::RenderThread::Get()->GetConnector()->BindInterface(service_manager::Identity("qtwebengine"),
+                                                                interface_name,
+                                                                std::move(interface_pipe));
+}
+
 // The following is based on chrome/renderer/media/chrome_key_systems.cc:
 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
@@ -246,18 +258,18 @@ bool ContentRendererClientQt::IsLinkVisited(unsigned long long linkHash)
 static const char kExternalClearKeyPepperType[] = "application/x-ppapi-clearkey-cdm";
 
 static bool IsPepperCdmAvailable(const std::string& pepper_type,
-                                 std::vector<base::string16>* additional_param_names,
-                                 std::vector<base::string16>* additional_param_values)
+                                 std::vector<content::WebPluginMimeType::Param>* additional_params)
 {
-    bool is_available = false;
+    base::Optional<std::vector<content::WebPluginMimeType::Param>> opt_additional_params;
     content::RenderThread::Get()->Send(
         new QtWebEngineHostMsg_IsInternalPluginAvailableForMimeType(
             pepper_type,
-            &is_available,
-            additional_param_names,
-            additional_param_values));
+            &opt_additional_params));
+
+    if (opt_additional_params)
+        *additional_params = *opt_additional_params;
 
-    return is_available;
+    return opt_additional_params.has_value();
 }
 
 // KeySystemProperties implementation for external Clear Key systems.
@@ -349,11 +361,8 @@ static void AddExternalClearKey(std::vector<std::unique_ptr<media::KeySystemProp
     static const char kExternalClearKeyCrashKeySystem[] =
         "org.chromium.externalclearkey.crash";
 
-    std::vector<base::string16> additional_param_names;
-    std::vector<base::string16> additional_param_values;
-    if (!IsPepperCdmAvailable(kExternalClearKeyPepperType,
-                              &additional_param_names,
-                              &additional_param_values))
+    std::vector<content::WebPluginMimeType::Param> additional_params;
+    if (!IsPepperCdmAvailable(kExternalClearKeyPepperType, &additional_params))
         return;
 
     concrete_key_systems->emplace_back(
@@ -389,11 +398,8 @@ static void AddPepperBasedWidevine(std::vector<std::unique_ptr<media::KeySystemP
 //        return;
 //#endif  // defined(WIDEVINE_CDM_MIN_GLIBC_VERSION)
 
-    std::vector<base::string16> additional_param_names;
-    std::vector<base::string16> additional_param_values;
-    if (!IsPepperCdmAvailable(kWidevineCdmPluginMimeType,
-                              &additional_param_names,
-                              &additional_param_values)) {
+    std::vector<content::WebPluginMimeType::Param> additional_params;
+    if (!IsPepperCdmAvailable(kWidevineCdmPluginMimeType, &additional_params)) {
         DVLOG(1) << "Widevine CDM is not currently available.";
         return;
     }
diff --git a/src/core/renderer/content_renderer_client_qt.h b/src/core/renderer/content_renderer_client_qt.h
index 18cf129c2..11538b3f0 100644
--- a/src/core/renderer/content_renderer_client_qt.h
+++ b/src/core/renderer/content_renderer_client_qt.h
@@ -41,9 +41,14 @@
 
 #include "content/public/renderer/content_renderer_client.h"
 #include "components/spellcheck/spellcheck_build_features.h"
+#include "services/service_manager/public/cpp/local_interface_provider.h"
 
 #include <QScopedPointer>
 
+namespace error_page {
+class Error;
+}
+
 namespace visitedlink {
 class VisitedLinkSlave;
 }
@@ -58,7 +63,9 @@ class SpellCheck;
 
 namespace QtWebEngineCore {
 
-class ContentRendererClientQt : public content::ContentRendererClient {
+class ContentRendererClientQt : public content::ContentRendererClient
+                              , public service_manager::LocalInterfaceProvider
+{
 public:
     ContentRendererClientQt();
     ~ContentRendererClientQt();
@@ -69,6 +76,9 @@ public:
     bool HasErrorPage(int http_status_code) override;
     void GetNavigationErrorStrings(content::RenderFrame* renderFrame, const blink::WebURLRequest& failedRequest,
                                    const blink::WebURLError& error, std::string* errorHtml, base::string16* errorDescription) override;
+    void GetNavigationErrorStringsForHttpStatusError(content::RenderFrame* render_frame, const blink::WebURLRequest& failed_request,
+                                                     const GURL& unreachable_url, int http_status,
+                                                     std::string* error_html, base::string16* error_description) override;
 
     unsigned long long VisitedLinkHash(const char *canonicalUrl, size_t length) override;
     bool IsLinkVisited(unsigned long long linkHash) override;
@@ -78,6 +88,13 @@ public:
     void RunScriptsAtDocumentEnd(content::RenderFrame* render_frame) override;
 
 private:
+    // service_manager::LocalInterfaceProvider:
+    void GetInterface(const std::string& name, mojo::ScopedMessagePipeHandle request_handle) override;
+
+    void GetNavigationErrorStringsInternal(content::RenderFrame* renderFrame, const blink::WebURLRequest& failedRequest,
+                                           const error_page::Error& error, std::string* errorHtml, base::string16* errorDescription);
+
+
     QScopedPointer<visitedlink::VisitedLinkSlave> m_visitedLinkSlave;
     QScopedPointer<web_cache::WebCacheImpl> m_webCacheImpl;
 #if BUILDFLAG(ENABLE_SPELLCHECK)
diff --git a/src/core/renderer/pepper/pepper_flash_renderer_host_qt.cpp b/src/core/renderer/pepper/pepper_flash_renderer_host_qt.cpp
index bac1d7c1f..5d21201ba 100644
--- a/src/core/renderer/pepper/pepper_flash_renderer_host_qt.cpp
+++ b/src/core/renderer/pepper/pepper_flash_renderer_host_qt.cpp
@@ -251,12 +251,13 @@ int32_t PepperFlashRendererHostQt::OnDrawGlyphs(
             params.glyph_indices.empty())
         return PP_ERROR_FAILED;
 
-    int style = SkTypeface::kNormal;
-    if (static_cast<PP_BrowserFont_Trusted_Weight>(params.font_desc.weight) >= PP_BROWSERFONT_TRUSTED_WEIGHT_BOLD)
-        style |= SkTypeface::kBold;
+    int weight = (params.font_desc.weight + 1) * 100;
+    SkFontStyle::Slant slant = SkFontStyle::kUpright_Slant;
     if (params.font_desc.italic)
-        style |= SkTypeface::kItalic;
-    sk_sp<SkTypeface> typeface(SkTypeface::MakeFromName(params.font_desc.face.c_str(), SkFontStyle::FromOldStyle(style)));
+      slant = SkFontStyle::kItalic_Slant;
+    SkFontStyle style(weight, SkFontStyle::kNormal_Width, slant);
+    sk_sp<SkTypeface> typeface(
+        SkTypeface::MakeFromName(params.font_desc.face.c_str(), style));
     if (!typeface)
         return PP_ERROR_FAILED;