dist/changes-5.6.1

@@ -23,7 +23,7 @@ information about a particular change.
 ****************************************************************************
 
  - Chromium Snapshot:
-   * Security fixes from Chromium up to version 50.0.2661.94
+   * Security fixes from Chromium up to version 51.0.2704.63
    * [QTBUG-52602] Fixed devtools so it works with newer Chrome releases.
    * [QTBUG-52085, QTBUG-53108] qrc urls can now load local files.
 

examples/webenginewidgets/simplebrowser/webview.cpp

@@ -45,6 +45,7 @@
 #include "webpopupwindow.h"
 #include "webview.h"
 #include <QContextMenuEvent>
+#include <QDebug>
 #include <QMenu>
 #include <QMessageBox>
 #include <QNetworkReply>

3rdparty @ dc08e397

-Subproject commit 19e3d1d3af80efee4377a4e5fcb9c214dba5be4e
+Subproject commit dc08e3972d36a63dd477de0de005b3e81a5674d9

src/core/config/desktop_linux.pri

@@ -6,5 +6,9 @@ GYP_CONFIG += \
     desktop_linux=1 \
     enable_plugins=1 \
 
-linux-clang: GYP_CONFIG += clang=1 host_clang=1 clang_use_chrome_plugins=0 make_clang_dir=/usr
-else: GYP_CONFIG += clang=0 host_clang=0
+clang {
+    GYP_CONFIG += clang=1 host_clang=1 clang_use_chrome_plugins=0 make_clang_dir=/usr
+    linux-clang-libc++: GYP_CONFIG += use_system_libcxx=1
+} else {
+    GYP_CONFIG += clang=0 host_clang=0
+}

src/core/core_gyp_generator.pro

@@ -70,6 +70,7 @@ SOURCES = \
         render_widget_host_view_qt.cpp \
         renderer/content_renderer_client_qt.cpp \
         renderer/pepper/pepper_flash_browser_host_qt.cpp \
+        renderer/pepper/pepper_flash_clipboard_message_filter_qt.cpp \
         renderer/pepper/pepper_flash_renderer_host_qt.cpp \
         renderer/pepper/pepper_host_factory_qt.cpp \
         renderer/pepper/pepper_renderer_host_factory_qt.cpp \
@@ -145,6 +146,7 @@ HEADERS = \
         render_widget_host_view_qt_delegate.h \
         renderer/content_renderer_client_qt.h \
         renderer/pepper/pepper_flash_browser_host_qt.h \
+        renderer/pepper/pepper_flash_clipboard_message_filter_qt.h \
         renderer/pepper/pepper_flash_renderer_host_qt.h \
         renderer/pepper/pepper_host_factory_qt.h \
         renderer/pepper/pepper_renderer_host_factory_qt.h \

src/core/core_module.pro

@@ -14,6 +14,8 @@ load(qt_module)
 api_library_name = qtwebenginecoreapi$$qtPlatformTargetSuffix()
 api_library_path = $$OUT_PWD/api/$$getConfigDir()
 
+# Do not precompile any headers. We are only interested in the linker step.
+PRECOMPILED_HEADER =
 
 LIBS_PRIVATE += -L$$api_library_path
 CONFIG *= no_smart_library_merge

src/core/location_provider_qt.cpp

@@ -41,11 +41,13 @@
 #include "type_conversion.h"
 
 #include <QtCore/QCoreApplication>
+#include <QtCore/QMetaObject>
 #include <QtCore/QThread>
 #include <QtPositioning/QGeoPositionInfoSource>
 
-#include "base/message_loop/message_loop.h"
 #include "base/bind.h"
+#include "base/memory/weak_ptr.h"
+#include "base/message_loop/message_loop.h"
 #include "content/browser/geolocation/geolocation_provider_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/geolocation_provider.h"
@@ -60,9 +62,9 @@ public:
     QtPositioningHelper(LocationProviderQt *provider);
     ~QtPositioningHelper();
 
-    void start(bool highAccuracy);
-    void stop();
-    void refresh();
+    Q_INVOKABLE void start(bool highAccuracy);
+    Q_INVOKABLE void stop();
+    Q_INVOKABLE void refresh();
 
 private Q_SLOTS:
     void updatePosition(const QGeoPositionInfo &);
