From 3fdc4543b8a99c17134c87e902ddc1528cce4d74 Mon Sep 17 00:00:00 2001 From: deepak1556 Date: Tue, 28 Apr 2015 21:15:58 +0530 Subject: [PATCH] ppapi flash plugin support --- atom/app/atom_content_client.cc | 69 ++++ atom/app/atom_content_client.h | 2 + atom/browser/atom_browser_client.cc | 10 + atom/browser/atom_browser_client.h | 1 + atom/common/options_switches.cc | 3 + atom/common/options_switches.h | 1 + atom/renderer/atom_renderer_client.cc | 6 + atom/renderer/atom_renderer_client.h | 1 + .../pepper/chrome_browser_pepper_host_factory.cc | 94 ++++++ .../pepper/chrome_browser_pepper_host_factory.h | 38 +++ .../pepper/pepper_broker_message_filter.cc | 54 +++ .../pepper/pepper_broker_message_filter.h | 51 +++ .../pepper/pepper_flash_browser_host.cc | 114 +++++++ .../pepper/pepper_flash_browser_host.h | 60 ++++ .../pepper_flash_clipboard_message_filter.cc | 376 +++++++++++++++++++++ .../pepper/pepper_flash_clipboard_message_filter.h | 78 +++++ .../pepper_isolated_file_system_message_filter.cc | 110 ++++++ .../pepper_isolated_file_system_message_filter.h | 76 +++++ .../pepper/chrome_renderer_pepper_host_factory.cc | 87 +++++ .../pepper/chrome_renderer_pepper_host_factory.h | 35 ++ .../pepper/pepper_flash_drm_renderer_host.cc | 87 +++++ .../pepper/pepper_flash_drm_renderer_host.h | 51 +++ .../renderer/pepper/pepper_flash_font_file_host.cc | 74 ++++ .../renderer/pepper/pepper_flash_font_file_host.h | 52 +++ .../pepper/pepper_flash_fullscreen_host.cc | 43 +++ .../renderer/pepper/pepper_flash_fullscreen_host.h | 37 ++ .../renderer/pepper/pepper_flash_menu_host.cc | 202 +++++++++++ .../renderer/pepper/pepper_flash_menu_host.h | 69 ++++ .../renderer/pepper/pepper_flash_renderer_host.cc | 373 ++++++++++++++++++++ .../renderer/pepper/pepper_flash_renderer_host.h | 69 ++++ .../chrome/renderer/pepper/pepper_helper.cc | 26 ++ .../chrome/renderer/pepper/pepper_helper.h | 25 ++ .../pepper/pepper_shared_memory_message_filter.cc | 72 ++++ .../pepper/pepper_shared_memory_message_filter.h | 48 +++ filenames.gypi | 26 ++ 35 files changed, 2520 insertions(+) create mode 100644 chromium_src/chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.cc create mode 100644 chromium_src/chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h create mode 100644 chromium_src/chrome/browser/renderer_host/pepper/pepper_broker_message_filter.cc create mode 100644 chromium_src/chrome/browser/renderer_host/pepper/pepper_broker_message_filter.h create mode 100644 chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_browser_host.cc create mode 100644 chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_browser_host.h create mode 100644 chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_clipboard_message_filter.cc create mode 100644 chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_clipboard_message_filter.h create mode 100644 chromium_src/chrome/browser/renderer_host/pepper/pepper_isolated_file_system_message_filter.cc create mode 100644 chromium_src/chrome/browser/renderer_host/pepper/pepper_isolated_file_system_message_filter.h create mode 100644 chromium_src/chrome/renderer/pepper/chrome_renderer_pepper_host_factory.cc create mode 100644 chromium_src/chrome/renderer/pepper/chrome_renderer_pepper_host_factory.h create mode 100644 chromium_src/chrome/renderer/pepper/pepper_flash_drm_renderer_host.cc create mode 100644 chromium_src/chrome/renderer/pepper/pepper_flash_drm_renderer_host.h create mode 100644 chromium_src/chrome/renderer/pepper/pepper_flash_font_file_host.cc create mode 100644 chromium_src/chrome/renderer/pepper/pepper_flash_font_file_host.h create mode 100644 chromium_src/chrome/renderer/pepper/pepper_flash_fullscreen_host.cc create mode 100644 chromium_src/chrome/renderer/pepper/pepper_flash_fullscreen_host.h create mode 100644 chromium_src/chrome/renderer/pepper/pepper_flash_menu_host.cc create mode 100644 chromium_src/chrome/renderer/pepper/pepper_flash_menu_host.h create mode 100644 chromium_src/chrome/renderer/pepper/pepper_flash_renderer_host.cc create mode 100644 chromium_src/chrome/renderer/pepper/pepper_flash_renderer_host.h create mode 100644 chromium_src/chrome/renderer/pepper/pepper_helper.cc create mode 100644 chromium_src/chrome/renderer/pepper/pepper_helper.h create mode 100644 chromium_src/chrome/renderer/pepper/pepper_shared_memory_message_filter.cc create mode 100644 chromium_src/chrome/renderer/pepper/pepper_shared_memory_message_filter.h diff --git a/atom/app/atom_content_client.cc b/atom/app/atom_content_client.cc index f4beeb5..5d97fe5 100644 --- a/atom/app/atom_content_client.cc +++ b/atom/app/atom_content_client.cc @@ -8,9 +8,65 @@ #include #include "atom/common/chrome_version.h" +#include "atom/common/options_switches.h" +#include "base/command_line.h" +#include "base/strings/string_split.h" +#include "base/strings/string_util.h" +#include "content/public/common/content_constants.h" +#include "content/public/common/pepper_plugin_info.h" +#include "ppapi/shared_impl/ppapi_permissions.h" namespace atom { +int32 kPepperFlashPermissions = ppapi::PERMISSION_DEV | + ppapi::PERMISSION_PRIVATE | + ppapi::PERMISSION_BYPASS_USER_GESTURE | + ppapi::PERMISSION_FLASH; + +namespace { + + content::PepperPluginInfo CreatePepperFlashInfo(const base::FilePath& path, + const std::string& version) { + content::PepperPluginInfo plugin; + + plugin.is_out_of_process = true; + plugin.name = content::kFlashPluginName; + plugin.path = path; + plugin.permissions = kPepperFlashPermissions; + + std::vector flash_version_numbers; + base::SplitString(version, '.', &flash_version_numbers); + if (flash_version_numbers.size() < 1) + flash_version_numbers.push_back("11"); + // |SplitString()| puts in an empty string given an empty string. :( + else if (flash_version_numbers[0].empty()) + flash_version_numbers[0] = "11"; + if (flash_version_numbers.size() < 2) + flash_version_numbers.push_back("2"); + if (flash_version_numbers.size() < 3) + flash_version_numbers.push_back("999"); + if (flash_version_numbers.size() < 4) + flash_version_numbers.push_back("999"); + // E.g., "Shockwave Flash 10.2 r154": + plugin.description = plugin.name + " " + flash_version_numbers[0] + "." + + flash_version_numbers[1] + " r" + flash_version_numbers[2]; + plugin.version = JoinString(flash_version_numbers, '.'); + content::WebPluginMimeType swf_mime_type( + content::kFlashPluginSwfMimeType, + content::kFlashPluginSwfExtension, + content::kFlashPluginSwfDescription); + plugin.mime_types.push_back(swf_mime_type); + content::WebPluginMimeType spl_mime_type( + content::kFlashPluginSplMimeType, + content::kFlashPluginSplExtension, + content::kFlashPluginSplDescription); + plugin.mime_types.push_back(spl_mime_type); + + return plugin; + } + +} // namespace + AtomContentClient::AtomContentClient() { } @@ -27,4 +83,17 @@ void AtomContentClient::AddAdditionalSchemes( standard_schemes->push_back("chrome-extension"); } +void AtomContentClient::AddPepperPlugins( + std::vector* plugins) { + const base::CommandLine::StringType flash_path = + base::CommandLine::ForCurrentProcess()->GetSwitchValueNative( + switches::kPpapiFlashPath); + if (flash_path.empty()) + return; + + std::string flash_version; + plugins->push_back( + CreatePepperFlashInfo(base::FilePath(flash_path), flash_version)); +} + } // namespace atom diff --git a/atom/app/atom_content_client.h b/atom/app/atom_content_client.h index 732ac35..279ec71 100644 --- a/atom/app/atom_content_client.h +++ b/atom/app/atom_content_client.h @@ -23,6 +23,8 @@ class AtomContentClient : public brightray::ContentClient { void AddAdditionalSchemes( std::vector* standard_schemes, std::vector* savable_schemes) override; + void AddPepperPlugins( + std::vector* plugins) override; private: DISALLOW_COPY_AND_ASSIGN(AtomContentClient); diff --git a/atom/browser/atom_browser_client.cc b/atom/browser/atom_browser_client.cc index c897d5d..69ae0d3 100644 --- a/atom/browser/atom_browser_client.cc +++ b/atom/browser/atom_browser_client.cc @@ -16,13 +16,16 @@ #include "base/command_line.h" #include "base/strings/string_number_conversions.h" #include "chrome/browser/printing/printing_message_filter.h" +#include "chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h" #include "chrome/browser/speech/tts_message_filter.h" +#include "content/public/browser/browser_ppapi_host.h" #include "content/public/browser/render_process_host.h" #include "content/public/browser/render_view_host.h" #include "content/public/browser/resource_dispatcher_host.h" #include "content/public/browser/site_instance.h" #include "content/public/browser/web_contents.h" #include "content/public/common/web_preferences.h" +#include "ppapi/host/ppapi_host.h" #include "ui/base/l10n/l10n_util.h" namespace atom { @@ -197,6 +200,13 @@ void AtomBrowserClient::AppendExtraCommandLineSwitches( dying_render_process_ = nullptr; } +void AtomBrowserClient::DidCreatePpapiPlugin( + content::BrowserPpapiHost* browser_host) { + browser_host->GetPpapiHost()->AddHostFactoryFilter( + scoped_ptr( + new chrome::ChromeBrowserPepperHostFactory(browser_host))); +} + brightray::BrowserMainParts* AtomBrowserClient::OverrideCreateBrowserMainParts( const content::MainFunctionParams&) { v8::V8::Initialize(); // Init V8 before creating main parts. diff --git a/atom/browser/atom_browser_client.h b/atom/browser/atom_browser_client.h index 629ac96..cda0bd8 100644 --- a/atom/browser/atom_browser_client.h +++ b/atom/browser/atom_browser_client.h @@ -35,6 +35,7 @@ class AtomBrowserClient : public brightray::BrowserClient { content::SiteInstance** new_instance); void AppendExtraCommandLineSwitches(base::CommandLine* command_line, int child_process_id) override; + void DidCreatePpapiPlugin(content::BrowserPpapiHost* browser_host) override; private: brightray::BrowserMainParts* OverrideCreateBrowserMainParts( diff --git a/atom/common/options_switches.cc b/atom/common/options_switches.cc index c479b50..37daa89 100644 --- a/atom/common/options_switches.cc +++ b/atom/common/options_switches.cc @@ -63,6 +63,9 @@ const char kDirectWrite[] = "direct-write"; // Enable plugins. const char kEnablePlugins[] = "enable-plugins"; +// Ppapi Flash path. +const char kPpapiFlashPath[] = "ppapi-flash-path"; + // Instancd ID of guest WebContents. const char kGuestInstanceID[] = "guest-instance-id"; diff --git a/atom/common/options_switches.h b/atom/common/options_switches.h index 546c6a0..d6f8c07 100644 --- a/atom/common/options_switches.h +++ b/atom/common/options_switches.h @@ -37,6 +37,7 @@ extern const char kEnableLargerThanScreen[]; extern const char kDarkTheme[]; extern const char kDirectWrite[]; extern const char kEnablePlugins[]; +extern const char kPpapiFlashPath[]; extern const char kGuestInstanceID[]; extern const char kPreloadScript[]; extern const char kTransparent[]; diff --git a/atom/renderer/atom_renderer_client.cc b/atom/renderer/atom_renderer_client.cc index cc48bc0..d90a90b 100644 --- a/atom/renderer/atom_renderer_client.cc +++ b/atom/renderer/atom_renderer_client.cc @@ -11,6 +11,7 @@ #include "atom/common/options_switches.h" #include "atom/renderer/atom_render_view_observer.h" #include "atom/renderer/guest_view_container.h" +#include "chrome/renderer/pepper/pepper_helper.h" #include "chrome/renderer/printing/print_web_view_helper.h" #include "chrome/renderer/tts_dispatcher.h" #include "content/public/common/content_constants.h" @@ -79,6 +80,11 @@ void AtomRendererClient::RenderThreadStarted() { content::RenderThread::Get()->AddObserver(this); } +void AtomRendererClient::RenderFrameCreated( + content::RenderFrame* render_frame) { + new PepperHelper(render_frame); +} + void AtomRendererClient::RenderViewCreated(content::RenderView* render_view) { new printing::PrintWebViewHelper(render_view); new AtomRenderViewObserver(render_view, this); diff --git a/atom/renderer/atom_renderer_client.h b/atom/renderer/atom_renderer_client.h index 4aba42c..a709612 100644 --- a/atom/renderer/atom_renderer_client.h +++ b/atom/renderer/atom_renderer_client.h @@ -34,6 +34,7 @@ class AtomRendererClient : public content::ContentRendererClient, // content::ContentRendererClient: void RenderThreadStarted() override; + void RenderFrameCreated(content::RenderFrame*) override; void RenderViewCreated(content::RenderView*) override; blink::WebSpeechSynthesizer* OverrideSpeechSynthesizer( blink::WebSpeechSynthesizerClient* client) override; diff --git a/chromium_src/chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.cc b/chromium_src/chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.cc new file mode 100644 index 0000000..03d706f --- /dev/null +++ b/chromium_src/chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.cc @@ -0,0 +1,94 @@ +// 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/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h" + +#include "build/build_config.h" +#include "chrome/browser/renderer_host/pepper/pepper_broker_message_filter.h" +#include "chrome/browser/renderer_host/pepper/pepper_flash_browser_host.h" +#include "chrome/browser/renderer_host/pepper/pepper_flash_clipboard_message_filter.h" +#include "chrome/browser/renderer_host/pepper/pepper_isolated_file_system_message_filter.h" +#include "content/public/browser/browser_ppapi_host.h" +#include "ppapi/host/message_filter_host.h" +#include "ppapi/host/ppapi_host.h" +#include "ppapi/host/resource_host.h" +#include "ppapi/proxy/ppapi_messages.h" +#include "ppapi/shared_impl/ppapi_permissions.h" + +using ppapi::host::MessageFilterHost; +using ppapi::host::ResourceHost; +using ppapi::host::ResourceMessageFilter; + +namespace chrome { + +ChromeBrowserPepperHostFactory::ChromeBrowserPepperHostFactory( + content::BrowserPpapiHost* host) + : host_(host) {} + +ChromeBrowserPepperHostFactory::~ChromeBrowserPepperHostFactory() {} + +scoped_ptr ChromeBrowserPepperHostFactory::CreateResourceHost( + ppapi::host::PpapiHost* host, + PP_Resource resource, + PP_Instance instance, + const IPC::Message& message) { + DCHECK(host == host_->GetPpapiHost()); + + // Make sure the plugin is giving us a valid instance for this resource. + if (!host_->IsValidInstance(instance)) + return scoped_ptr(); + + // Private interfaces. + if (host_->GetPpapiHost()->permissions().HasPermission( + ppapi::PERMISSION_PRIVATE)) { + switch (message.type()) { + case PpapiHostMsg_Broker_Create::ID: { + scoped_refptr broker_filter( + new PepperBrokerMessageFilter(instance, host_)); + return scoped_ptr(new MessageFilterHost( + host_->GetPpapiHost(), instance, resource, broker_filter)); + } + } + } + + // Flash interfaces. + if (host_->GetPpapiHost()->permissions().HasPermission( + ppapi::PERMISSION_FLASH)) { + switch (message.type()) { + case PpapiHostMsg_Flash_Create::ID: + return scoped_ptr( + new PepperFlashBrowserHost(host_, instance, resource)); + case PpapiHostMsg_FlashClipboard_Create::ID: { + scoped_refptr clipboard_filter( + new PepperFlashClipboardMessageFilter); + return scoped_ptr(new MessageFilterHost( + host_->GetPpapiHost(), instance, resource, clipboard_filter)); + } +#if 0 + case PpapiHostMsg_FlashDRM_Create::ID: + return scoped_ptr( + new PepperFlashDRMHost(host_, instance, resource)); +#endif + } + } + + // Permissions for the following interfaces will be checked at the + // time of the corresponding instance's methods calls (because + // permission check can be performed only on the UI + // thread). Currently these interfaces are available only for + // whitelisted apps which may not have access to the other private + // interfaces. + if (message.type() == PpapiHostMsg_IsolatedFileSystem_Create::ID) { + PepperIsolatedFileSystemMessageFilter* isolated_fs_filter = + PepperIsolatedFileSystemMessageFilter::Create(instance, host_); + if (!isolated_fs_filter) + return scoped_ptr(); + return scoped_ptr( + new MessageFilterHost(host, instance, resource, isolated_fs_filter)); + } + + return scoped_ptr(); +} + +} // namespace chrome diff --git a/chromium_src/chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h b/chromium_src/chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h new file mode 100644 index 0000000..b817953 --- /dev/null +++ b/chromium_src/chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h @@ -0,0 +1,38 @@ +// 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 CHROME_BROWSER_RENDERER_HOST_PEPPER_CHROME_BROWSER_PEPPER_HOST_FACTORY_H_ +#define CHROME_BROWSER_RENDERER_HOST_PEPPER_CHROME_BROWSER_PEPPER_HOST_FACTORY_H_ + +#include "base/compiler_specific.h" +#include "ppapi/host/host_factory.h" + +namespace content { +class BrowserPpapiHost; +} // namespace content + +namespace chrome { + +class ChromeBrowserPepperHostFactory : public ppapi::host::HostFactory { + public: + // Non-owning pointer to the filter must outlive this class. + explicit ChromeBrowserPepperHostFactory(content::BrowserPpapiHost* host); + ~ChromeBrowserPepperHostFactory() override; + + scoped_ptr CreateResourceHost( + ppapi::host::PpapiHost* host, + PP_Resource resource, + PP_Instance instance, + const IPC::Message& message) override; + + private: + // Non-owning pointer. + content::BrowserPpapiHost* host_; + + DISALLOW_COPY_AND_ASSIGN(ChromeBrowserPepperHostFactory); +}; + +} // namespace chrome + +#endif // CHROME_BROWSER_RENDERER_HOST_PEPPER_CHROME_BROWSER_PEPPER_HOST_FACTORY_H_ diff --git a/chromium_src/chrome/browser/renderer_host/pepper/pepper_broker_message_filter.cc b/chromium_src/chrome/browser/renderer_host/pepper/pepper_broker_message_filter.cc new file mode 100644 index 0000000..224b55d --- /dev/null +++ b/chromium_src/chrome/browser/renderer_host/pepper/pepper_broker_message_filter.cc @@ -0,0 +1,54 @@ +// 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/browser/renderer_host/pepper/pepper_broker_message_filter.h" + +#include + +#include "content/public/browser/browser_ppapi_host.h" +#include "content/public/browser/browser_thread.h" +#include "content/public/browser/render_process_host.h" +#include "ipc/ipc_message_macros.h" +#include "ppapi/c/pp_errors.h" +#include "ppapi/host/dispatch_host_message.h" +#include "ppapi/proxy/ppapi_messages.h" +#include "url/gurl.h" + +using content::BrowserPpapiHost; +using content::BrowserThread; +using content::RenderProcessHost; + +namespace chrome { + +PepperBrokerMessageFilter::PepperBrokerMessageFilter(PP_Instance instance, + BrowserPpapiHost* host) + : document_url_(host->GetDocumentURLForInstance(instance)) { + int unused; + host->GetRenderFrameIDsForInstance(instance, &render_process_id_, &unused); +} + +PepperBrokerMessageFilter::~PepperBrokerMessageFilter() {} + +scoped_refptr +PepperBrokerMessageFilter::OverrideTaskRunnerForMessage( + const IPC::Message& message) { + return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI); +} + +int32_t PepperBrokerMessageFilter::OnResourceMessageReceived( + const IPC::Message& msg, + ppapi::host::HostMessageContext* context) { + PPAPI_BEGIN_MESSAGE_MAP(PepperBrokerMessageFilter, msg) + PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_Broker_IsAllowed, + OnIsAllowed) + PPAPI_END_MESSAGE_MAP() + return PP_ERROR_FAILED; +} + +int32_t PepperBrokerMessageFilter::OnIsAllowed( + ppapi::host::HostMessageContext* context) { + return PP_OK; +} + +} // namespace chrome diff --git a/chromium_src/chrome/browser/renderer_host/pepper/pepper_broker_message_filter.h b/chromium_src/chrome/browser/renderer_host/pepper/pepper_broker_message_filter.h new file mode 100644 index 0000000..44627c6 --- /dev/null +++ b/chromium_src/chrome/browser/renderer_host/pepper/pepper_broker_message_filter.h @@ -0,0 +1,51 @@ +// 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 CHROME_BROWSER_RENDERER_HOST_PEPPER_PEPPER_BROKER_MESSAGE_FILTER_H_ +#define CHROME_BROWSER_RENDERER_HOST_PEPPER_PEPPER_BROKER_MESSAGE_FILTER_H_ + +#include "base/compiler_specific.h" +#include "ppapi/c/pp_instance.h" +#include "ppapi/host/resource_message_filter.h" +#include "url/gurl.h" + +namespace content { +class BrowserPpapiHost; +} + +namespace ppapi { +namespace host { +struct HostMessageContext; +} +} + +namespace chrome { + +// This filter handles messages for the PepperBrokerHost on the UI thread. +class PepperBrokerMessageFilter : public ppapi::host::ResourceMessageFilter { + public: + PepperBrokerMessageFilter(PP_Instance instance, + content::BrowserPpapiHost* host); + + private: + ~PepperBrokerMessageFilter() override; + + // ppapi::host::ResourceMessageFilter overrides. + scoped_refptr OverrideTaskRunnerForMessage( + const IPC::Message& message) override; + int32_t OnResourceMessageReceived( + const IPC::Message& msg, + ppapi::host::HostMessageContext* context) override; + + int32_t OnIsAllowed(ppapi::host::HostMessageContext* context); + + int render_process_id_; + GURL document_url_; + + DISALLOW_COPY_AND_ASSIGN(PepperBrokerMessageFilter); +}; + +} // namespace chrome + +#endif // CHROME_BROWSER_RENDERER_HOST_PEPPER_PEPPER_BROKER_MESSAGE_FILTER_H_ diff --git a/chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_browser_host.cc b/chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_browser_host.cc new file mode 100644 index 0000000..43179c6 --- /dev/null +++ b/chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_browser_host.cc @@ -0,0 +1,114 @@ +// 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/browser/renderer_host/pepper/pepper_flash_browser_host.h" + +#include "base/time/time.h" +#include "content/public/browser/browser_context.h" +#include "content/public/browser/browser_ppapi_host.h" +#include "content/public/browser/browser_thread.h" +#include "content/public/browser/render_process_host.h" +#include "ipc/ipc_message_macros.h" +#include "ppapi/c/pp_errors.h" +#include "ppapi/c/private/ppb_flash.h" +#include "ppapi/host/dispatch_host_message.h" +#include "ppapi/proxy/ppapi_messages.h" +#include "ppapi/proxy/resource_message_params.h" +#include "ppapi/shared_impl/time_conversion.h" +#include "url/gurl.h" + +#if defined(OS_WIN) +#include +#elif defined(OS_MACOSX) +#include +#endif + +using content::BrowserPpapiHost; +using content::BrowserThread; +using content::RenderProcessHost; + +namespace chrome { + +PepperFlashBrowserHost::PepperFlashBrowserHost(BrowserPpapiHost* host, + PP_Instance instance, + PP_Resource resource) + : ResourceHost(host->GetPpapiHost(), instance, resource), + host_(host), + weak_factory_(this) { + int unused; + host->GetRenderFrameIDsForInstance(instance, &render_process_id_, &unused); +} + +PepperFlashBrowserHost::~PepperFlashBrowserHost() {} + +int32_t PepperFlashBrowserHost::OnResourceMessageReceived( + const IPC::Message& msg, + ppapi::host::HostMessageContext* context) { + PPAPI_BEGIN_MESSAGE_MAP(PepperFlashBrowserHost, msg) + PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_Flash_UpdateActivity, + OnUpdateActivity) + PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_Flash_GetLocalTimeZoneOffset, + OnGetLocalTimeZoneOffset) + PPAPI_DISPATCH_HOST_RESOURCE_CALL_0( + PpapiHostMsg_Flash_GetLocalDataRestrictions, OnGetLocalDataRestrictions) + PPAPI_END_MESSAGE_MAP() + return PP_ERROR_FAILED; +} + +int32_t PepperFlashBrowserHost::OnUpdateActivity( + ppapi::host::HostMessageContext* host_context) { +#if defined(OS_WIN) + // Reading then writing back the same value to the screensaver timeout system + // setting resets the countdown which prevents the screensaver from turning + // on "for a while". As long as the plugin pings us with this message faster + // than the screensaver timeout, it won't go on. + int value = 0; + if (SystemParametersInfo(SPI_GETSCREENSAVETIMEOUT, 0, &value, 0)) + SystemParametersInfo(SPI_SETSCREENSAVETIMEOUT, value, NULL, 0); +#elif defined(OS_MACOSX) +// UpdateSystemActivity(OverallAct); +#else +// TODO(brettw) implement this for other platforms. +#endif + return PP_OK; +} + +int32_t PepperFlashBrowserHost::OnGetLocalTimeZoneOffset( + ppapi::host::HostMessageContext* host_context, + const base::Time& t) { + // The reason for this processing being in the browser process is that on + // Linux, the localtime calls require filesystem access prohibited by the + // sandbox. + host_context->reply_msg = PpapiPluginMsg_Flash_GetLocalTimeZoneOffsetReply( + ppapi::PPGetLocalTimeZoneOffset(t)); + return PP_OK; +} + +int32_t PepperFlashBrowserHost::OnGetLocalDataRestrictions( + ppapi::host::HostMessageContext* context) { + // Getting the Flash LSO settings requires using the CookieSettings which + // belong to the profile which lives on the UI thread. We lazily initialize + // |cookie_settings_| by grabbing the reference from the UI thread and then + // call |GetLocalDataRestrictions| with it. + GURL document_url = host_->GetDocumentURLForInstance(pp_instance()); + GURL plugin_url = host_->GetPluginURLForInstance(pp_instance()); + GetLocalDataRestrictions(context->MakeReplyMessageContext(), + document_url, + plugin_url); + return PP_OK_COMPLETIONPENDING; +} + +void PepperFlashBrowserHost::GetLocalDataRestrictions( + ppapi::host::ReplyMessageContext reply_context, + const GURL& document_url, + const GURL& plugin_url) { + DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); + + PP_FlashLSORestrictions restrictions = PP_FLASHLSORESTRICTIONS_NONE; + SendReply(reply_context, + PpapiPluginMsg_Flash_GetLocalDataRestrictionsReply( + static_cast(restrictions))); +} + +} // namespace chrome diff --git a/chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_browser_host.h b/chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_browser_host.h new file mode 100644 index 0000000..6fb4ace --- /dev/null +++ b/chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_browser_host.h @@ -0,0 +1,60 @@ +// 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 CHROME_BROWSER_RENDERER_HOST_PEPPER_PEPPER_FLASH_BROWSER_HOST_H_ +#define CHROME_BROWSER_RENDERER_HOST_PEPPER_PEPPER_FLASH_BROWSER_HOST_H_ + +#include "base/basictypes.h" +#include "base/memory/ref_counted.h" +#include "base/memory/weak_ptr.h" +#include "ppapi/host/host_message_context.h" +#include "ppapi/host/resource_host.h" + +namespace base { +class Time; +} + +namespace content { +class BrowserPpapiHost; +class ResourceContext; +} + +class GURL; + +namespace chrome { + +class PepperFlashBrowserHost : public ppapi::host::ResourceHost { + public: + PepperFlashBrowserHost(content::BrowserPpapiHost* host, + PP_Instance instance, + PP_Resource resource); + ~PepperFlashBrowserHost() override; + + // ppapi::host::ResourceHost override. + int32_t OnResourceMessageReceived( + const IPC::Message& msg, + ppapi::host::HostMessageContext* context) override; + + private: + int32_t OnUpdateActivity(ppapi::host::HostMessageContext* host_context); + int32_t OnGetLocalTimeZoneOffset( + ppapi::host::HostMessageContext* host_context, + const base::Time& t); + int32_t OnGetLocalDataRestrictions(ppapi::host::HostMessageContext* context); + + void GetLocalDataRestrictions(ppapi::host::ReplyMessageContext reply_context, + const GURL& document_url, + const GURL& plugin_url); + + content::BrowserPpapiHost* host_; + int render_process_id_; + // For fetching the Flash LSO settings. + base::WeakPtrFactory weak_factory_; + + DISALLOW_COPY_AND_ASSIGN(PepperFlashBrowserHost); +}; + +} // namespace chrome + +#endif // CHROME_BROWSER_RENDERER_HOST_PEPPER_PEPPER_FLASH_BROWSER_HOST_H_ diff --git a/chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_clipboard_message_filter.cc b/chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_clipboard_message_filter.cc new file mode 100644 index 0000000..4499b21 --- /dev/null +++ b/chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_clipboard_message_filter.cc @@ -0,0 +1,376 @@ +// 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/browser/renderer_host/pepper/pepper_flash_clipboard_message_filter.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 chrome { + +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, 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 Pickle& pickle) { + PickleIterator iter(pickle); + return JumpToFormatInPickle(format, &iter); +} + +std::string ReadDataFromPickle(const base::string16& format, + const Pickle& pickle) { + std::string result; + PickleIterator iter(pickle); + if (!JumpToFormatInPickle(format, &iter) || !iter.ReadString(&result)) + return std::string(); + return result; +} + +bool WriteDataToPickle(const std::map& data, + Pickle* pickle) { + pickle->WriteSizeT(data.size()); + for (std::map::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 +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 = 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 (custom_formats_.IsFormatRegistered(format)) { + std::string format_name = custom_formats_.GetFormatName(format); + std::string clipboard_data; + clipboard->ReadData(ui::Clipboard::GetPepperCustomDataFormatType(), + &clipboard_data); + 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 (custom_formats_.IsFormatRegistered(format)) { + base::string16 format_name = + base::UTF8ToUTF16(custom_formats_.GetFormatName(format)); + std::string clipboard_data; + clipboard->ReadData(ui::Clipboard::GetPepperCustomDataFormatType(), + &clipboard_data); + 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& formats, + const std::vector& 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 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 (custom_formats_.IsFormatRegistered(formats[i])) { + std::string format_name = 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) { + 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 chrome diff --git a/chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_clipboard_message_filter.h b/chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_clipboard_message_filter.h new file mode 100644 index 0000000..ff07eb7 --- /dev/null +++ b/chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_clipboard_message_filter.h @@ -0,0 +1,78 @@ +// 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 CHROME_BROWSER_RENDERER_HOST_PEPPER_PEPPER_FLASH_CLIPBOARD_MESSAGE_FILTER_H_ +#define CHROME_BROWSER_RENDERER_HOST_PEPPER_PEPPER_FLASH_CLIPBOARD_MESSAGE_FILTER_H_ + +#include +#include + +#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 chrome { + +// 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 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& formats, + const std::vector& 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 custom_formats_; + + DISALLOW_COPY_AND_ASSIGN(PepperFlashClipboardMessageFilter); +}; + +} // namespace chrome + +#endif // CHROME_BROWSER_RENDERER_HOST_PEPPER_PEPPER_FLASH_CLIPBOARD_MESSAGE_FILTER_H_ diff --git a/chromium_src/chrome/browser/renderer_host/pepper/pepper_isolated_file_system_message_filter.cc b/chromium_src/chrome/browser/renderer_host/pepper/pepper_isolated_file_system_message_filter.cc new file mode 100644 index 0000000..10c0790 --- /dev/null +++ b/chromium_src/chrome/browser/renderer_host/pepper/pepper_isolated_file_system_message_filter.cc @@ -0,0 +1,110 @@ +// Copyright 2013 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/browser/renderer_host/pepper/pepper_isolated_file_system_message_filter.h" + +#include "content/public/browser/browser_ppapi_host.h" +#include "content/public/browser/browser_thread.h" +#include "content/public/browser/child_process_security_policy.h" +#include "content/public/browser/render_view_host.h" +#include "ppapi/c/pp_errors.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/shared_impl/file_system_util.h" +#include "storage/browser/fileapi/isolated_context.h" + +namespace chrome { + +// static +PepperIsolatedFileSystemMessageFilter* +PepperIsolatedFileSystemMessageFilter::Create(PP_Instance instance, + content::BrowserPpapiHost* host) { + int render_process_id; + int unused_render_frame_id; + if (!host->GetRenderFrameIDsForInstance( + instance, &render_process_id, &unused_render_frame_id)) { + return NULL; + } + return new PepperIsolatedFileSystemMessageFilter( + render_process_id, + host->GetProfileDataDirectory(), + host->GetDocumentURLForInstance(instance), + host->GetPpapiHost()); +} + +PepperIsolatedFileSystemMessageFilter::PepperIsolatedFileSystemMessageFilter( + int render_process_id, + const base::FilePath& profile_directory, + const GURL& document_url, + ppapi::host::PpapiHost* ppapi_host) + : render_process_id_(render_process_id), + profile_directory_(profile_directory), + document_url_(document_url), + ppapi_host_(ppapi_host) { +} + +PepperIsolatedFileSystemMessageFilter:: + ~PepperIsolatedFileSystemMessageFilter() {} + +scoped_refptr +PepperIsolatedFileSystemMessageFilter::OverrideTaskRunnerForMessage( + const IPC::Message& msg) { + // In order to reach ExtensionSystem, we need to get ProfileManager first. + // ProfileManager lives in UI thread, so we need to do this in UI thread. + return content::BrowserThread::GetMessageLoopProxyForThread( + content::BrowserThread::UI); +} + +int32_t PepperIsolatedFileSystemMessageFilter::OnResourceMessageReceived( + const IPC::Message& msg, + ppapi::host::HostMessageContext* context) { + PPAPI_BEGIN_MESSAGE_MAP(PepperIsolatedFileSystemMessageFilter, msg) + PPAPI_DISPATCH_HOST_RESOURCE_CALL( + PpapiHostMsg_IsolatedFileSystem_BrowserOpen, + OnOpenFileSystem) + PPAPI_END_MESSAGE_MAP() + return PP_ERROR_FAILED; +} + +int32_t PepperIsolatedFileSystemMessageFilter::OnOpenFileSystem( + ppapi::host::HostMessageContext* context, + PP_IsolatedFileSystemType_Private type) { + switch (type) { + case PP_ISOLATEDFILESYSTEMTYPE_PRIVATE_INVALID: + case PP_ISOLATEDFILESYSTEMTYPE_PRIVATE_CRX: + break; + case PP_ISOLATEDFILESYSTEMTYPE_PRIVATE_PLUGINPRIVATE: + return OpenPluginPrivateFileSystem(context); + } + NOTREACHED(); + context->reply_msg = + PpapiPluginMsg_IsolatedFileSystem_BrowserOpenReply(std::string()); + return PP_ERROR_FAILED; +} + +int32_t PepperIsolatedFileSystemMessageFilter::OpenPluginPrivateFileSystem( + ppapi::host::HostMessageContext* context) { + DCHECK(ppapi_host_); + // Only plugins with private permission can open the filesystem. + if (!ppapi_host_->permissions().HasPermission(ppapi::PERMISSION_PRIVATE)) + return PP_ERROR_NOACCESS; + + const std::string& root_name = ppapi::IsolatedFileSystemTypeToRootName( + PP_ISOLATEDFILESYSTEMTYPE_PRIVATE_PLUGINPRIVATE); + const std::string& fsid = + storage::IsolatedContext::GetInstance()->RegisterFileSystemForVirtualPath( + storage::kFileSystemTypePluginPrivate, root_name, base::FilePath()); + + // Grant full access of isolated filesystem to renderer process. + content::ChildProcessSecurityPolicy* policy = + content::ChildProcessSecurityPolicy::GetInstance(); + policy->GrantCreateReadWriteFileSystem(render_process_id_, fsid); + + context->reply_msg = PpapiPluginMsg_IsolatedFileSystem_BrowserOpenReply(fsid); + return PP_OK; +} + +} // namespace chrome diff --git a/chromium_src/chrome/browser/renderer_host/pepper/pepper_isolated_file_system_message_filter.h b/chromium_src/chrome/browser/renderer_host/pepper/pepper_isolated_file_system_message_filter.h new file mode 100644 index 0000000..6a24fea --- /dev/null +++ b/chromium_src/chrome/browser/renderer_host/pepper/pepper_isolated_file_system_message_filter.h @@ -0,0 +1,76 @@ +// Copyright 2013 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 CHROME_BROWSER_RENDERER_HOST_PEPPER_PEPPER_ISOLATED_FILE_SYSTEM_MESSAGE_FILTER_H_ +#define CHROME_BROWSER_RENDERER_HOST_PEPPER_PEPPER_ISOLATED_FILE_SYSTEM_MESSAGE_FILTER_H_ + +#include +#include + +#include "base/files/file_path.h" +#include "ppapi/c/pp_instance.h" +#include "ppapi/c/pp_resource.h" +#include "ppapi/c/private/ppb_isolated_file_system_private.h" +#include "ppapi/host/resource_host.h" +#include "ppapi/host/resource_message_filter.h" +#include "url/gurl.h" + +class Profile; + +namespace content { +class BrowserPpapiHost; +} + +namespace ppapi { +namespace host { +struct HostMessageContext; +} // namespace host +} // namespace ppapi + +namespace chrome { + +class PepperIsolatedFileSystemMessageFilter + : public ppapi::host::ResourceMessageFilter { + public: + static PepperIsolatedFileSystemMessageFilter* Create( + PP_Instance instance, + content::BrowserPpapiHost* host); + + // ppapi::host::ResourceMessageFilter implementation. + scoped_refptr OverrideTaskRunnerForMessage( + const IPC::Message& msg) override; + int32_t OnResourceMessageReceived( + const IPC::Message& msg, + ppapi::host::HostMessageContext* context) override; + + private: + PepperIsolatedFileSystemMessageFilter(int render_process_id, + const base::FilePath& profile_directory, + const GURL& document_url, + ppapi::host::PpapiHost* ppapi_host_); + + ~PepperIsolatedFileSystemMessageFilter() override; + + // Returns filesystem id of isolated filesystem if valid, or empty string + // otherwise. This must run on the UI thread because ProfileManager only + // allows access on that thread. + + int32_t OnOpenFileSystem(ppapi::host::HostMessageContext* context, + PP_IsolatedFileSystemType_Private type); + int32_t OpenPluginPrivateFileSystem(ppapi::host::HostMessageContext* context); + + const int render_process_id_; + // Keep a copy from original thread. + const base::FilePath profile_directory_; + const GURL document_url_; + + // Not owned by this object. + ppapi::host::PpapiHost* ppapi_host_; + + DISALLOW_COPY_AND_ASSIGN(PepperIsolatedFileSystemMessageFilter); +}; + +} // namespace chrome + +#endif // CHROME_BROWSER_RENDERER_HOST_PEPPER_PEPPER_ISOLATED_FILE_SYSTEM_MESSAGE_FILTER_H_ diff --git a/chromium_src/chrome/renderer/pepper/chrome_renderer_pepper_host_factory.cc b/chromium_src/chrome/renderer/pepper/chrome_renderer_pepper_host_factory.cc new file mode 100644 index 0000000..db92669 --- /dev/null +++ b/chromium_src/chrome/renderer/pepper/chrome_renderer_pepper_host_factory.cc @@ -0,0 +1,87 @@ +// 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/pepper/chrome_renderer_pepper_host_factory.h" + +#include "base/logging.h" +#include "chrome/renderer/pepper/pepper_flash_drm_renderer_host.h" +#include "chrome/renderer/pepper/pepper_flash_font_file_host.h" +#include "chrome/renderer/pepper/pepper_flash_fullscreen_host.h" +#include "chrome/renderer/pepper/pepper_flash_menu_host.h" +#include "chrome/renderer/pepper/pepper_flash_renderer_host.h" +#include "content/public/renderer/renderer_ppapi_host.h" +#include "ppapi/host/ppapi_host.h" +#include "ppapi/host/resource_host.h" +#include "ppapi/proxy/ppapi_message_utils.h" +#include "ppapi/proxy/ppapi_messages.h" +#include "ppapi/shared_impl/ppapi_permissions.h" + +using ppapi::host::ResourceHost; + +ChromeRendererPepperHostFactory::ChromeRendererPepperHostFactory( + content::RendererPpapiHost* host) + : host_(host) {} + +ChromeRendererPepperHostFactory::~ChromeRendererPepperHostFactory() {} + +scoped_ptr ChromeRendererPepperHostFactory::CreateResourceHost( + ppapi::host::PpapiHost* host, + PP_Resource resource, + PP_Instance instance, + const IPC::Message& message) { + DCHECK_EQ(host_->GetPpapiHost(), host); + + // Make sure the plugin is giving us a valid instance for this resource. + if (!host_->IsValidInstance(instance)) + return scoped_ptr(); + + if (host_->GetPpapiHost()->permissions().HasPermission( + ppapi::PERMISSION_FLASH)) { + switch (message.type()) { + case PpapiHostMsg_Flash_Create::ID: { + return scoped_ptr( + new PepperFlashRendererHost(host_, instance, resource)); + } + case PpapiHostMsg_FlashFullscreen_Create::ID: { + return scoped_ptr( + new PepperFlashFullscreenHost(host_, instance, resource)); + } + case PpapiHostMsg_FlashMenu_Create::ID: { + ppapi::proxy::SerializedFlashMenu serialized_menu; + if (ppapi::UnpackMessage( + message, &serialized_menu)) { + return scoped_ptr(new PepperFlashMenuHost( + host_, instance, resource, serialized_menu)); + } + break; + } + } + } + + // TODO(raymes): PDF also needs access to the FlashFontFileHost currently. + // We should either rename PPB_FlashFont_File to PPB_FontFile_Private or get + // rid of its use in PDF if possible. + if (host_->GetPpapiHost()->permissions().HasPermission( + ppapi::PERMISSION_FLASH) || + host_->GetPpapiHost()->permissions().HasPermission( + ppapi::PERMISSION_PRIVATE)) { + switch (message.type()) { + case PpapiHostMsg_FlashFontFile_Create::ID: { + ppapi::proxy::SerializedFontDescription description; + PP_PrivateFontCharset charset; + if (ppapi::UnpackMessage( + message, &description, &charset)) { + return scoped_ptr(new PepperFlashFontFileHost( + host_, instance, resource, description, charset)); + } + break; + } + case PpapiHostMsg_FlashDRM_Create::ID: + return scoped_ptr( + new PepperFlashDRMRendererHost(host_, instance, resource)); + } + } + + return scoped_ptr(); +} diff --git a/chromium_src/chrome/renderer/pepper/chrome_renderer_pepper_host_factory.h b/chromium_src/chrome/renderer/pepper/chrome_renderer_pepper_host_factory.h new file mode 100644 index 0000000..13ab285 --- /dev/null +++ b/chromium_src/chrome/renderer/pepper/chrome_renderer_pepper_host_factory.h @@ -0,0 +1,35 @@ +// 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 CHROME_RENDERER_PEPPER_CHROME_RENDERER_PEPPER_HOST_FACTORY_H_ +#define CHROME_RENDERER_PEPPER_CHROME_RENDERER_PEPPER_HOST_FACTORY_H_ + +#include "base/basictypes.h" +#include "base/compiler_specific.h" +#include "ppapi/host/host_factory.h" + +namespace content { +class RendererPpapiHost; +} + +class ChromeRendererPepperHostFactory : public ppapi::host::HostFactory { + public: + explicit ChromeRendererPepperHostFactory(content::RendererPpapiHost* host); + ~ChromeRendererPepperHostFactory() override; + + // HostFactory. + scoped_ptr CreateResourceHost( + ppapi::host::PpapiHost* host, + PP_Resource resource, + PP_Instance instance, + const IPC::Message& message) override; + + private: + // Not owned by this object. + content::RendererPpapiHost* host_; + + DISALLOW_COPY_AND_ASSIGN(ChromeRendererPepperHostFactory); +}; + +#endif // CHROME_RENDERER_PEPPER_CHROME_RENDERER_PEPPER_HOST_FACTORY_H_ diff --git a/chromium_src/chrome/renderer/pepper/pepper_flash_drm_renderer_host.cc b/chromium_src/chrome/renderer/pepper/pepper_flash_drm_renderer_host.cc new file mode 100644 index 0000000..2e95d23 --- /dev/null +++ b/chromium_src/chrome/renderer/pepper/pepper_flash_drm_renderer_host.cc @@ -0,0 +1,87 @@ +// 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/pepper/pepper_flash_drm_renderer_host.h" + +#include "base/files/file_path.h" +#include "content/public/renderer/pepper_plugin_instance.h" +#include "content/public/renderer/renderer_ppapi_host.h" +#include "ppapi/c/pp_errors.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" + +// TODO(raymes): This is duplicated from pepper_flash_drm_host.cc but once +// FileRef is refactored to the browser, it won't need to be. +namespace { +const char kVoucherFilename[] = "plugin.vch"; +} // namespace + +PepperFlashDRMRendererHost::PepperFlashDRMRendererHost( + content::RendererPpapiHost* host, + PP_Instance instance, + PP_Resource resource) + : ResourceHost(host->GetPpapiHost(), instance, resource), + renderer_ppapi_host_(host), + weak_factory_(this) {} + +PepperFlashDRMRendererHost::~PepperFlashDRMRendererHost() {} + +int32_t PepperFlashDRMRendererHost::OnResourceMessageReceived( + const IPC::Message& msg, + ppapi::host::HostMessageContext* context) { + PPAPI_BEGIN_MESSAGE_MAP(PepperFlashDRMRendererHost, msg) + PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_FlashDRM_GetVoucherFile, + OnGetVoucherFile) + PPAPI_END_MESSAGE_MAP() + return PP_ERROR_FAILED; +} + +int32_t PepperFlashDRMRendererHost::OnGetVoucherFile( + ppapi::host::HostMessageContext* context) { + content::PepperPluginInstance* plugin_instance = + renderer_ppapi_host_->GetPluginInstance(pp_instance()); + if (!plugin_instance) + return PP_ERROR_FAILED; + + base::FilePath plugin_dir = plugin_instance->GetModulePath().DirName(); + DCHECK(!plugin_dir.empty()); + base::FilePath voucher_file = plugin_dir.AppendASCII(kVoucherFilename); + + int renderer_pending_host_id = + plugin_instance->MakePendingFileRefRendererHost(voucher_file); + if (renderer_pending_host_id == 0) + return PP_ERROR_FAILED; + + std::vector create_msgs; + create_msgs.push_back(PpapiHostMsg_FileRef_CreateForRawFS(voucher_file)); + + renderer_ppapi_host_->CreateBrowserResourceHosts( + pp_instance(), + create_msgs, + base::Bind(&PepperFlashDRMRendererHost::DidCreateFileRefHosts, + weak_factory_.GetWeakPtr(), + context->MakeReplyMessageContext(), + voucher_file, + renderer_pending_host_id)); + return PP_OK_COMPLETIONPENDING; +} + +void PepperFlashDRMRendererHost::DidCreateFileRefHosts( + const ppapi::host::ReplyMessageContext& reply_context, + const base::FilePath& external_path, + int renderer_pending_host_id, + const std::vector& browser_pending_host_ids) { + DCHECK_EQ(1U, browser_pending_host_ids.size()); + int browser_pending_host_id = browser_pending_host_ids[0]; + + ppapi::FileRefCreateInfo create_info = + ppapi::MakeExternalFileRefCreateInfo(external_path, + std::string(), + browser_pending_host_id, + renderer_pending_host_id); + host()->SendReply(reply_context, + PpapiPluginMsg_FlashDRM_GetVoucherFileReply(create_info)); +} diff --git a/chromium_src/chrome/renderer/pepper/pepper_flash_drm_renderer_host.h b/chromium_src/chrome/renderer/pepper/pepper_flash_drm_renderer_host.h new file mode 100644 index 0000000..cc06d38 --- /dev/null +++ b/chromium_src/chrome/renderer/pepper/pepper_flash_drm_renderer_host.h @@ -0,0 +1,51 @@ +// 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 CHROME_RENDERER_PEPPER_PEPPER_FLASH_DRM_RENDERER_HOST_H_ +#define CHROME_RENDERER_PEPPER_PEPPER_FLASH_DRM_RENDERER_HOST_H_ + +#include "base/basictypes.h" +#include "base/compiler_specific.h" +#include "base/memory/weak_ptr.h" +#include "ppapi/host/resource_host.h" + +namespace base { +class FilePath; +} + +namespace content { +class RendererPpapiHost; +} + +// TODO(raymes): This is only needed until we move FileRef resources to the +// browser. After that, get rid of this class altogether. +class PepperFlashDRMRendererHost : public ppapi::host::ResourceHost { + public: + PepperFlashDRMRendererHost(content::RendererPpapiHost* host, + PP_Instance instance, + PP_Resource resource); + ~PepperFlashDRMRendererHost() override; + + int32_t OnResourceMessageReceived( + const IPC::Message& msg, + ppapi::host::HostMessageContext* context) override; + + private: + int32_t OnGetVoucherFile(ppapi::host::HostMessageContext* context); + + void DidCreateFileRefHosts( + const ppapi::host::ReplyMessageContext& reply_context, + const base::FilePath& external_path, + int renderer_pending_host_id, + const std::vector& browser_pending_host_ids); + + // Non-owning pointer. + content::RendererPpapiHost* renderer_ppapi_host_; + + base::WeakPtrFactory weak_factory_; + + DISALLOW_COPY_AND_ASSIGN(PepperFlashDRMRendererHost); +}; + +#endif // CHROME_RENDERER_PEPPER_PEPPER_FLASH_DRM_RENDERER_HOST_H_ diff --git a/chromium_src/chrome/renderer/pepper/pepper_flash_font_file_host.cc b/chromium_src/chrome/renderer/pepper/pepper_flash_font_file_host.cc new file mode 100644 index 0000000..305b6ec --- /dev/null +++ b/chromium_src/chrome/renderer/pepper/pepper_flash_font_file_host.cc @@ -0,0 +1,74 @@ +// 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/pepper/pepper_flash_font_file_host.h" + +#include "build/build_config.h" +#include "content/public/renderer/renderer_ppapi_host.h" +#include "ppapi/c/pp_errors.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/serialized_structs.h" + +#if defined(OS_LINUX) || defined(OS_OPENBSD) +#include "content/public/common/child_process_sandbox_support_linux.h" +#endif + +PepperFlashFontFileHost::PepperFlashFontFileHost( + content::RendererPpapiHost* host, + PP_Instance instance, + PP_Resource resource, + const ppapi::proxy::SerializedFontDescription& description, + PP_PrivateFontCharset charset) + : ResourceHost(host->GetPpapiHost(), instance, resource) { +#if defined(OS_LINUX) || defined(OS_OPENBSD) + fd_.reset(content::MatchFontWithFallback( + description.face.c_str(), + description.weight >= PP_BROWSERFONT_TRUSTED_WEIGHT_BOLD, + description.italic, + charset, + PP_BROWSERFONT_TRUSTED_FAMILY_DEFAULT)); +#endif // defined(OS_LINUX) || defined(OS_OPENBSD) +} + +PepperFlashFontFileHost::~PepperFlashFontFileHost() {} + +int32_t PepperFlashFontFileHost::OnResourceMessageReceived( + const IPC::Message& msg, + ppapi::host::HostMessageContext* context) { + PPAPI_BEGIN_MESSAGE_MAP(PepperFlashFontFileHost, msg) + PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_FlashFontFile_GetFontTable, + OnGetFontTable) + PPAPI_END_MESSAGE_MAP() + return PP_ERROR_FAILED; +} + +int32_t PepperFlashFontFileHost::OnGetFontTable( + ppapi::host::HostMessageContext* context, + uint32_t table) { + std::string contents; + int32_t result = PP_ERROR_FAILED; +#if defined(OS_LINUX) || defined(OS_OPENBSD) + int fd = fd_.get(); + if (fd != -1) { + size_t length = 0; + if (content::GetFontTable(fd, table, 0 /* offset */, NULL, &length)) { + contents.resize(length); + uint8_t* contents_ptr = + reinterpret_cast(const_cast(contents.c_str())); + if (content::GetFontTable( + fd, table, 0 /* offset */, contents_ptr, &length)) { + result = PP_OK; + } else { + contents.clear(); + } + } + } +#endif // defined(OS_LINUX) || defined(OS_OPENBSD) + + context->reply_msg = PpapiPluginMsg_FlashFontFile_GetFontTableReply(contents); + return result; +} diff --git a/chromium_src/chrome/renderer/pepper/pepper_flash_font_file_host.h b/chromium_src/chrome/renderer/pepper/pepper_flash_font_file_host.h new file mode 100644 index 0000000..02bb30f --- /dev/null +++ b/chromium_src/chrome/renderer/pepper/pepper_flash_font_file_host.h @@ -0,0 +1,52 @@ +// 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 CHROME_RENDERER_PEPPER_PEPPER_FLASH_FONT_FILE_HOST_H_ +#define CHROME_RENDERER_PEPPER_PEPPER_FLASH_FONT_FILE_HOST_H_ + +#include "base/basictypes.h" +#include "base/compiler_specific.h" +#include "ppapi/c/private/pp_private_font_charset.h" +#include "ppapi/host/resource_host.h" + +#if defined(OS_LINUX) || defined(OS_OPENBSD) +#include "base/files/scoped_file.h" +#endif + +namespace content { +class RendererPpapiHost; +} + +namespace ppapi { +namespace proxy { +struct SerializedFontDescription; +} +} + +class PepperFlashFontFileHost : public ppapi::host::ResourceHost { + public: + PepperFlashFontFileHost( + content::RendererPpapiHost* host, + PP_Instance instance, + PP_Resource resource, + const ppapi::proxy::SerializedFontDescription& description, + PP_PrivateFontCharset charset); + ~PepperFlashFontFileHost() override; + + int32_t OnResourceMessageReceived( + const IPC::Message& msg, + ppapi::host::HostMessageContext* context) override; + + private: + int32_t OnGetFontTable(ppapi::host::HostMessageContext* context, + uint32_t table); + +#if defined(OS_LINUX) || defined(OS_OPENBSD) + base::ScopedFD fd_; +#endif + + DISALLOW_COPY_AND_ASSIGN(PepperFlashFontFileHost); +}; + +#endif // CHROME_RENDERER_PEPPER_PEPPER_FLASH_FONT_FILE_HOST_H_ diff --git a/chromium_src/chrome/renderer/pepper/pepper_flash_fullscreen_host.cc b/chromium_src/chrome/renderer/pepper/pepper_flash_fullscreen_host.cc new file mode 100644 index 0000000..d590cde --- /dev/null +++ b/chromium_src/chrome/renderer/pepper/pepper_flash_fullscreen_host.cc @@ -0,0 +1,43 @@ +// 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/pepper/pepper_flash_fullscreen_host.h" + +#include "content/public/renderer/pepper_plugin_instance.h" +#include "content/public/renderer/renderer_ppapi_host.h" +#include "ppapi/c/pp_errors.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" + +PepperFlashFullscreenHost::PepperFlashFullscreenHost( + content::RendererPpapiHost* host, + PP_Instance instance, + PP_Resource resource) + : ResourceHost(host->GetPpapiHost(), instance, resource), + renderer_ppapi_host_(host) {} + +PepperFlashFullscreenHost::~PepperFlashFullscreenHost() {} + +int32_t PepperFlashFullscreenHost::OnResourceMessageReceived( + const IPC::Message& msg, + ppapi::host::HostMessageContext* context) { + PPAPI_BEGIN_MESSAGE_MAP(PepperFlashFullscreenHost, msg) + PPAPI_DISPATCH_HOST_RESOURCE_CALL( + PpapiHostMsg_FlashFullscreen_SetFullscreen, + OnSetFullscreen) + PPAPI_END_MESSAGE_MAP() + return PP_ERROR_FAILED; +} + +int32_t PepperFlashFullscreenHost::OnSetFullscreen( + ppapi::host::HostMessageContext* context, + bool fullscreen) { + content::PepperPluginInstance* plugin_instance = + renderer_ppapi_host_->GetPluginInstance(pp_instance()); + if (plugin_instance && plugin_instance->FlashSetFullscreen(fullscreen, true)) + return PP_OK; + return PP_ERROR_FAILED; +} diff --git a/chromium_src/chrome/renderer/pepper/pepper_flash_fullscreen_host.h b/chromium_src/chrome/renderer/pepper/pepper_flash_fullscreen_host.h new file mode 100644 index 0000000..3550ea1 --- /dev/null +++ b/chromium_src/chrome/renderer/pepper/pepper_flash_fullscreen_host.h @@ -0,0 +1,37 @@ +// 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 CHROME_RENDERER_PEPPER_PEPPER_FLASH_FULLSCREEN_HOST_H_ +#define CHROME_RENDERER_PEPPER_PEPPER_FLASH_FULLSCREEN_HOST_H_ + +#include "base/basictypes.h" +#include "base/compiler_specific.h" +#include "ppapi/host/resource_host.h" + +namespace content { +class RendererPpapiHost; +} + +class PepperFlashFullscreenHost : public ppapi::host::ResourceHost { + public: + PepperFlashFullscreenHost(content::RendererPpapiHost* host, + PP_Instance instance, + PP_Resource resource); + ~PepperFlashFullscreenHost() override; + + int32_t OnResourceMessageReceived( + const IPC::Message& msg, + ppapi::host::HostMessageContext* context) override; + + private: + int32_t OnSetFullscreen(ppapi::host::HostMessageContext* context, + bool fullscreen); + + // Non-owning pointer. + content::RendererPpapiHost* renderer_ppapi_host_; + + DISALLOW_COPY_AND_ASSIGN(PepperFlashFullscreenHost); +}; + +#endif // CHROME_RENDERER_PEPPER_PEPPER_FLASH_FULLSCREEN_HOST_H_ diff --git a/chromium_src/chrome/renderer/pepper/pepper_flash_menu_host.cc b/chromium_src/chrome/renderer/pepper/pepper_flash_menu_host.cc new file mode 100644 index 0000000..3b7a438 --- /dev/null +++ b/chromium_src/chrome/renderer/pepper/pepper_flash_menu_host.cc @@ -0,0 +1,202 @@ +// 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/pepper/pepper_flash_menu_host.h" + +#include "base/strings/utf_string_conversions.h" +#include "content/public/common/context_menu_params.h" +#include "content/public/renderer/render_frame.h" +#include "content/public/renderer/renderer_ppapi_host.h" +#include "ipc/ipc_message.h" +#include "ppapi/c/private/ppb_flash_menu.h" +#include "ppapi/host/dispatch_host_message.h" +#include "ppapi/host/ppapi_host.h" +#include "ppapi/proxy/ppapi_messages.h" +#include "ppapi/proxy/serialized_flash_menu.h" +#include "ui/gfx/geometry/point.h" + +namespace { + +// Maximum depth of submenus allowed (e.g., 1 indicates that submenus are +// allowed, but not sub-submenus). +const size_t kMaxMenuDepth = 2; + +// Maximum number of entries in any single menu (including separators). +const size_t kMaxMenuEntries = 50; + +// Maximum total number of entries in the |menu_id_map| (see below). +// (Limit to 500 real entries; reserve the 0 action as an invalid entry.) +const size_t kMaxMenuIdMapEntries = 501; + +// Converts menu data from one form to another. +// - |depth| is the current nested depth (call it starting with 0). +// - |menu_id_map| is such that |menu_id_map[output_item.action] == +// input_item.id| (where |action| is what a |MenuItem| has, |id| is what a +// |PP_Flash_MenuItem| has). +bool ConvertMenuData(const PP_Flash_Menu* in_menu, + size_t depth, + std::vector* out_menu, + std::vector* menu_id_map) { + if (depth > kMaxMenuDepth || !in_menu) + return false; + + // Clear the output, just in case. + out_menu->clear(); + + if (!in_menu->count) + return true; // Nothing else to do. + + if (!in_menu->items || in_menu->count > kMaxMenuEntries) + return false; + for (uint32_t i = 0; i < in_menu->count; i++) { + content::MenuItem item; + + PP_Flash_MenuItem_Type type = in_menu->items[i].type; + switch (type) { + case PP_FLASH_MENUITEM_TYPE_NORMAL: + item.type = content::MenuItem::OPTION; + break; + case PP_FLASH_MENUITEM_TYPE_CHECKBOX: + item.type = content::MenuItem::CHECKABLE_OPTION; + break; + case PP_FLASH_MENUITEM_TYPE_SEPARATOR: + item.type = content::MenuItem::SEPARATOR; + break; + case PP_FLASH_MENUITEM_TYPE_SUBMENU: + item.type = content::MenuItem::SUBMENU; + break; + default: + return false; + } + if (in_menu->items[i].name) + item.label = base::UTF8ToUTF16(in_menu->items[i].name); + if (menu_id_map->size() >= kMaxMenuIdMapEntries) + return false; + item.action = static_cast(menu_id_map->size()); + // This sets |(*menu_id_map)[item.action] = in_menu->items[i].id|. + menu_id_map->push_back(in_menu->items[i].id); + item.enabled = PP_ToBool(in_menu->items[i].enabled); + item.checked = PP_ToBool(in_menu->items[i].checked); + if (type == PP_FLASH_MENUITEM_TYPE_SUBMENU) { + if (!ConvertMenuData( + in_menu->items[i].submenu, depth + 1, &item.submenu, menu_id_map)) + return false; + } + + out_menu->push_back(item); + } + + return true; +} + +} // namespace + +PepperFlashMenuHost::PepperFlashMenuHost( + content::RendererPpapiHost* host, + PP_Instance instance, + PP_Resource resource, + const ppapi::proxy::SerializedFlashMenu& serial_menu) + : ppapi::host::ResourceHost(host->GetPpapiHost(), instance, resource), + renderer_ppapi_host_(host), + showing_context_menu_(false), + context_menu_request_id_(0), + has_saved_context_menu_action_(false), + saved_context_menu_action_(0) { + menu_id_map_.push_back(0); // Reserve |menu_id_map_[0]|. + if (!ConvertMenuData(serial_menu.pp_menu(), 0, &menu_data_, &menu_id_map_)) { + menu_data_.clear(); + menu_id_map_.clear(); + } +} + +PepperFlashMenuHost::~PepperFlashMenuHost() { + if (showing_context_menu_) { + content::RenderFrame* render_frame = + renderer_ppapi_host_->GetRenderFrameForInstance(pp_instance()); + if (render_frame) + render_frame->CancelContextMenu(context_menu_request_id_); + } +} + +int32_t PepperFlashMenuHost::OnResourceMessageReceived( + const IPC::Message& msg, + ppapi::host::HostMessageContext* context) { + PPAPI_BEGIN_MESSAGE_MAP(PepperFlashMenuHost, msg) + PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_FlashMenu_Show, + OnHostMsgShow) + PPAPI_END_MESSAGE_MAP() + return PP_ERROR_FAILED; +} + +int32_t PepperFlashMenuHost::OnHostMsgShow( + ppapi::host::HostMessageContext* context, + const PP_Point& location) { + // Note that all early returns must do a SendMenuReply. The sync result for + // this message isn't used, so to forward the error to the plugin, we need to + // additionally call SendMenuReply explicitly. + if (menu_data_.empty()) { + SendMenuReply(PP_ERROR_FAILED, -1); + return PP_ERROR_FAILED; + } + if (showing_context_menu_) { + SendMenuReply(PP_ERROR_INPROGRESS, -1); + return PP_ERROR_INPROGRESS; + } + + content::RenderFrame* render_frame = + renderer_ppapi_host_->GetRenderFrameForInstance(pp_instance()); + + content::ContextMenuParams params; + params.x = location.x; + params.y = location.y; + params.custom_context.is_pepper_menu = true; + params.custom_context.render_widget_id = + renderer_ppapi_host_->GetRoutingIDForWidget(pp_instance()); + params.custom_items = menu_data_; + + // Transform the position to be in render frame's coordinates. + gfx::Point render_frame_pt = renderer_ppapi_host_->PluginPointToRenderFrame( + pp_instance(), gfx::Point(location.x, location.y)); + params.x = render_frame_pt.x(); + params.y = render_frame_pt.y(); + + showing_context_menu_ = true; + context_menu_request_id_ = render_frame->ShowContextMenu(this, params); + + // Note: the show message is sync so this OK is for the sync reply which we + // don't actually use (see the comment in the resource file for this). The + // async message containing the context menu action will be sent in the + // future. + return PP_OK; +} + +void PepperFlashMenuHost::OnMenuAction(int request_id, unsigned action) { + // Just save the action. + DCHECK(!has_saved_context_menu_action_); + has_saved_context_menu_action_ = true; + saved_context_menu_action_ = action; +} + +void PepperFlashMenuHost::OnMenuClosed(int request_id) { + if (has_saved_context_menu_action_ && + saved_context_menu_action_ < menu_id_map_.size()) { + SendMenuReply(PP_OK, menu_id_map_[saved_context_menu_action_]); + has_saved_context_menu_action_ = false; + saved_context_menu_action_ = 0; + } else { + SendMenuReply(PP_ERROR_USERCANCEL, -1); + } + + showing_context_menu_ = false; + context_menu_request_id_ = 0; +} + +void PepperFlashMenuHost::SendMenuReply(int32_t result, int action) { + ppapi::host::ReplyMessageContext reply_context( + ppapi::proxy::ResourceMessageReplyParams(pp_resource(), 0), + NULL, + MSG_ROUTING_NONE); + reply_context.params.set_result(result); + host()->SendReply(reply_context, PpapiPluginMsg_FlashMenu_ShowReply(action)); +} diff --git a/chromium_src/chrome/renderer/pepper/pepper_flash_menu_host.h b/chromium_src/chrome/renderer/pepper/pepper_flash_menu_host.h new file mode 100644 index 0000000..3aa730a --- /dev/null +++ b/chromium_src/chrome/renderer/pepper/pepper_flash_menu_host.h @@ -0,0 +1,69 @@ +// 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 CHROME_RENDERER_PEPPER_PEPPER_FLASH_MENU_HOST_H_ +#define CHROME_RENDERER_PEPPER_PEPPER_FLASH_MENU_HOST_H_ + +#include + +#include "base/compiler_specific.h" +#include "content/public/renderer/context_menu_client.h" +#include "ppapi/c/pp_point.h" +#include "ppapi/host/host_message_context.h" +#include "ppapi/host/resource_host.h" + +namespace content { +class RendererPpapiHost; +struct MenuItem; +} + +namespace ppapi { +namespace proxy { +class SerializedFlashMenu; +} +} + +class PepperFlashMenuHost : public ppapi::host::ResourceHost, + public content::ContextMenuClient { + public: + PepperFlashMenuHost(content::RendererPpapiHost* host, + PP_Instance instance, + PP_Resource resource, + const ppapi::proxy::SerializedFlashMenu& serial_menu); + ~PepperFlashMenuHost() override; + + int32_t OnResourceMessageReceived( + const IPC::Message& msg, + ppapi::host::HostMessageContext* context) override; + + private: + int32_t OnHostMsgShow(ppapi::host::HostMessageContext* context, + const PP_Point& location); + + // ContextMenuClient implementation. + void OnMenuAction(int request_id, unsigned action) override; + void OnMenuClosed(int request_id) override; + + void SendMenuReply(int32_t result, int action); + + content::RendererPpapiHost* renderer_ppapi_host_; + + bool showing_context_menu_; + int context_menu_request_id_; + + std::vector menu_data_; + + // We send |MenuItem|s, which have an |unsigned| "action" field instead of + // an |int32_t| ID. (CONTENT also limits the range of valid values for + // actions.) This maps actions to IDs. + std::vector menu_id_map_; + + // Used to send a single context menu "completion" upon menu close. + bool has_saved_context_menu_action_; + unsigned saved_context_menu_action_; + + DISALLOW_COPY_AND_ASSIGN(PepperFlashMenuHost); +}; + +#endif // CHROME_RENDERER_PEPPER_PEPPER_FLASH_MENU_HOST_H_ diff --git a/chromium_src/chrome/renderer/pepper/pepper_flash_renderer_host.cc b/chromium_src/chrome/renderer/pepper/pepper_flash_renderer_host.cc new file mode 100644 index 0000000..fe5e28e --- /dev/null +++ b/chromium_src/chrome/renderer/pepper/pepper_flash_renderer_host.cc @@ -0,0 +1,373 @@ +// 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/pepper/pepper_flash_renderer_host.h" + +#include +#include + +#include "base/lazy_instance.h" +#include "base/metrics/histogram.h" +#include "base/strings/string_util.h" +#include "content/public/renderer/pepper_plugin_instance.h" +#include "content/public/renderer/render_thread.h" +#include "content/public/renderer/renderer_ppapi_host.h" +#include "ipc/ipc_message_macros.h" +#include "net/http/http_util.h" +#include "ppapi/c/pp_errors.h" +#include "ppapi/c/trusted/ppb_browser_font_trusted.h" +#include "ppapi/host/dispatch_host_message.h" +#include "ppapi/proxy/host_dispatcher.h" +#include "ppapi/proxy/ppapi_messages.h" +#include "ppapi/proxy/resource_message_params.h" +#include "ppapi/proxy/serialized_structs.h" +#include "ppapi/thunk/enter.h" +#include "ppapi/thunk/ppb_image_data_api.h" +#include "skia/ext/platform_canvas.h" +#include "third_party/skia/include/core/SkCanvas.h" +#include "third_party/skia/include/core/SkMatrix.h" +#include "third_party/skia/include/core/SkPaint.h" +#include "third_party/skia/include/core/SkPoint.h" +#include "third_party/skia/include/core/SkTemplates.h" +#include "third_party/skia/include/core/SkTypeface.h" +#include "ui/gfx/geometry/rect.h" +#include "url/gurl.h" + +using ppapi::thunk::EnterResourceNoLock; +using ppapi::thunk::PPB_ImageData_API; + +namespace { + +// Some non-simple HTTP request headers that Flash may set. +// (Please see http://www.w3.org/TR/cors/#simple-header for the definition of +// simple headers.) +// +// The list and the enum defined below are used to collect data about request +// headers used in PPB_Flash.Navigate() calls, in order to understand the impact +// of rejecting PPB_Flash.Navigate() requests with non-simple headers. +// +// TODO(yzshen): We should be able to remove the histogram recording code once +// we get the answer. +const char* const kRejectedHttpRequestHeaders[] = { + "authorization", // + "cache-control", // + "content-encoding", // + "content-md5", // + "content-type", // If the media type is not one of those covered by the + // simple header definition. + "expires", // + "from", // + "if-match", // + "if-none-match", // + "if-range", // + "if-unmodified-since", // + "pragma", // + "referer" // +}; + +// Please note that new entries should be added right above +// FLASH_NAVIGATE_USAGE_ENUM_COUNT, and existing entries shouldn't be re-ordered +// or removed, since this ordering is used in a histogram. +enum FlashNavigateUsage { + // This section must be in the same order as kRejectedHttpRequestHeaders. + REJECT_AUTHORIZATION = 0, + REJECT_CACHE_CONTROL, + REJECT_CONTENT_ENCODING, + REJECT_CONTENT_MD5, + REJECT_CONTENT_TYPE, + REJECT_EXPIRES, + REJECT_FROM, + REJECT_IF_MATCH, + REJECT_IF_NONE_MATCH, + REJECT_IF_RANGE, + REJECT_IF_UNMODIFIED_SINCE, + REJECT_PRAGMA, + REJECT_REFERER, + + // The navigate request is rejected because of headers not listed above + // (e.g., custom headers). + REJECT_OTHER_HEADERS, + + // Total number of rejected navigate requests. + TOTAL_REJECTED_NAVIGATE_REQUESTS, + + // Total number of navigate requests. + TOTAL_NAVIGATE_REQUESTS, + FLASH_NAVIGATE_USAGE_ENUM_COUNT +}; + +static base::LazyInstance > + g_rejected_headers = LAZY_INSTANCE_INITIALIZER; + +bool IsSimpleHeader(const std::string& lower_case_header_name, + const std::string& header_value) { + if (lower_case_header_name == "accept" || + lower_case_header_name == "accept-language" || + lower_case_header_name == "content-language") { + return true; + } + + if (lower_case_header_name == "content-type") { + std::string lower_case_mime_type; + std::string lower_case_charset; + bool had_charset = false; + net::HttpUtil::ParseContentType(header_value, + &lower_case_mime_type, + &lower_case_charset, + &had_charset, + NULL); + return lower_case_mime_type == "application/x-www-form-urlencoded" || + lower_case_mime_type == "multipart/form-data" || + lower_case_mime_type == "text/plain"; + } + + return false; +} + +void RecordFlashNavigateUsage(FlashNavigateUsage usage) { + DCHECK_NE(FLASH_NAVIGATE_USAGE_ENUM_COUNT, usage); + UMA_HISTOGRAM_ENUMERATION( + "Plugin.FlashNavigateUsage", usage, FLASH_NAVIGATE_USAGE_ENUM_COUNT); +} + +} // namespace + +PepperFlashRendererHost::PepperFlashRendererHost( + content::RendererPpapiHost* host, + PP_Instance instance, + PP_Resource resource) + : ResourceHost(host->GetPpapiHost(), instance, resource), + host_(host), + weak_factory_(this) {} + +PepperFlashRendererHost::~PepperFlashRendererHost() { + // This object may be destroyed in the middle of a sync message. If that is + // the case, make sure we respond to all the pending navigate calls. + std::vector::reverse_iterator it; + for (it = navigate_replies_.rbegin(); it != navigate_replies_.rend(); ++it) + SendReply(*it, IPC::Message()); +} + +int32_t PepperFlashRendererHost::OnResourceMessageReceived( + const IPC::Message& msg, + ppapi::host::HostMessageContext* context) { + PPAPI_BEGIN_MESSAGE_MAP(PepperFlashRendererHost, msg) + PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_Flash_GetProxyForURL, + OnGetProxyForURL) + PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_Flash_SetInstanceAlwaysOnTop, + OnSetInstanceAlwaysOnTop) + PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_Flash_DrawGlyphs, + OnDrawGlyphs) + PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_Flash_Navigate, OnNavigate) + PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_Flash_IsRectTopmost, + OnIsRectTopmost) + PPAPI_END_MESSAGE_MAP() + return PP_ERROR_FAILED; +} + +int32_t PepperFlashRendererHost::OnGetProxyForURL( + ppapi::host::HostMessageContext* host_context, + const std::string& url) { + GURL gurl(url); + if (!gurl.is_valid()) + return PP_ERROR_FAILED; + std::string proxy; + bool result = content::RenderThread::Get()->ResolveProxy(gurl, &proxy); + if (!result) + return PP_ERROR_FAILED; + host_context->reply_msg = PpapiPluginMsg_Flash_GetProxyForURLReply(proxy); + return PP_OK; +} + +int32_t PepperFlashRendererHost::OnSetInstanceAlwaysOnTop( + ppapi::host::HostMessageContext* host_context, + bool on_top) { + content::PepperPluginInstance* plugin_instance = + host_->GetPluginInstance(pp_instance()); + if (plugin_instance) + plugin_instance->SetAlwaysOnTop(on_top); + // Since no reply is sent for this message, it doesn't make sense to return an + // error. + return PP_OK; +} + +int32_t PepperFlashRendererHost::OnDrawGlyphs( + ppapi::host::HostMessageContext* host_context, + ppapi::proxy::PPBFlash_DrawGlyphs_Params params) { + if (params.glyph_indices.size() != params.glyph_advances.size() || + params.glyph_indices.empty()) + return PP_ERROR_FAILED; + + // Set up the typeface. + int style = SkTypeface::kNormal; + if (static_cast(params.font_desc.weight) >= + PP_BROWSERFONT_TRUSTED_WEIGHT_BOLD) + style |= SkTypeface::kBold; + if (params.font_desc.italic) + style |= SkTypeface::kItalic; + skia::RefPtr typeface = skia::AdoptRef(SkTypeface::CreateFromName( + params.font_desc.face.c_str(), static_cast(style))); + if (!typeface) + return PP_ERROR_FAILED; + + EnterResourceNoLock enter( + params.image_data.host_resource(), true); + if (enter.failed()) + return PP_ERROR_FAILED; + + // Set up the canvas. + PPB_ImageData_API* image = static_cast(enter.object()); + SkCanvas* canvas = image->GetCanvas(); + bool needs_unmapping = false; + if (!canvas) { + needs_unmapping = true; + image->Map(); + canvas = image->GetCanvas(); + if (!canvas) + return PP_ERROR_FAILED; // Failure mapping. + } + + SkAutoCanvasRestore acr(canvas, true); + + // Clip is applied in pixels before the transform. + SkRect clip_rect = { + SkIntToScalar(params.clip.point.x), SkIntToScalar(params.clip.point.y), + SkIntToScalar(params.clip.point.x + params.clip.size.width), + SkIntToScalar(params.clip.point.y + params.clip.size.height)}; + canvas->clipRect(clip_rect); + + // Convert & set the matrix. + SkMatrix matrix; + matrix.set(SkMatrix::kMScaleX, SkFloatToScalar(params.transformation[0][0])); + matrix.set(SkMatrix::kMSkewX, SkFloatToScalar(params.transformation[0][1])); + matrix.set(SkMatrix::kMTransX, SkFloatToScalar(params.transformation[0][2])); + matrix.set(SkMatrix::kMSkewY, SkFloatToScalar(params.transformation[1][0])); + matrix.set(SkMatrix::kMScaleY, SkFloatToScalar(params.transformation[1][1])); + matrix.set(SkMatrix::kMTransY, SkFloatToScalar(params.transformation[1][2])); + matrix.set(SkMatrix::kMPersp0, SkFloatToScalar(params.transformation[2][0])); + matrix.set(SkMatrix::kMPersp1, SkFloatToScalar(params.transformation[2][1])); + matrix.set(SkMatrix::kMPersp2, SkFloatToScalar(params.transformation[2][2])); + canvas->concat(matrix); + + SkPaint paint; + paint.setColor(params.color); + paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding); + paint.setAntiAlias(true); + paint.setHinting(SkPaint::kFull_Hinting); + paint.setTextSize(SkIntToScalar(params.font_desc.size)); + paint.setTypeface(typeface.get()); // Takes a ref and manages lifetime. + if (params.allow_subpixel_aa) { + paint.setSubpixelText(true); + paint.setLCDRenderText(true); + } + + SkScalar x = SkIntToScalar(params.position.x); + SkScalar y = SkIntToScalar(params.position.y); + + // Build up the skia advances. + size_t glyph_count = params.glyph_indices.size(); + if (glyph_count) { + std::vector storage; + storage.resize(glyph_count); + SkPoint* sk_positions = &storage[0]; + for (uint32_t i = 0; i < glyph_count; i++) { + sk_positions[i].set(x, y); + x += SkFloatToScalar(params.glyph_advances[i].x); + y += SkFloatToScalar(params.glyph_advances[i].y); + } + + canvas->drawPosText( + ¶ms.glyph_indices[0], glyph_count * 2, sk_positions, paint); + } + + if (needs_unmapping) + image->Unmap(); + + return PP_OK; +} + +// CAUTION: This code is subtle because Navigate is a sync call which may +// cause re-entrancy or cause the instance to be destroyed. If the instance +// is destroyed we need to ensure that we respond to all outstanding sync +// messages so that the plugin process does not remain blocked. +int32_t PepperFlashRendererHost::OnNavigate( + ppapi::host::HostMessageContext* host_context, + const ppapi::URLRequestInfoData& data, + const std::string& target, + bool from_user_action) { + // If our PepperPluginInstance is already destroyed, just return a failure. + content::PepperPluginInstance* plugin_instance = + host_->GetPluginInstance(pp_instance()); + if (!plugin_instance) + return PP_ERROR_FAILED; + + std::map& rejected_headers = + g_rejected_headers.Get(); + if (rejected_headers.empty()) { + for (size_t i = 0; i < arraysize(kRejectedHttpRequestHeaders); ++i) + rejected_headers[kRejectedHttpRequestHeaders[i]] = + static_cast(i); + } + + net::HttpUtil::HeadersIterator header_iter( + data.headers.begin(), data.headers.end(), "\n\r"); + bool rejected = false; + while (header_iter.GetNext()) { + std::string lower_case_header_name = + base::StringToLowerASCII(header_iter.name()); + if (!IsSimpleHeader(lower_case_header_name, header_iter.values())) { + rejected = true; + + std::map::const_iterator iter = + rejected_headers.find(lower_case_header_name); + FlashNavigateUsage usage = + iter != rejected_headers.end() ? iter->second : REJECT_OTHER_HEADERS; + RecordFlashNavigateUsage(usage); + } + } + + RecordFlashNavigateUsage(TOTAL_NAVIGATE_REQUESTS); + if (rejected) { + RecordFlashNavigateUsage(TOTAL_REJECTED_NAVIGATE_REQUESTS); + return PP_ERROR_NOACCESS; + } + + // Navigate may call into Javascript (e.g. with a "javascript:" URL), + // or do things like navigate away from the page, either one of which will + // need to re-enter into the plugin. It is safe, because it is essentially + // equivalent to NPN_GetURL, where Flash would expect re-entrancy. + ppapi::proxy::HostDispatcher* host_dispatcher = + ppapi::proxy::HostDispatcher::GetForInstance(pp_instance()); + host_dispatcher->set_allow_plugin_reentrancy(); + + // Grab a weak pointer to ourselves on the stack so we can check if we are + // still alive. + base::WeakPtr weak_ptr = weak_factory_.GetWeakPtr(); + // Keep track of reply contexts in case we are destroyed during a Navigate + // call. Even if we are destroyed, we still need to send these replies to + // unblock the plugin process. + navigate_replies_.push_back(host_context->MakeReplyMessageContext()); + plugin_instance->Navigate(data, target.c_str(), from_user_action); + // This object might have been destroyed by this point. If it is destroyed + // the reply will be sent in the destructor. Otherwise send the reply here. + if (weak_ptr.get()) { + SendReply(navigate_replies_.back(), IPC::Message()); + navigate_replies_.pop_back(); + } + + // Return PP_OK_COMPLETIONPENDING so that no reply is automatically sent. + return PP_OK_COMPLETIONPENDING; +} + +int32_t PepperFlashRendererHost::OnIsRectTopmost( + ppapi::host::HostMessageContext* host_context, + const PP_Rect& rect) { + content::PepperPluginInstance* plugin_instance = + host_->GetPluginInstance(pp_instance()); + if (plugin_instance && + plugin_instance->IsRectTopmost(gfx::Rect( + rect.point.x, rect.point.y, rect.size.width, rect.size.height))) + return PP_OK; + return PP_ERROR_FAILED; +} diff --git a/chromium_src/chrome/renderer/pepper/pepper_flash_renderer_host.h b/chromium_src/chrome/renderer/pepper/pepper_flash_renderer_host.h new file mode 100644 index 0000000..de22f46 --- /dev/null +++ b/chromium_src/chrome/renderer/pepper/pepper_flash_renderer_host.h @@ -0,0 +1,69 @@ +// 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 CHROME_RENDERER_PEPPER_PEPPER_FLASH_RENDERER_HOST_H_ +#define CHROME_RENDERER_PEPPER_PEPPER_FLASH_RENDERER_HOST_H_ + +#include +#include + +#include "base/basictypes.h" +#include "base/memory/weak_ptr.h" +#include "ppapi/host/host_message_context.h" +#include "ppapi/host/resource_host.h" + +struct PP_Rect; + +namespace ppapi { +struct URLRequestInfoData; +} + +namespace ppapi { +namespace proxy { +struct PPBFlash_DrawGlyphs_Params; +} +} + +namespace content { +class RendererPpapiHost; +} + +class PepperFlashRendererHost : public ppapi::host::ResourceHost { + public: + PepperFlashRendererHost(content::RendererPpapiHost* host, + PP_Instance instance, + PP_Resource resource); + ~PepperFlashRendererHost() override; + + // ppapi::host::ResourceHost override. + int32_t OnResourceMessageReceived( + const IPC::Message& msg, + ppapi::host::HostMessageContext* context) override; + + private: + int32_t OnGetProxyForURL(ppapi::host::HostMessageContext* host_context, + const std::string& url); + int32_t OnSetInstanceAlwaysOnTop( + ppapi::host::HostMessageContext* host_context, + bool on_top); + int32_t OnDrawGlyphs(ppapi::host::HostMessageContext* host_context, + ppapi::proxy::PPBFlash_DrawGlyphs_Params params); + int32_t OnNavigate(ppapi::host::HostMessageContext* host_context, + const ppapi::URLRequestInfoData& data, + const std::string& target, + bool from_user_action); + int32_t OnIsRectTopmost(ppapi::host::HostMessageContext* host_context, + const PP_Rect& rect); + + // A stack of ReplyMessageContexts to track Navigate() calls which have not + // yet been replied to. + std::vector navigate_replies_; + + content::RendererPpapiHost* host_; + base::WeakPtrFactory weak_factory_; + + DISALLOW_COPY_AND_ASSIGN(PepperFlashRendererHost); +}; + +#endif // CHROME_RENDERER_PEPPER_PEPPER_FLASH_RENDERER_HOST_H_ diff --git a/chromium_src/chrome/renderer/pepper/pepper_helper.cc b/chromium_src/chrome/renderer/pepper/pepper_helper.cc new file mode 100644 index 0000000..a610a30 --- /dev/null +++ b/chromium_src/chrome/renderer/pepper/pepper_helper.cc @@ -0,0 +1,26 @@ +// 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/pepper/pepper_helper.h" + +#include "chrome/renderer/pepper/chrome_renderer_pepper_host_factory.h" +#include "chrome/renderer/pepper/pepper_shared_memory_message_filter.h" +#include "content/public/renderer/renderer_ppapi_host.h" +#include "ppapi/host/ppapi_host.h" + +PepperHelper::PepperHelper(content::RenderFrame* render_frame) + : RenderFrameObserver(render_frame) {} + +PepperHelper::~PepperHelper() {} + +void PepperHelper::DidCreatePepperPlugin(content::RendererPpapiHost* host) { + // TODO(brettw) figure out how to hook up the host factory. It needs some + // kind of filter-like system to allow dynamic additions. + host->GetPpapiHost()->AddHostFactoryFilter( + scoped_ptr( + new ChromeRendererPepperHostFactory(host))); + host->GetPpapiHost()->AddInstanceMessageFilter( + scoped_ptr( + new PepperSharedMemoryMessageFilter(host))); +} diff --git a/chromium_src/chrome/renderer/pepper/pepper_helper.h b/chromium_src/chrome/renderer/pepper/pepper_helper.h new file mode 100644 index 0000000..b3e850b --- /dev/null +++ b/chromium_src/chrome/renderer/pepper/pepper_helper.h @@ -0,0 +1,25 @@ +// 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 CHROME_RENDERER_PEPPER_PEPPER_HELPER_H_ +#define CHROME_RENDERER_PEPPER_PEPPER_HELPER_H_ + +#include "base/compiler_specific.h" +#include "content/public/renderer/render_frame_observer.h" + +// This class listens for Pepper creation events from the RenderFrame and +// attaches the parts required for Chrome-specific plugin support. +class PepperHelper : public content::RenderFrameObserver { + public: + explicit PepperHelper(content::RenderFrame* render_frame); + ~PepperHelper() override; + + // RenderFrameObserver. + void DidCreatePepperPlugin(content::RendererPpapiHost* host) override; + + private: + DISALLOW_COPY_AND_ASSIGN(PepperHelper); +}; + +#endif // CHROME_RENDERER_PEPPER_PEPPER_HELPER_H_ diff --git a/chromium_src/chrome/renderer/pepper/pepper_shared_memory_message_filter.cc b/chromium_src/chrome/renderer/pepper/pepper_shared_memory_message_filter.cc new file mode 100644 index 0000000..e01aea7 --- /dev/null +++ b/chromium_src/chrome/renderer/pepper/pepper_shared_memory_message_filter.cc @@ -0,0 +1,72 @@ +// Copyright (c) 2013 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/pepper/pepper_shared_memory_message_filter.h" + +#include "base/memory/scoped_ptr.h" +#include "base/memory/shared_memory.h" +#include "base/process/process_handle.h" +#include "content/public/common/content_client.h" +#include "content/public/renderer/pepper_plugin_instance.h" +#include "content/public/renderer/render_thread.h" +#include "content/public/renderer/renderer_ppapi_host.h" +#include "ppapi/host/ppapi_host.h" +#include "ppapi/proxy/ppapi_messages.h" +#include "ppapi/shared_impl/var_tracker.h" + +PepperSharedMemoryMessageFilter::PepperSharedMemoryMessageFilter( + content::RendererPpapiHost* host) + : InstanceMessageFilter(host->GetPpapiHost()), host_(host) {} + +PepperSharedMemoryMessageFilter::~PepperSharedMemoryMessageFilter() {} + +bool PepperSharedMemoryMessageFilter::OnInstanceMessageReceived( + const IPC::Message& msg) { + bool handled = true; + IPC_BEGIN_MESSAGE_MAP(PepperSharedMemoryMessageFilter, msg) + IPC_MESSAGE_HANDLER(PpapiHostMsg_SharedMemory_CreateSharedMemory, + OnHostMsgCreateSharedMemory) + IPC_MESSAGE_UNHANDLED(handled = false) + IPC_END_MESSAGE_MAP() + return handled; +} + +bool PepperSharedMemoryMessageFilter::Send(IPC::Message* msg) { + return host_->GetPpapiHost()->Send(msg); +} + +void PepperSharedMemoryMessageFilter::OnHostMsgCreateSharedMemory( + PP_Instance instance, + uint32_t size, + int* host_handle_id, + ppapi::proxy::SerializedHandle* plugin_handle) { + plugin_handle->set_null_shmem(); + *host_handle_id = -1; + scoped_ptr shm(content::RenderThread::Get() + ->HostAllocateSharedMemoryBuffer(size) + .Pass()); + if (!shm.get()) + return; + + base::SharedMemoryHandle host_shm_handle; + shm->ShareToProcess(base::GetCurrentProcessHandle(), &host_shm_handle); + *host_handle_id = + content::PepperPluginInstance::Get(instance) + ->GetVarTracker() + ->TrackSharedMemoryHandle(instance, host_shm_handle, size); + + base::PlatformFile host_handle = +#if defined(OS_WIN) + host_shm_handle; +#elif defined(OS_POSIX) + host_shm_handle.fd; +#else +#error Not implemented. +#endif + // We set auto_close to false since we need our file descriptor to + // actually be duplicated on linux. The shared memory destructor will + // close the original handle for us. + plugin_handle->set_shmem(host_->ShareHandleWithRemote(host_handle, false), + size); +} diff --git a/chromium_src/chrome/renderer/pepper/pepper_shared_memory_message_filter.h b/chromium_src/chrome/renderer/pepper/pepper_shared_memory_message_filter.h new file mode 100644 index 0000000..d7e0934 --- /dev/null +++ b/chromium_src/chrome/renderer/pepper/pepper_shared_memory_message_filter.h @@ -0,0 +1,48 @@ +// Copyright (c) 2013 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 CHROME_RENDERER_PEPPER_PEPPER_SHARED_MEMORY_MESSAGE_FILTER_H_ +#define CHROME_RENDERER_PEPPER_PEPPER_SHARED_MEMORY_MESSAGE_FILTER_H_ + +#include "base/basictypes.h" +#include "base/compiler_specific.h" +#include "ppapi/c/pp_instance.h" +#include "ppapi/host/instance_message_filter.h" + +namespace content { +class RendererPpapiHost; +} + +namespace ppapi { +namespace proxy { +class SerializedHandle; +} +} + +// Implements the backend for shared memory messages from a plugin process. +class PepperSharedMemoryMessageFilter + : public ppapi::host::InstanceMessageFilter { + public: + explicit PepperSharedMemoryMessageFilter(content::RendererPpapiHost* host); + ~PepperSharedMemoryMessageFilter() override; + + // InstanceMessageFilter: + bool OnInstanceMessageReceived(const IPC::Message& msg) override; + + bool Send(IPC::Message* msg); + + private: + // Message handlers. + void OnHostMsgCreateSharedMemory( + PP_Instance instance, + uint32_t size, + int* host_shm_handle_id, + ppapi::proxy::SerializedHandle* plugin_shm_handle); + + content::RendererPpapiHost* host_; + + DISALLOW_COPY_AND_ASSIGN(PepperSharedMemoryMessageFilter); +}; + +#endif // CHROME_RENDERER_PEPPER_PEPPER_SHARED_MEMORY_MESSAGE_FILTER_H_ diff --git a/filenames.gypi b/filenames.gypi index bb1e7e5..c275af7 100644 --- a/filenames.gypi +++ b/filenames.gypi @@ -311,6 +311,16 @@ 'chromium_src/chrome/browser/printing/printer_query.h', 'chromium_src/chrome/browser/printing/printing_message_filter.cc', 'chromium_src/chrome/browser/printing/printing_message_filter.h', + 'chromium_src/chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.cc', + 'chromium_src/chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h', + 'chromium_src/chrome/browser/renderer_host/pepper/pepper_broker_message_filter.cc', + 'chromium_src/chrome/browser/renderer_host/pepper/pepper_broker_message_filter.h', + 'chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_browser_host.cc', + 'chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_browser_host.h', + 'chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_clipboard_message_filter.cc', + 'chromium_src/chrome/browser/renderer_host/pepper/pepper_flash_clipboard_message_filter.h', + 'chromium_src/chrome/browser/renderer_host/pepper/pepper_isolated_file_system_message_filter.cc', + 'chromium_src/chrome/browser/renderer_host/pepper/pepper_isolated_file_system_message_filter.h', 'chromium_src/chrome/browser/speech/tts_controller.h', 'chromium_src/chrome/browser/speech/tts_controller_impl.cc', 'chromium_src/chrome/browser/speech/tts_controller_impl.h', @@ -333,6 +343,22 @@ 'chromium_src/chrome/common/tts_messages.h', 'chromium_src/chrome/common/tts_utterance_request.cc', 'chromium_src/chrome/common/tts_utterance_request.h', + 'chromium_src/chrome/renderer/pepper/chrome_renderer_pepper_host_factory.cc', + 'chromium_src/chrome/renderer/pepper/chrome_renderer_pepper_host_factory.h', + 'chromium_src/chrome/renderer/pepper/pepper_flash_drm_renderer_host.cc', + 'chromium_src/chrome/renderer/pepper/pepper_flash_drm_renderer_host.h', + 'chromium_src/chrome/renderer/pepper/pepper_flash_font_file_host.cc', + 'chromium_src/chrome/renderer/pepper/pepper_flash_font_file_host.h', + 'chromium_src/chrome/renderer/pepper/pepper_flash_fullscreen_host.cc', + 'chromium_src/chrome/renderer/pepper/pepper_flash_fullscreen_host.h', + 'chromium_src/chrome/renderer/pepper/pepper_flash_menu_host.cc', + 'chromium_src/chrome/renderer/pepper/pepper_flash_menu_host.h', + 'chromium_src/chrome/renderer/pepper/pepper_flash_renderer_host.cc', + 'chromium_src/chrome/renderer/pepper/pepper_flash_renderer_host.h', + 'chromium_src/chrome/renderer/pepper/pepper_helper.cc', + 'chromium_src/chrome/renderer/pepper/pepper_helper.h', + 'chromium_src/chrome/renderer/pepper/pepper_shared_memory_message_filter.cc', + 'chromium_src/chrome/renderer/pepper/pepper_shared_memory_message_filter.h', 'chromium_src/chrome/renderer/printing/print_web_view_helper.cc', 'chromium_src/chrome/renderer/printing/print_web_view_helper_linux.cc', 'chromium_src/chrome/renderer/printing/print_web_view_helper_mac.mm', -- 2.7.4