Merge remote-tracking branch 'origin/5.6' into 5.7

Change-Id: Ib010ede9756fb02992a3276ae7ec90ef1ab56a00

3 files changed, 524 insertions, 9 deletions

diff --git a/src/core/renderer/pepper/pepper_flash_clipboard_message_filter_qt.cpp b/src/core/renderer/pepper/pepper_flash_clipboard_message_filter_qt.cpp
new file mode 100644
index 000000000..c1782844d
--- /dev/null
+++ b/src/core/renderer/pepper/pepper_flash_clipboard_message_filter_qt.cpp
@@ -0,0 +1,401 @@
+/****************************************************************************
+**
+** 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_t fragment_start;
+        uint32_t 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
diff --git a/src/core/renderer/pepper/pepper_flash_clipboard_message_filter_qt.h b/src/core/renderer/pepper/pepper_flash_clipboard_message_filter_qt.h
new file mode 100644
index 000000000..c00e668ea
--- /dev/null
+++ b/src/core/renderer/pepper/pepper_flash_clipboard_message_filter_qt.h
@@ -0,0 +1,108 @@
+/****************************************************************************
+**
+** 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/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
diff --git a/src/core/renderer/pepper/pepper_host_factory_qt.cpp b/src/core/renderer/pepper/pepper_host_factory_qt.cpp
index 9fbd413ef..9b7236d8a 100644
--- a/src/core/renderer/pepper/pepper_host_factory_qt.cpp
+++ b/src/core/renderer/pepper/pepper_host_factory_qt.cpp
@@ -53,10 +53,10 @@
 #include "ppapi/shared_impl/ppapi_permissions.h"
 
 #include "pepper_flash_browser_host_qt.h"
+#include "pepper_flash_clipboard_message_filter_qt.h"
 #include "pepper_isolated_file_system_message_filter.h"
 
 using ppapi::host::MessageFilterHost;
-using ppapi::host::ResourceHost;
 using ppapi::host::ResourceMessageFilter;
 
 namespace QtWebEngineCore {
@@ -79,12 +79,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));
+        }
+        }
+    }
 
     // Permissions for the following interfaces will be checked at the
     // time of the corresponding instance's methods calls (because
@@ -95,8 +101,8 @@ scoped_ptr<ppapi::host::ResourceHost> PepperHostFactoryQt::CreateResourceHost(pp
     if (message.type() == PpapiHostMsg_IsolatedFileSystem_Create::ID) {
         PepperIsolatedFileSystemMessageFilter* isolated_fs_filter = PepperIsolatedFileSystemMessageFilter::Create(instance, host_);
         if (!isolated_fs_filter)
-            return scoped_ptr<ResourceHost>();
-        return scoped_ptr<ResourceHost>(new MessageFilterHost(host, instance, resource, isolated_fs_filter));
+            return scoped_ptr<ppapi::host::ResourceHost>();
+        return scoped_ptr<ppapi::host::ResourceHost>(new MessageFilterHost(host, instance, resource, isolated_fs_filter));
     }
 
     return scoped_ptr<ppapi::host::ResourceHost>();