@@ -72,6 +74,7 @@ private Q_SLOTS:
 private:
     LocationProviderQt *m_locationProvider;
     QGeoPositionInfoSource *m_positionInfoSource;
+    base::WeakPtrFactory<LocationProviderQt> m_locationProviderFactory;
 
     void postToLocationProvider(const base::Closure &task);
     friend class LocationProviderQt;
@@ -80,14 +83,13 @@ private:
 QtPositioningHelper::QtPositioningHelper(LocationProviderQt *provider)
     : m_locationProvider(provider)
     , m_positionInfoSource(0)
+    , m_locationProviderFactory(provider)
 {
     Q_ASSERT(provider);
 }
 
 QtPositioningHelper::~QtPositioningHelper()
 {
-    if (m_locationProvider)
-        m_locationProvider->m_positioningHelper = 0;
 }
 
 static bool isHighAccuracySource(const QGeoPositionInfoSource *source)
@@ -183,7 +185,8 @@ void QtPositioningHelper::updatePosition(const QGeoPositionInfo &pos)
     newPos.speed =  pos.hasAttribute(QGeoPositionInfo::GroundSpeed) ? pos.attribute(QGeoPositionInfo::GroundSpeed) : -1;
     newPos.heading =  pos.hasAttribute(QGeoPositionInfo::Direction) ? pos.attribute(QGeoPositionInfo::Direction) : -1;
 
-    postToLocationProvider(base::Bind(&LocationProviderQt::updatePosition, base::Unretained(m_locationProvider), newPos));
+    if (m_locationProvider)
+        postToLocationProvider(base::Bind(&LocationProviderQt::updatePosition, m_locationProviderFactory.GetWeakPtr(), newPos));
 }
 
 void QtPositioningHelper::error(QGeoPositionInfoSource::Error positioningError)
@@ -200,7 +203,8 @@ void QtPositioningHelper::error(QGeoPositionInfoSource::Error positioningError)
         newPos.error_code = content::Geoposition::ERROR_CODE_POSITION_UNAVAILABLE;
         break;
     }
-    postToLocationProvider(base::Bind(&LocationProviderQt::updatePosition, base::Unretained(m_locationProvider), newPos));
+    if (m_locationProvider)
+        postToLocationProvider(base::Bind(&LocationProviderQt::updatePosition, m_locationProviderFactory.GetWeakPtr(), newPos));
 }
 
 void QtPositioningHelper::timeout()
@@ -210,7 +214,8 @@ void QtPositioningHelper::timeout()
     // argument used in JS never comes all the way to the browser process.
     // Let's just treat it like any other error where the position is unavailable.
     newPos.error_code = content::Geoposition::ERROR_CODE_POSITION_UNAVAILABLE;
-    postToLocationProvider(base::Bind(&LocationProviderQt::updatePosition, base::Unretained(m_locationProvider), newPos));
+    if (m_locationProvider)
+        postToLocationProvider(base::Bind(&LocationProviderQt::updatePosition, m_locationProviderFactory.GetWeakPtr(), newPos));
 }
 
 inline void QtPositioningHelper::postToLocationProvider(const base::Closure &task)
@@ -227,6 +232,7 @@ LocationProviderQt::~LocationProviderQt()
 {
     if (m_positioningHelper) {
         m_positioningHelper->m_locationProvider = 0;
+        m_positioningHelper->m_locationProviderFactory.InvalidateWeakPtrs();
         m_positioningHelper->deleteLater();
     }
 }
@@ -238,23 +244,21 @@ bool LocationProviderQt::StartProvider(bool highAccuracy)
         m_positioningHelper = new QtPositioningHelper(this);
         m_positioningHelper->moveToThread(guiThread);
     }
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(&QtPositioningHelper::start
-                                                                 , base::Unretained(m_positioningHelper), highAccuracy));
+
+    QMetaObject::invokeMethod(m_positioningHelper, "start", Qt::QueuedConnection, Q_ARG(bool, highAccuracy));
     return true;
 }
 
 void LocationProviderQt::StopProvider()
 {
     if (m_positioningHelper)
-        BrowserThread::PostTask(BrowserThread::UI,FROM_HERE, base::Bind(&QtPositioningHelper::stop
-                                                                     , base::Unretained(m_positioningHelper)));
+        QMetaObject::invokeMethod(m_positioningHelper, "stop", Qt::QueuedConnection);
 }
 
 void LocationProviderQt::RequestRefresh()
 {
     if (m_positioningHelper)
-        BrowserThread::PostTask(BrowserThread::UI,FROM_HERE, base::Bind(&QtPositioningHelper::refresh
-                                                                     , base::Unretained(m_positioningHelper)));
+        QMetaObject::invokeMethod(m_positioningHelper, "refresh", Qt::QueuedConnection);
 }
 
 void LocationProviderQt::OnPermissionGranted()

src/core/render_widget_host_view_qt.cpp

@@ -838,12 +838,12 @@ void RenderWidgetHostViewQt::sendDelegatedFrameAck()
 
 void RenderWidgetHostViewQt::processMotionEvent(const ui::MotionEvent &motionEvent)
 {
-    if (!m_gestureProvider.OnTouchEvent(motionEvent).succeeded)
+    auto result = m_gestureProvider.OnTouchEvent(motionEvent);
+    if (!result.succeeded)
         return;
 
-    bool causesScrollingIfUncancelled = true;
     blink::WebTouchEvent touchEvent = ui::CreateWebTouchEventFromMotionEvent(motionEvent,
-                                                                             causesScrollingIfUncancelled);
+                                                                             result.did_generate_scroll);
     m_host->ForwardTouchEventWithLatencyInfo(touchEvent, CreateLatencyInfo(touchEvent));
 }
 

src/core/renderer/pepper/pepper_flash_clipboard_message_filter_qt.cpp

+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtWebEngine module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+// based on chrome/browser/renderer_host/pepper/pepper_flash_clipboard_message_filter.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 "pepper_flash_clipboard_message_filter_qt.h"
+
+#include "base/pickle.h"
+#include "base/strings/utf_string_conversions.h"
+#include "content/public/browser/browser_thread.h"
+#include "ipc/ipc_message.h"
+#include "ipc/ipc_message_macros.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/c/private/ppb_flash_clipboard.h"
+#include "ppapi/host/dispatch_host_message.h"
+#include "ppapi/host/host_message_context.h"
+#include "ppapi/host/ppapi_host.h"
+#include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/proxy/resource_message_params.h"
+#include "ui/base/clipboard/scoped_clipboard_writer.h"
+
+using content::BrowserThread;
+
+namespace QtWebEngineCore {
+
+namespace {
+
+const size_t kMaxClipboardWriteSize = 1000000;
+
+ui::ClipboardType ConvertClipboardType(uint32_t type)
+{
+    switch (type) {
+    case PP_FLASH_CLIPBOARD_TYPE_STANDARD:
+        return ui::CLIPBOARD_TYPE_COPY_PASTE;
+    case PP_FLASH_CLIPBOARD_TYPE_SELECTION:
+        return ui::CLIPBOARD_TYPE_SELECTION;
+    }
+    NOTREACHED();
+    return ui::CLIPBOARD_TYPE_COPY_PASTE;
+}
+
+// Functions to pack/unpack custom data from a pickle. See the header file for
+// more detail on custom formats in Pepper.
+// TODO(raymes): Currently pepper custom formats are stored in their own
+// native format type. However we should be able to store them in the same way
+// as "Web Custom" formats are. This would allow clipboard data to be shared
+// between pepper applications and web applications. However currently web apps
+// assume all data that is placed on the clipboard is UTF16 and pepper allows
+// arbitrary data so this change would require some reworking of the chrome
+// clipboard interface for custom data.
+bool JumpToFormatInPickle(const base::string16& format, base::PickleIterator* iter)
+{
+    size_t size = 0;
+    if (!iter->ReadSizeT(&size))
+        return false;
+    for (size_t i = 0; i < size; ++i) {
+        base::string16 stored_format;
+        if (!iter->ReadString16(&stored_format))
+            return false;
+        if (stored_format == format)
+            return true;
+        int skip_length;
+        if (!iter->ReadLength(&skip_length))
+            return false;
+        if (!iter->SkipBytes(skip_length))
+            return false;
+    }
+    return false;
+}
+
+bool IsFormatAvailableInPickle(const base::string16& format, const base::Pickle& pickle)
+{
+    base::PickleIterator iter(pickle);
+    return JumpToFormatInPickle(format, &iter);
+}
+
+std::string ReadDataFromPickle(const base::string16& format, const base::Pickle& pickle)
+{
+    std::string result;
+    base::PickleIterator iter(pickle);
+    if (!JumpToFormatInPickle(format, &iter) || !iter.ReadString(&result))
+        return std::string();
+    return result;
+}
+
+bool WriteDataToPickle(const std::map<base::string16, std::string>& data, base::Pickle* pickle)
+{
+    pickle->WriteSizeT(data.size());
+    for (std::map<base::string16, std::string>::const_iterator it = data.begin(); it != data.end(); ++it) {
+        if (!pickle->WriteString16(it->first))
+            return false;
+        if (!pickle->WriteString(it->second))
+            return false;
+    }
+    return true;
+}
+
+}  // namespace
+
+PepperFlashClipboardMessageFilter::PepperFlashClipboardMessageFilter() {}
+
+PepperFlashClipboardMessageFilter::~PepperFlashClipboardMessageFilter() {}
+
+scoped_refptr<base::TaskRunner>
+PepperFlashClipboardMessageFilter::OverrideTaskRunnerForMessage(const IPC::Message& msg)
+{
+    // Clipboard writes should always occur on the UI thread due to the
+    // restrictions of various platform APIs. In general, the clipboard is not
+    // thread-safe, so all clipboard calls should be serviced from the UI thread.
+    if (msg.type() == PpapiHostMsg_FlashClipboard_WriteData::ID)
+        return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI);
+
+    // Windows needs clipboard reads to be serviced from the IO thread because
+    // these are sync IPCs which can result in deadlocks with plugins if serviced
+    // from the UI thread. Note that Windows clipboard calls ARE thread-safe so it
+    // is ok for reads and writes to be serviced from different threads.
+#if !defined(OS_WIN)
+    return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI);
+#else
+    return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
+#endif
+}
+
+int32_t PepperFlashClipboardMessageFilter::OnResourceMessageReceived(const IPC::Message& msg,
+                                                                     ppapi::host::HostMessageContext* context)
+{
+    PPAPI_BEGIN_MESSAGE_MAP(PepperFlashClipboardMessageFilter, msg)
+        PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_FlashClipboard_RegisterCustomFormat,
+                                          OnMsgRegisterCustomFormat)
+        PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_FlashClipboard_IsFormatAvailable,
+                                          OnMsgIsFormatAvailable)
+        PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_FlashClipboard_ReadData,
+                                          OnMsgReadData)
+        PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_FlashClipboard_WriteData,
+                                          OnMsgWriteData)
+        PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_FlashClipboard_GetSequenceNumber,
+                                          OnMsgGetSequenceNumber)
+    PPAPI_END_MESSAGE_MAP()
+    return PP_ERROR_FAILED;
+}
+
+int32_t PepperFlashClipboardMessageFilter::OnMsgRegisterCustomFormat(
+    ppapi::host::HostMessageContext* host_context,
+    const std::string& format_name)
+{
+    uint32_t format = m_custom_formats.RegisterFormat(format_name);
+    if (format == PP_FLASH_CLIPBOARD_FORMAT_INVALID)
+        return PP_ERROR_FAILED;
+    host_context->reply_msg = PpapiPluginMsg_FlashClipboard_RegisterCustomFormatReply(format);
+    return PP_OK;
+}
+
+int32_t PepperFlashClipboardMessageFilter::OnMsgIsFormatAvailable(
+    ppapi::host::HostMessageContext* host_context,
+    uint32_t clipboard_type,
+    uint32_t format)
+{
+    if (clipboard_type != PP_FLASH_CLIPBOARD_TYPE_STANDARD) {
+        NOTIMPLEMENTED();
+        return PP_ERROR_FAILED;
+    }
+
+    ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
+    ui::ClipboardType type = ConvertClipboardType(clipboard_type);
+    bool available = false;
+    switch (format) {
+    case PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT: {
+        bool plain = clipboard->IsFormatAvailable(ui::Clipboard::GetPlainTextFormatType(), type);
+        bool plainw = clipboard->IsFormatAvailable(ui::Clipboard::GetPlainTextWFormatType(), type);
+        available = plain || plainw;
+        break;
+    }
+    case PP_FLASH_CLIPBOARD_FORMAT_HTML:
+        available = clipboard->IsFormatAvailable(ui::Clipboard::GetHtmlFormatType(), type);
+        break;
+    case PP_FLASH_CLIPBOARD_FORMAT_RTF:
+        available = clipboard->IsFormatAvailable(ui::Clipboard::GetRtfFormatType(), type);
+        break;
+    case PP_FLASH_CLIPBOARD_FORMAT_INVALID:
+        break;
+    default:
+        if (m_custom_formats.IsFormatRegistered(format)) {
+            std::string format_name = m_custom_formats.GetFormatName(format);
+            std::string clipboard_data;
+            clipboard->ReadData(ui::Clipboard::GetPepperCustomDataFormatType(), &clipboard_data);
+            base::Pickle pickle(clipboard_data.data(), clipboard_data.size());
+            available = IsFormatAvailableInPickle(base::UTF8ToUTF16(format_name), pickle);
+        }
+        break;
+    }
+
+    return available ? PP_OK : PP_ERROR_FAILED;
+}
+
+int32_t PepperFlashClipboardMessageFilter::OnMsgReadData(
+    ppapi::host::HostMessageContext* host_context,
+    uint32_t clipboard_type,
+    uint32_t format)
+{
+    if (clipboard_type != PP_FLASH_CLIPBOARD_TYPE_STANDARD) {
+        NOTIMPLEMENTED();
+        return PP_ERROR_FAILED;
+    }
+
+    ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
+    ui::ClipboardType type = ConvertClipboardType(clipboard_type);
+    std::string clipboard_string;
+    int32_t result = PP_ERROR_FAILED;
+    switch (format) {
+    case PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT: {
+        if (clipboard->IsFormatAvailable(ui::Clipboard::GetPlainTextWFormatType(), type)) {
+            base::string16 text;
+            clipboard->ReadText(type, &text);
+            if (!text.empty()) {
+                result = PP_OK;
+                clipboard_string = base::UTF16ToUTF8(text);
+                break;
+            }
+        }
+        // If the PlainTextW format isn't available or is empty, take the
+        // ASCII text format.
+        if (clipboard->IsFormatAvailable(ui::Clipboard::GetPlainTextFormatType(), type)) {
+            result = PP_OK;
+            clipboard->ReadAsciiText(type, &clipboard_string);
+        }
+        break;
+    }
+    case PP_FLASH_CLIPBOARD_FORMAT_HTML: {
+        if (!clipboard->IsFormatAvailable(ui::Clipboard::GetHtmlFormatType(), type)) {
+            break;
+        }
+
+        base::string16 html;
+        std::string url;
+        uint32 fragment_start;
+        uint32 fragment_end;
+        clipboard->ReadHTML(type, &html, &url, &fragment_start, &fragment_end);
+        result = PP_OK;
+        clipboard_string = base::UTF16ToUTF8(html.substr(fragment_start, fragment_end - fragment_start));
+        break;
+    }
+    case PP_FLASH_CLIPBOARD_FORMAT_RTF: {
+        if (!clipboard->IsFormatAvailable(ui::Clipboard::GetRtfFormatType(), type)) {
+            break;
+        }
+        result = PP_OK;
+        clipboard->ReadRTF(type, &clipboard_string);
+        break;
+    }
+    case PP_FLASH_CLIPBOARD_FORMAT_INVALID:
+        break;
+    default:
+        if (m_custom_formats.IsFormatRegistered(format)) {
+            base::string16 format_name =
+                base::UTF8ToUTF16(m_custom_formats.GetFormatName(format));
+            std::string clipboard_data;
+            clipboard->ReadData(ui::Clipboard::GetPepperCustomDataFormatType(),
+                                &clipboard_data);
+            base::Pickle pickle(clipboard_data.data(), clipboard_data.size());
+            if (IsFormatAvailableInPickle(format_name, pickle)) {
+                result = PP_OK;
+                clipboard_string = ReadDataFromPickle(format_name, pickle);
+            }
+        }
+        break;
+    }
+
+    if (result == PP_OK) {
+        host_context->reply_msg = PpapiPluginMsg_FlashClipboard_ReadDataReply(clipboard_string);
+    }
+    return result;
+}
+
+int32_t PepperFlashClipboardMessageFilter::OnMsgWriteData(
+    ppapi::host::HostMessageContext* host_context,
+    uint32_t clipboard_type,
+    const std::vector<uint32_t>& formats,
+    const std::vector<std::string>& data)
+{
+    if (clipboard_type != PP_FLASH_CLIPBOARD_TYPE_STANDARD) {
+        NOTIMPLEMENTED();
+        return PP_ERROR_FAILED;
+    }
+    if (formats.size() != data.size())
+        return PP_ERROR_FAILED;
+
+    ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
+    ui::ClipboardType type = ConvertClipboardType(clipboard_type);
+    // If no formats are passed in clear the clipboard.
+    if (formats.size() == 0) {
+        clipboard->Clear(type);
+        return PP_OK;
+    }
+
+    ui::ScopedClipboardWriter scw(type);
+    std::map<base::string16, std::string> custom_data_map;
+    int32_t res = PP_OK;
+    for (uint32_t i = 0; i < formats.size(); ++i) {
+        if (data[i].length() > kMaxClipboardWriteSize) {
+            res = PP_ERROR_NOSPACE;
+            break;
+        }
+
+        switch (formats[i]) {
+        case PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT:
+            scw.WriteText(base::UTF8ToUTF16(data[i]));
+            break;
+        case PP_FLASH_CLIPBOARD_FORMAT_HTML:
+            scw.WriteHTML(base::UTF8ToUTF16(data[i]), std::string());
+            break;
+        case PP_FLASH_CLIPBOARD_FORMAT_RTF:
+            scw.WriteRTF(data[i]);
+            break;
+        case PP_FLASH_CLIPBOARD_FORMAT_INVALID:
+            res = PP_ERROR_BADARGUMENT;
+            break;
+        default:
+            if (m_custom_formats.IsFormatRegistered(formats[i])) {
+                std::string format_name = m_custom_formats.GetFormatName(formats[i]);
+                custom_data_map[base::UTF8ToUTF16(format_name)] = data[i];
+            } else {
+                // Invalid format.
+                res = PP_ERROR_BADARGUMENT;
+                break;
+            }
+        }
+
+        if (res != PP_OK)
+            break;
+    }
+
+    if (custom_data_map.size() > 0) {
+        base::Pickle pickle;
+        if (WriteDataToPickle(custom_data_map, &pickle)) {
+            scw.WritePickledData(pickle, ui::Clipboard::GetPepperCustomDataFormatType());
+        } else {
+            res = PP_ERROR_BADARGUMENT;
+        }
+    }
+
+    if (res != PP_OK) {
+        // Need to clear the objects so nothing is written.
+        scw.Reset();
+    }
+
+    return res;
+}
+
+int32_t PepperFlashClipboardMessageFilter::OnMsgGetSequenceNumber(
+    ppapi::host::HostMessageContext* host_context,
+    uint32_t clipboard_type)
+{
+    if (clipboard_type != PP_FLASH_CLIPBOARD_TYPE_STANDARD) {
+        NOTIMPLEMENTED();
+        return PP_ERROR_FAILED;
+    }
+
+    ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
+    ui::ClipboardType type = ConvertClipboardType(clipboard_type);
+    int64_t sequence_number = clipboard->GetSequenceNumber(type);
+    host_context->reply_msg = PpapiPluginMsg_FlashClipboard_GetSequenceNumberReply(sequence_number);
+    return PP_OK;
+}
+
+}  // namespace QtWebEngineCore

src/core/renderer/pepper/pepper_flash_clipboard_message_filter_qt.h

+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtWebEngine module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+// based on chrome/browser/renderer_host/pepper/pepper_flash_clipboard_message_filter.h
+// 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.
+
+#ifndef PEPPER_FLASH_CLIPBOARD_MESSAGE_FILTER_QT_H
+#define PEPPER_FLASH_CLIPBOARD_MESSAGE_FILTER_QT_H
+
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "ppapi/host/resource_message_filter.h"
+#include "ppapi/shared_impl/flash_clipboard_format_registry.h"
+
+namespace ppapi {
+namespace host {
+struct HostMessageContext;
+}
+}
+
+namespace ui {
+class ScopedClipboardWriter;
+}
+
+namespace QtWebEngineCore {
+
+// Resource message filter for accessing the clipboard in Pepper. Pepper
+// supports reading/writing custom formats from the clipboard. Currently, all
+// custom formats that are read/written from the clipboard through pepper are
+// stored in a single real clipboard format (in the same way the "web custom"
+// clipboard formats are). This is done so that we don't have to have use real
+// clipboard types for each custom clipboard format which may be a limited
+// resource on a particular platform.
+class PepperFlashClipboardMessageFilter : public ppapi::host::ResourceMessageFilter {
+public:
+    PepperFlashClipboardMessageFilter();
+
+protected:
+    // ppapi::host::ResourceMessageFilter overrides.
+    scoped_refptr<base::TaskRunner> OverrideTaskRunnerForMessage(const IPC::Message& msg) override;
+    int32_t OnResourceMessageReceived(const IPC::Message& msg, ppapi::host::HostMessageContext* context) override;
+
+private:
+    ~PepperFlashClipboardMessageFilter() override;
+
+    int32_t OnMsgRegisterCustomFormat(ppapi::host::HostMessageContext* host_context, const std::string& format_name);
+    int32_t OnMsgIsFormatAvailable(ppapi::host::HostMessageContext* host_context,
+                                   uint32_t clipboard_type,
+                                   uint32_t format);
+    int32_t OnMsgReadData(ppapi::host::HostMessageContext* host_context,
+                          uint32_t clipoard_type,
+                          uint32_t format);
+    int32_t OnMsgWriteData(ppapi::host::HostMessageContext* host_context,
+                           uint32_t clipboard_type,
+                           const std::vector<uint32_t>& formats,
+                           const std::vector<std::string>& data);
+    int32_t OnMsgGetSequenceNumber(ppapi::host::HostMessageContext* host_context,
+                                   uint32_t clipboard_type);
+
+    int32_t WriteClipboardDataItem(uint32_t format,
+                                   const std::string& data,
+                                   ui::ScopedClipboardWriter* scw);
+
+    ppapi::FlashClipboardFormatRegistry m_custom_formats;
+
+    DISALLOW_COPY_AND_ASSIGN(PepperFlashClipboardMessageFilter);
+};
+
+}  // namespace QtWebEngineCore
+
+#endif  // PEPPER_FLASH_CLIPBOARD_MESSAGE_FILTER_QT_H

src/core/renderer/pepper/pepper_host_factory_qt.cpp

@@ -44,9 +44,9 @@
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/ppapi_permissions.h"
 #include "pepper_flash_browser_host_qt.h"
+#include "pepper_flash_clipboard_message_filter_qt.h"
 
 using ppapi::host::MessageFilterHost;
-using ppapi::host::ResourceHost;
 using ppapi::host::ResourceMessageFilter;
 
 namespace QtWebEngineCore {
@@ -69,12 +69,18 @@ scoped_ptr<ppapi::host::ResourceHost> PepperHostFactoryQt::CreateResourceHost(pp
     if (!host_->IsValidInstance(instance))
         return scoped_ptr<ppapi::host::ResourceHost>();
 
-    if (host_->GetPpapiHost()->permissions().HasPermission(ppapi::PERMISSION_FLASH)
-            && message.type() == PpapiHostMsg_Flash_Create::ID)
-        return scoped_ptr<ppapi::host::ResourceHost>(
-                    new PepperFlashBrowserHostQt(host_,
-                                                 instance,
-                                                 resource));
+    // Flash interfaces.
+    if (host_->GetPpapiHost()->permissions().HasPermission(ppapi::PERMISSION_FLASH)) {
+        switch (message.type()) {
+        case PpapiHostMsg_Flash_Create::ID:
+            return scoped_ptr<ppapi::host::ResourceHost>(new PepperFlashBrowserHostQt(host_, instance, resource));
+        case PpapiHostMsg_FlashClipboard_Create::ID: {
+            scoped_refptr<ResourceMessageFilter> clipboard_filter(new PepperFlashClipboardMessageFilter);
+            return scoped_ptr<ppapi::host::ResourceHost>(new MessageFilterHost(
+                host_->GetPpapiHost(), instance, resource, clipboard_filter));
+        }
+        }
+    }
 
     return scoped_ptr<ppapi::host::ResourceHost>();
 }

src/webengine/api/qquickwebengineview_p.h

@@ -51,6 +51,7 @@
 #include <private/qtwebengineglobal_p.h>
 #include "qquickwebenginescript_p.h"
 #include <QQuickItem>
+#include <QtGui/qcolor.h>
 
 QT_BEGIN_NAMESPACE
 

src/webengine/doc/qtwebengine.qdocconf

@@ -4,8 +4,6 @@ project                 = QtWebEngine
 description             = Qt WebEngine Reference Documentation
 version                 = $QT_VERSION
 
-examplesinstallpath     = qtwebengine
-
 qhp.projects            = QtWebEngine
 
 qhp.QtWebEngine.file                = qtwebengine.qhp

src/webenginewidgets/doc/src/qwebenginesettings_lgpl.qdoc

@@ -86,7 +86,8 @@
     This enum type specifies settings for web pages:
 
     \value  AutoLoadImages
-            Automatically loads images on web pages. Enabled by default.
+            Automatically dowloads images for web pages. When this setting is
+            disabled, images are loaded from the cache. Enabled by default.
     \value  JavascriptEnabled
             Enables the running of JavaScript programs. Enabled by default.
     \value  JavascriptCanOpenWindows

tests/auto/quick/qmltests/BLACKLIST

@@ -5,5 +5,4 @@
 osx
 
 [WebViewGeopermission::test_geoPermissionRequest]
-osx
-windows
+*

tests/auto/widgets/qwebenginepage/BLACKLIST

@@ -3,6 +3,3 @@
 
 [macCopyUnicodeToClipboard]
 osx
-
-[setHtmlWithImageResource]
-*

tests/auto/widgets/qwebenginepage/tst_qwebenginepage.cpp

@@ -3948,26 +3948,26 @@ void tst_QWebEnginePage::setHtml()
 
 void tst_QWebEnginePage::setHtmlWithImageResource()
 {
-    // By default, only security origins of local files can load local resources.
-    // So we should specify baseUrl to be a local file in order to get a proper origin and load the local image.
+    // We allow access to qrc resources from any security origin, including local and anonymous
 
     QLatin1String html("<html><body><p>hello world</p><img src='qrc:/resources/image.png'/></body></html>");
     QWebEnginePage page;
 
-    page.setHtml(html, QUrl(QLatin1String("file:///path/to/file")));
-    waitForSignal(&page, SIGNAL(loadFinished(bool)));
+    QSignalSpy spy(&page, SIGNAL(loadFinished(bool)));
+    page.setHtml(html, QUrl("file:///path/to/file"));
+    QTRY_COMPARE(spy.count(), 1);
 
     QCOMPARE(evaluateJavaScriptSync(&page, "document.images.length").toInt(), 1);
     QCOMPARE(evaluateJavaScriptSync(&page, "document.images[0].width").toInt(), 128);
     QCOMPARE(evaluateJavaScriptSync(&page, "document.images[0].height").toInt(), 128);
 
-    // Now we test the opposite: without a baseUrl as a local file, we cannot request local resources.
+    // Now we test the opposite: without a baseUrl as a local file, we can still request qrc resources.
 
     page.setHtml(html);
-    waitForSignal(&page, SIGNAL(loadFinished(bool)));
+    QTRY_COMPARE(spy.count(), 2);
     QCOMPARE(evaluateJavaScriptSync(&page, "document.images.length").toInt(), 1);
-    QCOMPARE(evaluateJavaScriptSync(&page, "document.images[0].width").toInt(), 0);
-    QCOMPARE(evaluateJavaScriptSync(&page, "document.images[0].height").toInt(), 0);
+    QCOMPARE(evaluateJavaScriptSync(&page, "document.images[0].width").toInt(), 128);
+    QCOMPARE(evaluateJavaScriptSync(&page, "document.images[0].height").toInt(), 128);
 }
 
 void tst_QWebEnginePage::setHtmlWithStylesheetResource()