diff options
42 files changed, 775 insertions, 227 deletions
diff --git a/chrome/browser/DEPS b/chrome/browser/DEPS index 903a8f1..b57c3f5 100644 --- a/chrome/browser/DEPS +++ b/chrome/browser/DEPS @@ -13,6 +13,7 @@ include_rules = [ "+media/base", # For media switches "+policy", # For generated headers and source "+ppapi/c", # For various types. + "+ppapi/host", "+ppapi/proxy", "+ppapi/shared_impl/api_id.h", # Defines some types that are marshalled over IPC. diff --git a/chrome/browser/chrome_content_browser_client.cc b/chrome/browser/chrome_content_browser_client.cc index 0540dadf..15cc0af 100644 --- a/chrome/browser/chrome_content_browser_client.cc +++ b/chrome/browser/chrome_content_browser_client.cc @@ -56,6 +56,7 @@ #include "chrome/browser/profiles/profile_manager.h" #include "chrome/browser/renderer_host/chrome_render_message_filter.h" #include "chrome/browser/renderer_host/chrome_render_view_host_observer.h" +#include "chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h" #include "chrome/browser/renderer_host/plugin_info_message_filter.h" #include "chrome/browser/search_engines/search_provider_install_state_message_filter.h" #include "chrome/browser/speech/chrome_speech_recognition_manager_delegate.h" @@ -83,6 +84,7 @@ #include "chrome/common/url_constants.h" #include "content/public/browser/browser_child_process_host.h" #include "content/public/browser/browser_main_parts.h" +#include "content/public/browser/browser_ppapi_host.h" #include "content/public/browser/browser_url_handler.h" #include "content/public/browser/child_process_security_policy.h" #include "content/public/browser/render_process_host.h" @@ -99,6 +101,7 @@ #include "net/base/ssl_cert_request_info.h" #include "net/cookies/canonical_cookie.h" #include "net/cookies/cookie_options.h" +#include "ppapi/host/ppapi_host.h" #include "ui/base/l10n/l10n_util.h" #include "ui/base/resource/resource_bundle.h" #include "webkit/glue/webpreferences.h" @@ -1601,6 +1604,13 @@ std::string ChromeContentBrowserClient::GetDefaultDownloadName() { return l10n_util::GetStringUTF8(IDS_DEFAULT_DOWNLOAD_FILENAME); } +void ChromeContentBrowserClient::DidCreatePpapiPlugin( + content::BrowserPpapiHost* browser_host) { + browser_host->GetPpapiHost()->AddHostFactoryFilter( + scoped_ptr<ppapi::host::HostFactory>( + new ChromeBrowserPepperHostFactory(browser_host))); +} + bool ChromeContentBrowserClient::AllowPepperSocketAPI( content::BrowserContext* browser_context, const GURL& url) { if (!url.is_valid()) diff --git a/chrome/browser/chrome_content_browser_client.h b/chrome/browser/chrome_content_browser_client.h index aa20b04..6f0fad4 100644 --- a/chrome/browser/chrome_content_browser_client.h +++ b/chrome/browser/chrome_content_browser_client.h @@ -198,6 +198,8 @@ class ChromeContentBrowserClient : public content::ContentBrowserClient { virtual void ClearCookies(content::RenderViewHost* rvh) OVERRIDE; virtual FilePath GetDefaultDownloadDirectory() OVERRIDE; virtual std::string GetDefaultDownloadName() OVERRIDE; + virtual void DidCreatePpapiPlugin( + content::BrowserPpapiHost* browser_host) OVERRIDE; virtual bool AllowPepperSocketAPI(content::BrowserContext* browser_context, const GURL& url) OVERRIDE; virtual bool AllowPepperPrivateFileAPI() OVERRIDE; diff --git a/chrome/browser/renderer_host/pepper/DEPS b/chrome/browser/renderer_host/pepper/DEPS new file mode 100644 index 0000000..4b73f76 --- /dev/null +++ b/chrome/browser/renderer_host/pepper/DEPS @@ -0,0 +1,5 @@ +include_rules = [ + # ppapi/host and ppapi/proxy are already added at a higher level DEPS file. + "+ppapi/shared_impl", +] + diff --git a/chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.cc b/chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.cc new file mode 100644 index 0000000..5aead89 --- /dev/null +++ b/chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.cc @@ -0,0 +1,49 @@ +// 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 "chrome/browser/renderer_host/pepper/pepper_flash_device_id_host.h" +#include "content/public/browser/browser_ppapi_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::ResourceHost; + +namespace chrome { + +ChromeBrowserPepperHostFactory::ChromeBrowserPepperHostFactory( + content::BrowserPpapiHost* host) + : host_(host) { +} + +ChromeBrowserPepperHostFactory::~ChromeBrowserPepperHostFactory() { +} + +scoped_ptr<ResourceHost> ChromeBrowserPepperHostFactory::CreateResourceHost( + ppapi::host::PpapiHost* host, + const ppapi::proxy::ResourceMessageCallParams& params, + 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<ResourceHost>(); + + // Private interfaces. + if (host_->GetPpapiHost()->permissions().HasPermission( + ppapi::PERMISSION_PRIVATE)) { + switch (message.type()) { + case PpapiHostMsg_FlashDeviceID_Create::ID: + return scoped_ptr<ResourceHost>(new PepperFlashDeviceIDHost( + host_, instance, params.pp_resource())); + } + } + return scoped_ptr<ResourceHost>(); +} + +} // namespace chrome diff --git a/chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h b/chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h new file mode 100644 index 0000000..e051c1d --- /dev/null +++ b/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); + virtual ~ChromeBrowserPepperHostFactory(); + + virtual scoped_ptr<ppapi::host::ResourceHost> CreateResourceHost( + ppapi::host::PpapiHost* host, + const ppapi::proxy::ResourceMessageCallParams& params, + 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/chrome/browser/renderer_host/pepper/pepper_flash_device_id_host.cc b/chrome/browser/renderer_host/pepper/pepper_flash_device_id_host.cc new file mode 100644 index 0000000..b355322 --- /dev/null +++ b/chrome/browser/renderer_host/pepper/pepper_flash_device_id_host.cc @@ -0,0 +1,150 @@ +// 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_device_id_host.h" + +#include "base/bind.h" +#include "base/compiler_specific.h" +#include "base/file_util.h" +#include "base/logging.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 "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" + +using content::BrowserPpapiHost; +using content::BrowserThread; + +namespace chrome { + +namespace { + +// The path to the file containing the DRM ID. +// It is mirrored from +// chrome/browser/chromeos/system/drm_settings.cc +const char kDRMIdentifierFile[] = "Pepper DRM ID.0"; + +} // namespace + +// PepperFlashDeviceIDHost::Fetcher -------------------------------------------- + +PepperFlashDeviceIDHost::Fetcher::Fetcher( + const base::WeakPtr<PepperFlashDeviceIDHost>& host) + : host_(host) { + DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); +} + +PepperFlashDeviceIDHost::Fetcher::~Fetcher() { + DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); +} + +void PepperFlashDeviceIDHost::Fetcher::Start(BrowserPpapiHost* browser_host) { + DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); + + int process_id = 0; + int view_id = 0; + browser_host->GetRenderViewIDsForInstance(host_->pp_instance(), + &process_id, + &view_id); + BrowserThread::PostTask( + BrowserThread::UI, FROM_HERE, + base::Bind(&PepperFlashDeviceIDHost::Fetcher::GetFilePathOnUIThread, + this, process_id, view_id)); +} + +void PepperFlashDeviceIDHost::Fetcher::GetFilePathOnUIThread( + int render_process_id, + int render_view_id) { + DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); + + FilePath path; + content::RenderViewHost* render_view_host = + content::RenderViewHost::FromID(render_process_id, render_view_id); + if (render_view_host) { + content::BrowserContext* browser_context = + render_view_host->GetProcess()->GetBrowserContext(); + // Don't use DRM IDs when incognito to prevent tracking. + if (!browser_context->IsOffTheRecord()) + path = browser_context->GetPath().AppendASCII(kDRMIdentifierFile); + } + + // Continue on the file thread (on failure/incognito, this will just send + // the empty path which will forward the error). + BrowserThread::PostTask( + BrowserThread::FILE, FROM_HERE, + base::Bind(&PepperFlashDeviceIDHost::Fetcher::ReadDRMFileOnFileThread, + this, path)); +} + +void PepperFlashDeviceIDHost::Fetcher::ReadDRMFileOnFileThread( + const FilePath& path) { + DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); + + std::string contents; + if (!path.empty()) + file_util::ReadFileToString(path, &contents); + + // Give back to the resource host on the IO thread. On failure this will just + // forward the empty string. + BrowserThread::PostTask( + BrowserThread::IO, FROM_HERE, + base::Bind(&PepperFlashDeviceIDHost::Fetcher::ReplyOnIOThread, + this, contents)); +} + +void PepperFlashDeviceIDHost::Fetcher::ReplyOnIOThread( + const std::string& contents) { + DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); + if (host_.get()) // Plugin or resource could have been deleted. + host_->GotDRMContents(contents); +} + +// PepperFlashDeviceIDHost ----------------------------------------------------- + +PepperFlashDeviceIDHost::PepperFlashDeviceIDHost(BrowserPpapiHost* host, + PP_Instance instance, + PP_Resource resource) + : ppapi::host::ResourceHost(host->GetPpapiHost(), instance, resource), + factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)), + browser_ppapi_host_(host) { +} + +PepperFlashDeviceIDHost::~PepperFlashDeviceIDHost() { +} + +int32_t PepperFlashDeviceIDHost::OnResourceMessageReceived( + const IPC::Message& msg, + ppapi::host::HostMessageContext* context) { + IPC_BEGIN_MESSAGE_MAP(PepperFlashDeviceIDHost, msg) + PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_FlashDeviceID_GetDeviceID, + OnHostMsgGetDeviceID) + IPC_END_MESSAGE_MAP() + return PP_ERROR_FAILED; +} + +int32_t PepperFlashDeviceIDHost::OnHostMsgGetDeviceID( + const ppapi::host::HostMessageContext* context) { + if (fetcher_) + return PP_ERROR_INPROGRESS; + + fetcher_ = new Fetcher(factory_.GetWeakPtr()); + fetcher_->Start(browser_ppapi_host_); + reply_params_ = context->MakeReplyParams(); + return PP_OK_COMPLETIONPENDING; +} + +void PepperFlashDeviceIDHost::GotDRMContents(const std::string& contents) { + fetcher_ = NULL; + reply_params_.set_result(contents.empty() ? PP_ERROR_FAILED : PP_OK); + host()->SendReply(reply_params_, + PpapiPluginMsg_FlashDeviceID_GetDeviceIDReply(contents)); +} + +} // namespace chrome diff --git a/chrome/browser/renderer_host/pepper/pepper_flash_device_id_host.h b/chrome/browser/renderer_host/pepper/pepper_flash_device_id_host.h new file mode 100644 index 0000000..0be1580 --- /dev/null +++ b/chrome/browser/renderer_host/pepper/pepper_flash_device_id_host.h @@ -0,0 +1,101 @@ +// 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_DEVICE_ID_HOST_H_ +#define CHROME_BROWSER_RENDERER_HOST_PEPPER_PEPPER_FLASH_DEVICE_ID_HOST_H_ + +#include "base/memory/weak_ptr.h" +#include "content/public/browser/browser_thread.h" +#include "ppapi/host/resource_host.h" +#include "ppapi/proxy/resource_message_params.h" + +class FilePath; + +namespace content { +class BrowserPpapiHost; +} + +namespace chrome { + +class PepperFlashDeviceIDHost : public ppapi::host::ResourceHost { + public: + PepperFlashDeviceIDHost(content::BrowserPpapiHost* host, + PP_Instance instance, + PP_Resource resource); + virtual ~PepperFlashDeviceIDHost(); + + // ResourceHost override. + virtual int32_t OnResourceMessageReceived( + const IPC::Message& msg, + ppapi::host::HostMessageContext* context) OVERRIDE; + + private: + // Helper class to manage the unfortunate number of thread transitions + // required for this operation. We must first get the profile info from the + // UI thread, and then actually read the file from the FILE thread before + // returning to the IO thread to forward the result to the plugin. + class Fetcher + : public base::RefCountedThreadSafe< + Fetcher, + content::BrowserThread::DeleteOnIOThread> { + public: + explicit Fetcher(const base::WeakPtr<PepperFlashDeviceIDHost>& host); + + // Schedules the request operation. The host will be called back with + // GotDRMContents. On failure, the contents will be empty. + void Start(content::BrowserPpapiHost* browser_host); + + private: + friend struct content::BrowserThread::DeleteOnThread< + content::BrowserThread::IO>; + friend class base::DeleteHelper<Fetcher>; + + ~Fetcher(); + + // Called on the UI thread to get the file path corresponding to the + // given render view. It will schedule the resulting file to be read on the + // file thread. On error, it will pass the empty path to the file thread. + void GetFilePathOnUIThread(int render_process_id, + int render_view_id); + + // Called on the file thread to read the contents of the file and to + // forward it to the IO thread. The path will be empty on error (in + // which case it will forward the empty string to the IO thread). + void ReadDRMFileOnFileThread(const FilePath& path); + + // Called on the IO thread to call back into the device ID host with the + // file contents, or the empty string on failure. + void ReplyOnIOThread(const std::string& contents); + + // Access only on IO thread (this class is destroyed on the IO thread + // to ensure that this is deleted properly, since weak ptrs aren't + // threadsafe). + base::WeakPtr<PepperFlashDeviceIDHost> host_; + + DISALLOW_COPY_AND_ASSIGN(Fetcher); + }; + friend class Fetcher; + + // IPC message handler. + int32_t OnHostMsgGetDeviceID(const ppapi::host::HostMessageContext* context); + + // Called by the fetcher when the DRM ID was retrieved, or the empty string + // on error. + void GotDRMContents(const std::string& contents); + + base::WeakPtrFactory<PepperFlashDeviceIDHost> factory_; + + content::BrowserPpapiHost* browser_ppapi_host_; + + // When a request is pending, the fetcher will be non-null, and the reply + // params will have the appropriate routing info set for the reply. + scoped_refptr<Fetcher> fetcher_; + ppapi::proxy::ResourceMessageReplyParams reply_params_; + + DISALLOW_COPY_AND_ASSIGN(PepperFlashDeviceIDHost); +}; + +} // namespace chrome + +#endif // CHROME_BROWSER_RENDERER_HOST_PEPPER_PEPPER_FLASH_DEVICE_ID_HOST_H_ diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi index 0debbe4..69213c6 100644 --- a/chrome/chrome_browser.gypi +++ b/chrome/chrome_browser.gypi @@ -1577,6 +1577,10 @@ 'browser/renderer_host/intercept_navigation_resource_throttle.h', 'browser/renderer_host/offline_resource_throttle.cc', 'browser/renderer_host/offline_resource_throttle.h', + 'browser/renderer_host/pepper/chrome_browser_pepper_host_factory.cc', + 'browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h', + 'browser/renderer_host/pepper/pepper_flash_device_id_host.cc', + 'browser/renderer_host/pepper/pepper_flash_device_id_host.h', 'browser/renderer_host/plugin_info_message_filter.cc', 'browser/renderer_host/plugin_info_message_filter.h', 'browser/renderer_host/safe_browsing_resource_throttle.cc', diff --git a/chrome/renderer/pepper/pepper_helper.cc b/chrome/renderer/pepper/pepper_helper.cc index 37b904c..73ac2b6 100644 --- a/chrome/renderer/pepper/pepper_helper.cc +++ b/chrome/renderer/pepper/pepper_helper.cc @@ -21,7 +21,9 @@ 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. - // new ChromeRendererPepperHostFactory(host); + host->GetPpapiHost()->AddHostFactoryFilter( + scoped_ptr<ppapi::host::HostFactory>( + new ChromeRendererPepperHostFactory)); host->GetPpapiHost()->AddInstanceMessageFilter( scoped_ptr<ppapi::host::InstanceMessageFilter>( new PepperFlashRendererMessageFilter(host))); diff --git a/content/browser/ppapi_plugin_process_host.cc b/content/browser/ppapi_plugin_process_host.cc index c80ceee..22d8a06 100644 --- a/content/browser/ppapi_plugin_process_host.cc +++ b/content/browser/ppapi_plugin_process_host.cc @@ -72,6 +72,7 @@ PpapiPluginProcessHost::~PpapiPluginProcessHost() { CancelRequests(); } +// static PpapiPluginProcessHost* PpapiPluginProcessHost::CreatePluginHost( const content::PepperPluginInfo& info, const FilePath& profile_data_directory, @@ -85,6 +86,7 @@ PpapiPluginProcessHost* PpapiPluginProcessHost::CreatePluginHost( return NULL; } +// static PpapiPluginProcessHost* PpapiPluginProcessHost::CreateBrokerHost( const content::PepperPluginInfo& info) { PpapiPluginProcessHost* plugin_host = @@ -96,6 +98,48 @@ PpapiPluginProcessHost* PpapiPluginProcessHost::CreateBrokerHost( return NULL; } +// static +void PpapiPluginProcessHost::DidCreateOutOfProcessInstance( + int plugin_process_id, + int32 pp_instance, + int render_process_id, + int render_view_id) { + for (PpapiPluginProcessHostIterator iter; !iter.Done(); ++iter) { + if (iter->process_.get() && + iter->process_->GetData().id == plugin_process_id) { + // Found the plugin. + iter->host_impl_->AddInstanceForView(pp_instance, + render_process_id, render_view_id); + return; + } + } + // We'll see this passed with a 0 process ID for the browser tag stuff that + // is currently in the process of being removed. + // + // TODO(brettw) When old browser tag impl is removed + // (PepperPluginDelegateImpl::CreateBrowserPluginModule passes a 0 plugin + // process ID) this should be converted to a NOTREACHED(). + DCHECK(plugin_process_id == 0) + << "Renderer sent a bad plugin process host ID"; +} + +// static +void PpapiPluginProcessHost::DidDeleteOutOfProcessInstance( + int plugin_process_id, + int32 pp_instance) { + for (PpapiPluginProcessHostIterator iter; !iter.Done(); ++iter) { + if (iter->process_.get() && + iter->process_->GetData().id == plugin_process_id) { + // Found the plugin. + iter->host_impl_->DeleteInstanceForView(pp_instance); + return; + } + } + // Note: It's possible that the plugin process has already been deleted by + // the time this message is received. For example, it could have crashed. + // That's OK, we can just ignore this message. +} + bool PpapiPluginProcessHost::Send(IPC::Message* message) { return process_->Send(message); } @@ -135,6 +179,8 @@ PpapiPluginProcessHost::PpapiPluginProcessHost( process_->GetHost()->AddFilter(filter_.get()); process_->GetHost()->AddFilter(file_filter_.get()); process_->GetHost()->AddFilter(host_impl_.get()); + + content::GetContentClient()->browser()->DidCreatePpapiPlugin(host_impl_); } PpapiPluginProcessHost::PpapiPluginProcessHost() diff --git a/content/browser/ppapi_plugin_process_host.h b/content/browser/ppapi_plugin_process_host.h index de57b52..3c6576c 100644 --- a/content/browser/ppapi_plugin_process_host.h +++ b/content/browser/ppapi_plugin_process_host.h @@ -80,6 +80,19 @@ class PpapiPluginProcessHost : public content::BrowserChildProcessHostDelegate, static PpapiPluginProcessHost* CreateBrokerHost( const content::PepperPluginInfo& info); + // Notification that a PP_Instance has been created for the given + // RenderView/Process pair for the given plugin. This is necessary so that + // when the plugin calls us with a PP_Instance we can find the RenderView + // associated with it without trusting the plugin. + static void DidCreateOutOfProcessInstance(int plugin_process_id, + int32 pp_instance, + int render_process_id, + int render_view_id); + + // The opposite of DIdCreate... above. + static void DidDeleteOutOfProcessInstance(int plugin_process_id, + int32 pp_instance); + // IPC::Sender implementation: virtual bool Send(IPC::Message* message) OVERRIDE; diff --git a/content/browser/renderer_host/pepper/browser_ppapi_host_impl.cc b/content/browser/renderer_host/pepper/browser_ppapi_host_impl.cc index 92e5b76..dedd51e 100644 --- a/content/browser/renderer_host/pepper/browser_ppapi_host_impl.cc +++ b/content/browser/renderer_host/pepper/browser_ppapi_host_impl.cc @@ -4,6 +4,8 @@ #include "content/browser/renderer_host/pepper/browser_ppapi_host_impl.h" +#include "content/public/browser/browser_thread.h" +#include "content/public/browser/render_view_host.h" #include "ipc/ipc_message_macros.h" namespace content { @@ -11,9 +13,10 @@ namespace content { BrowserPpapiHostImpl::BrowserPpapiHostImpl( IPC::Sender* sender, const ppapi::PpapiPermissions& permissions) - : host_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)), - ppapi_host_(sender, &host_factory_, permissions), + : ppapi_host_(sender, permissions), plugin_process_handle_(base::kNullProcessHandle) { + ppapi_host_.AddHostFactoryFilter(scoped_ptr<ppapi::host::HostFactory>( + new ContentBrowserPepperHostFactory(this))); } BrowserPpapiHostImpl::~BrowserPpapiHostImpl() { @@ -41,4 +44,44 @@ base::ProcessHandle BrowserPpapiHostImpl::GetPluginProcessHandle() const { return plugin_process_handle_; } +bool BrowserPpapiHostImpl::IsValidInstance(PP_Instance instance) const { + return instance_to_view_.find(instance) != instance_to_view_.end(); +} + +bool BrowserPpapiHostImpl::GetRenderViewIDsForInstance( + PP_Instance instance, + int* render_process_id, + int* render_view_id) const { + InstanceToViewMap::const_iterator found = instance_to_view_.find(instance); + if (found == instance_to_view_.end()) { + *render_process_id = 0; + *render_view_id = 0; + return false; + } + + *render_process_id = found->second.process_id; + *render_view_id = found->second.view_id; + return true; +} + +void BrowserPpapiHostImpl::AddInstanceForView(PP_Instance instance, + int render_process_id, + int render_view_id) { + DCHECK(instance_to_view_.find(instance) == instance_to_view_.end()); + + RenderViewIDs ids; + ids.process_id = render_process_id; + ids.view_id = render_view_id; + instance_to_view_[instance] = ids; +} + +void BrowserPpapiHostImpl::DeleteInstanceForView(PP_Instance instance) { + InstanceToViewMap::iterator found = instance_to_view_.find(instance); + if (found == instance_to_view_.end()) { + NOTREACHED(); + return; + } + instance_to_view_.erase(found); +} + } // namespace content diff --git a/content/browser/renderer_host/pepper/browser_ppapi_host_impl.h b/content/browser/renderer_host/pepper/browser_ppapi_host_impl.h index 98edba1..d743d15 100644 --- a/content/browser/renderer_host/pepper/browser_ppapi_host_impl.h +++ b/content/browser/renderer_host/pepper/browser_ppapi_host_impl.h @@ -5,6 +5,8 @@ #ifndef CONTENT_BROWSER_RENDERER_HOST_PEPPER_BROWSER_PPAPI_HOST_IMPL_H_ #define CONTENT_BROWSER_RENDERER_HOST_PEPPER_BROWSER_PPAPI_HOST_IMPL_H_ +#include <map> + #include "base/basictypes.h" #include "base/compiler_specific.h" #include "content/browser/renderer_host/pepper/content_browser_pepper_host_factory.h" @@ -35,20 +37,41 @@ class CONTENT_EXPORT BrowserPpapiHostImpl // BrowserPpapiHost. virtual ppapi::host::PpapiHost* GetPpapiHost() OVERRIDE; virtual base::ProcessHandle GetPluginProcessHandle() const OVERRIDE; + virtual bool IsValidInstance(PP_Instance instance) const OVERRIDE; + virtual bool GetRenderViewIDsForInstance(PP_Instance instance, + int* render_process_id, + int* render_view_id) const OVERRIDE; void set_plugin_process_handle(base::ProcessHandle handle) { plugin_process_handle_ = handle; } + // These two functions are notifications that an instance has been created + // or destroyed. They allow us to maintain a mapping of PP_Instance to view + // IDs in the browser process. + void AddInstanceForView(PP_Instance instance, + int render_process_id, + int render_view_id); + void DeleteInstanceForView(PP_Instance instance); + private: friend class BrowserPpapiHostTest; + struct RenderViewIDs { + int process_id; + int view_id; + }; + typedef std::map<PP_Instance, RenderViewIDs> InstanceToViewMap; + virtual ~BrowserPpapiHostImpl(); - ContentBrowserPepperHostFactory host_factory_; ppapi::host::PpapiHost ppapi_host_; base::ProcessHandle plugin_process_handle_; + // Tracks all PP_Instances in this plugin and maps them to + // RenderProcess/RenderView IDs. + InstanceToViewMap instance_to_view_; + DISALLOW_COPY_AND_ASSIGN(BrowserPpapiHostImpl); }; diff --git a/content/browser/renderer_host/pepper/content_browser_pepper_host_factory.cc b/content/browser/renderer_host/pepper/content_browser_pepper_host_factory.cc index d5e7e98..34ba0d3 100644 --- a/content/browser/renderer_host/pepper/content_browser_pepper_host_factory.cc +++ b/content/browser/renderer_host/pepper/content_browser_pepper_host_factory.cc @@ -29,11 +29,8 @@ scoped_ptr<ResourceHost> ContentBrowserPepperHostFactory::CreateResourceHost( DCHECK(host == host_->GetPpapiHost()); // Make sure the plugin is giving us a valid instance for this resource. - /* TODO(brettw) make this work. The browser should be aware of all valid - instances. if (!host_->IsValidInstance(instance)) return scoped_ptr<ResourceHost>(); - */ // Public interfaces with no permissions required. switch (message.type()) { diff --git a/content/browser/renderer_host/pepper/pepper_message_filter.cc b/content/browser/renderer_host/pepper/pepper_message_filter.cc index 9aa0912..0355a7c 100644 --- a/content/browser/renderer_host/pepper/pepper_message_filter.cc +++ b/content/browser/renderer_host/pepper/pepper_message_filter.cc @@ -65,6 +65,8 @@ const int kDRMIdentifierSize = (256 / 8) * 2; // The path to the file containing the DRM ID. // It is mirrored from // chrome/browser/chromeos/system/drm_settings.cc +// TODO(brettw) remove this when we remove the sync Device ID getter in +// preference for the async one. const char kDRMIdentifierFile[] = "Pepper DRM ID.0"; void CreateNetAddressListFromAddressList( @@ -122,8 +124,7 @@ void PepperMessageFilter::OverrideThreadForMessage( message.type() == PpapiHostMsg_PPBTCPServerSocket_Listen::ID || message.type() == PpapiHostMsg_PPBHostResolver_Resolve::ID) { *thread = BrowserThread::UI; - } else if (message.type() == PepperMsg_GetDeviceID::ID || - message.type() == PpapiHostMsg_PPBFlashDeviceID_Get::ID) { + } else if (message.type() == PepperMsg_GetDeviceID::ID) { *thread = BrowserThread::FILE; } } @@ -181,7 +182,6 @@ bool PepperMessageFilter::OnMessageReceived(const IPC::Message& msg, // Flash messages. IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlash_UpdateActivity, OnUpdateActivity) IPC_MESSAGE_HANDLER(PepperMsg_GetDeviceID, OnGetDeviceID) - IPC_MESSAGE_HANDLER(PpapiHostMsg_PPBFlashDeviceID_Get, OnGetDeviceIDAsync) IPC_MESSAGE_HANDLER(PepperMsg_GetLocalDataRestrictions, OnGetLocalDataRestrictions) @@ -701,6 +701,8 @@ void PepperMessageFilter::OnUpdateActivity() { #endif } +// TODO(brettw) remove this when we remove the sync Device ID getter in +// preference for the async one. void PepperMessageFilter::OnGetDeviceID(std::string* id) { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); id->clear(); @@ -735,17 +737,6 @@ void PepperMessageFilter::OnGetDeviceID(std::string* id) { id->assign(id_buf, kDRMIdentifierSize); } -void PepperMessageFilter::OnGetDeviceIDAsync(int32_t routing_id, - PP_Resource resource) { - std::string result; - OnGetDeviceID(&result); - Send(new PpapiMsg_PPBFlashDeviceID_GetReply(ppapi::API_ID_PPB_FLASH_DEVICE_ID, - routing_id, resource, - result.empty() ? PP_ERROR_FAILED - : PP_OK, - result)); -} - void PepperMessageFilter::OnGetLocalDataRestrictions( const GURL& document_url, const GURL& plugin_url, diff --git a/content/browser/renderer_host/pepper/pepper_message_filter.h b/content/browser/renderer_host/pepper/pepper_message_filter.h index f6a278b..817ec40 100644 --- a/content/browser/renderer_host/pepper/pepper_message_filter.h +++ b/content/browser/renderer_host/pepper/pepper_message_filter.h @@ -222,7 +222,6 @@ class PepperMessageFilter ppapi::PPB_X509Certificate_Fields* result); void OnUpdateActivity(); void OnGetDeviceID(std::string* id); - void OnGetDeviceIDAsync(int32_t routing_id, PP_Resource resource); void OnGetLocalDataRestrictions(const GURL& document_url, const GURL& plugin_url, PP_FlashLSORestrictions* restrictions); diff --git a/content/browser/renderer_host/render_message_filter.cc b/content/browser/renderer_host/render_message_filter.cc index aa971df..46522c0 100644 --- a/content/browser/renderer_host/render_message_filter.cc +++ b/content/browser/renderer_host/render_message_filter.cc @@ -363,6 +363,10 @@ bool RenderMessageFilter::OnMessageReceived(const IPC::Message& message, OnOpenChannelToPlugin) IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_OpenChannelToPepperPlugin, OnOpenChannelToPepperPlugin) + IPC_MESSAGE_HANDLER(ViewHostMsg_DidCreateOutOfProcessPepperInstance, + OnDidCreateOutOfProcessPepperInstance) + IPC_MESSAGE_HANDLER(ViewHostMsg_DidDeleteOutOfProcessPepperInstance, + OnDidDeleteOutOfProcessPepperInstance) IPC_MESSAGE_HANDLER(ViewHostMsg_OpenChannelToPpapiBroker, OnOpenChannelToPpapiBroker) IPC_MESSAGE_HANDLER_GENERIC(ViewHostMsg_UpdateRect, @@ -675,6 +679,27 @@ void RenderMessageFilter::OnOpenChannelToPepperPlugin( this, resource_context_, reply_msg)); } +void RenderMessageFilter::OnDidCreateOutOfProcessPepperInstance( + int plugin_child_id, + int32 pp_instance, + int render_view_id) { + // It's important that we supply the render process ID ourselves based on the + // channel the message arrived on. We use the + // PP_Instance -> (process id, view id) + // mapping to decide how to handle messages received from the (untrusted) + // plugin, so an exploited renderer must not be able to insert fake mappings + // that may allow it access to other render processes. + PpapiPluginProcessHost::DidCreateOutOfProcessInstance( + plugin_child_id, pp_instance, render_process_id_, render_view_id); +} + +void RenderMessageFilter::OnDidDeleteOutOfProcessPepperInstance( + int plugin_child_id, + int32 pp_instance) { + PpapiPluginProcessHost::DidDeleteOutOfProcessInstance( + plugin_child_id, pp_instance); +} + void RenderMessageFilter::OnOpenChannelToPpapiBroker(int routing_id, int request_id, const FilePath& path) { diff --git a/content/browser/renderer_host/render_message_filter.h b/content/browser/renderer_host/render_message_filter.h index 0ab0135..51596a2 100644 --- a/content/browser/renderer_host/render_message_filter.h +++ b/content/browser/renderer_host/render_message_filter.h @@ -167,6 +167,11 @@ class RenderMessageFilter : public BrowserMessageFilter { IPC::Message* reply_msg); void OnOpenChannelToPepperPlugin(const FilePath& path, IPC::Message* reply_msg); + void OnDidCreateOutOfProcessPepperInstance(int plugin_child_id, + int32 pp_instance, + int render_view_id); + void OnDidDeleteOutOfProcessPepperInstance(int plugin_child_id, + int32 pp_instance); void OnOpenChannelToPpapiBroker(int routing_id, int request_id, const FilePath& path); diff --git a/content/common/view_messages.h b/content/common/view_messages.h index f745244..422776d 100644 --- a/content/common/view_messages.h +++ b/content/common/view_messages.h @@ -1908,6 +1908,28 @@ IPC_SYNC_MESSAGE_CONTROL1_2(ViewHostMsg_OpenChannelToPepperPlugin, IPC::ChannelHandle /* handle to channel */, int /* plugin_child_id */) +// Notification that a native (non-NaCl) plugin has created a new plugin +// instance. The parameters indicate the plugin process ID that we're creating +// the instance for, and the routing ID of the render view that the plugin +// instance is associated with. This allows us to create a mapping in the +// browser process for what objects a given PP_Instance is associated with. +// +// This message must be sync even though it returns no parameters to avoid +// a race condition with the plugin process. The plugin process sends messages +// to the browser that assume the browser knows about the instance. We need to +// sure that the browser actually knows about the instance before we tell the +// plugin to run. +IPC_SYNC_MESSAGE_CONTROL3_0(ViewHostMsg_DidCreateOutOfProcessPepperInstance, + int /* plugin_child_id */, + int32 /* pp_instance */, + int /* view_routing_id */) + +// Notification that a native (non-NaCl) plugin has destroyed an instance. This +// is the opposite if the "DidCreate" version above. +IPC_MESSAGE_CONTROL2(ViewHostMsg_DidDeleteOutOfProcessPepperInstance, + int /* plugin_child_id */, + int32 /* pp_instance */) + // A renderer sends this to the browser process when it wants to // create a ppapi broker. The browser will create the broker process // if necessary, and will return a handle to the channel on success. diff --git a/content/public/browser/browser_ppapi_host.h b/content/public/browser/browser_ppapi_host.h index aa97990..3e1db99 100644 --- a/content/public/browser/browser_ppapi_host.h +++ b/content/public/browser/browser_ppapi_host.h @@ -5,8 +5,12 @@ #ifndef CONTENT_PUBLIC_BROWSER_BROWSER_PPAPI_HOST_H_ #define CONTENT_PUBLIC_BROWSER_BROWSER_PPAPI_HOST_H_ +#include "base/callback_forward.h" #include "base/process.h" #include "content/common/content_export.h" +#include "content/public/browser/browser_thread.h" +#include "content/public/browser/render_view_host.h" +#include "ppapi/c/pp_instance.h" namespace ppapi { namespace host { @@ -29,6 +33,22 @@ class CONTENT_EXPORT BrowserPpapiHost { // Returns the handle to the plugin process. virtual base::ProcessHandle GetPluginProcessHandle() const = 0; + // Returns true if the given PP_Instance is valid. + virtual bool IsValidInstance(PP_Instance instance) const = 0; + + // Retrieves the process/view Ids associated with the RenderView containing + // the given instance and returns true on success. If the instance is + // invalid, the ids will be 0 and false will be returned. + // + // When a resource is created, the PP_Instance should already have been + // validated, and the resource hosts will be deleted when the resource is + // destroyed. So it should not generally be necessary to check for errors + // from this function except as a last-minute sanity check if you convert the + // IDs to a RenderView/ProcessHost on the UI thread. + virtual bool GetRenderViewIDsForInstance(PP_Instance instance, + int* render_process_id, + int* render_view_id) const = 0; + protected: virtual ~BrowserPpapiHost() {} }; diff --git a/content/public/browser/content_browser_client.h b/content/public/browser/content_browser_client.h index 33e216c..7766f55 100644 --- a/content/public/browser/content_browser_client.h +++ b/content/public/browser/content_browser_client.h @@ -54,6 +54,7 @@ class AccessTokenStore; class BrowserChildProcessHost; class BrowserContext; class BrowserMainParts; +class BrowserPpapiHost; class BrowserURLHandler; class MediaObserver; class QuotaPermissionContext; @@ -434,6 +435,11 @@ class CONTENT_EXPORT ContentBrowserClient { // else we should do with the file. virtual std::string GetDefaultDownloadName(); + // Notifification that a pepper plugin has just been spawned. This allows the + // embedder to add filters onto the host to implement interfaces. + // This is called on the IO thread. + virtual void DidCreatePpapiPlugin(BrowserPpapiHost* browser_host) {} + // Returns true if renderer processes can use Pepper TCP/UDP sockets from // the given origin. virtual bool AllowPepperSocketAPI(BrowserContext* browser_context, diff --git a/content/renderer/pepper/mock_renderer_ppapi_host.cc b/content/renderer/pepper/mock_renderer_ppapi_host.cc index 042d3a3..9a31ecd 100644 --- a/content/renderer/pepper/mock_renderer_ppapi_host.cc +++ b/content/renderer/pepper/mock_renderer_ppapi_host.cc @@ -10,7 +10,7 @@ namespace content { MockRendererPpapiHost::MockRendererPpapiHost(RenderView* render_view, PP_Instance instance) : sink_(), - ppapi_host_(&sink_, NULL, ppapi::PpapiPermissions()), + ppapi_host_(&sink_, ppapi::PpapiPermissions()), render_view_(render_view), pp_instance_(instance), has_user_gesture_(false) { diff --git a/content/renderer/pepper/pepper_plugin_delegate_impl.cc b/content/renderer/pepper/pepper_plugin_delegate_impl.cc index 79b7d92..4671f8e 100644 --- a/content/renderer/pepper/pepper_plugin_delegate_impl.cc +++ b/content/renderer/pepper/pepper_plugin_delegate_impl.cc @@ -107,8 +107,11 @@ class HostDispatcherWrapper public: HostDispatcherWrapper(RenderViewImpl* rv, webkit::ppapi::PluginModule* module, + int plugin_child_id, const ppapi::PpapiPermissions& perms) - : module_(module), + : render_view_(rv), + module_(module), + plugin_child_id_(plugin_child_id), permissions_(perms) { } virtual ~HostDispatcherWrapper() {} @@ -150,16 +153,32 @@ class HostDispatcherWrapper } virtual void AddInstance(PP_Instance instance) { ppapi::proxy::HostDispatcher::SetForInstance(instance, dispatcher_.get()); + + render_view_->Send(new ViewHostMsg_DidCreateOutOfProcessPepperInstance( + plugin_child_id_, + instance, + render_view_->routing_id())); } virtual void RemoveInstance(PP_Instance instance) { ppapi::proxy::HostDispatcher::RemoveForInstance(instance); + + render_view_->Send(new ViewHostMsg_DidDeleteOutOfProcessPepperInstance( + plugin_child_id_, + instance)); } ppapi::proxy::HostDispatcher* dispatcher() { return dispatcher_.get(); } private: + RenderViewImpl* render_view_; + webkit::ppapi::PluginModule* module_; + // ID that the browser process uses to idetify the child process for the + // plugin. This isn't directly useful from our process (the renderer) except + // in messages to the browser to disambiguate plugins. + int plugin_child_id_; + ppapi::PpapiPermissions permissions_; scoped_ptr<ppapi::proxy::HostDispatcher> dispatcher_; @@ -361,7 +380,8 @@ PepperPluginDelegateImpl::CreatePepperPluginModule( permissions); PepperPluginRegistry::GetInstance()->AddLiveModule(path, module); scoped_ptr<HostDispatcherWrapper> dispatcher( - new HostDispatcherWrapper(render_view_, module, permissions)); + new HostDispatcherWrapper(render_view_, module, plugin_child_id, + permissions)); if (!dispatcher->Init( channel_handle, webkit::ppapi::PluginModule::GetLocalGetInterfaceFunc(), @@ -406,7 +426,7 @@ scoped_refptr<webkit::ppapi::PluginModule> RenderThreadImpl::current()->browser_plugin_registry()->AddModule( guest_process_id, module); scoped_ptr<HostDispatcherWrapper> dispatcher( - new HostDispatcherWrapper(render_view_, module, permissions)); + new HostDispatcherWrapper(render_view_, module, 0, permissions)); if (!dispatcher->Init( channel_handle, webkit::ppapi::PluginModule::GetLocalGetInterfaceFunc(), diff --git a/content/renderer/pepper/renderer_ppapi_host_impl.cc b/content/renderer/pepper/renderer_ppapi_host_impl.cc index feafc2e..8447093 100644 --- a/content/renderer/pepper/renderer_ppapi_host_impl.cc +++ b/content/renderer/pepper/renderer_ppapi_host_impl.cc @@ -23,11 +23,12 @@ RendererPpapiHostImpl::RendererPpapiHostImpl( webkit::ppapi::PluginModule* module, ppapi::proxy::HostDispatcher* dispatcher, const ppapi::PpapiPermissions& permissions) - : module_(module), - host_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) { + : module_(module) { // Hook the PpapiHost up to the dispatcher for out-of-process communication. ppapi_host_.reset( - new ppapi::host::PpapiHost(dispatcher, &host_factory_, permissions)); + new ppapi::host::PpapiHost(dispatcher, permissions)); + ppapi_host_->AddHostFactoryFilter(scoped_ptr<ppapi::host::HostFactory>( + new ContentRendererPepperHostFactory(this))); dispatcher->AddFilter(ppapi_host_.get()); } @@ -35,13 +36,13 @@ RendererPpapiHostImpl::RendererPpapiHostImpl( RendererPpapiHostImpl::RendererPpapiHostImpl( webkit::ppapi::PluginModule* module, const ppapi::PpapiPermissions& permissions) - : module_(module), - host_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) { + : module_(module) { // Hook the host up to the in-process router. in_process_router_.reset(new PepperInProcessRouter(this)); ppapi_host_.reset(new ppapi::host::PpapiHost( - in_process_router_->GetRendererToPluginSender(), - &host_factory_, permissions)); + in_process_router_->GetRendererToPluginSender(), permissions)); + ppapi_host_->AddHostFactoryFilter(scoped_ptr<ppapi::host::HostFactory>( + new ContentRendererPepperHostFactory(this))); } RendererPpapiHostImpl::~RendererPpapiHostImpl() { diff --git a/content/renderer/pepper/renderer_ppapi_host_impl.h b/content/renderer/pepper/renderer_ppapi_host_impl.h index a3537fb..24927b1 100644 --- a/content/renderer/pepper/renderer_ppapi_host_impl.h +++ b/content/renderer/pepper/renderer_ppapi_host_impl.h @@ -102,7 +102,6 @@ class RendererPpapiHostImpl webkit::ppapi::PluginModule* module_; // Non-owning pointer. - ContentRendererPepperHostFactory host_factory_; scoped_ptr<ppapi::host::PpapiHost> ppapi_host_; // Null when running out-of-process. diff --git a/ppapi/host/host_message_context.cc b/ppapi/host/host_message_context.cc index 5c1c0d1..ed785bc 100644 --- a/ppapi/host/host_message_context.cc +++ b/ppapi/host/host_message_context.cc @@ -15,7 +15,8 @@ HostMessageContext::HostMessageContext( HostMessageContext::~HostMessageContext() { } -ppapi::proxy::ResourceMessageReplyParams HostMessageContext::MakeReplyParams() { +ppapi::proxy::ResourceMessageReplyParams +HostMessageContext::MakeReplyParams() const { return ppapi::proxy::ResourceMessageReplyParams(params.pp_resource(), params.sequence()); } diff --git a/ppapi/host/host_message_context.h b/ppapi/host/host_message_context.h index 6708261..d0958ab 100644 --- a/ppapi/host/host_message_context.h +++ b/ppapi/host/host_message_context.h @@ -21,7 +21,7 @@ struct PPAPI_HOST_EXPORT HostMessageContext { // Returns a "reply params" struct with the same resource and sequence number // as this request. - ppapi::proxy::ResourceMessageReplyParams MakeReplyParams(); + ppapi::proxy::ResourceMessageReplyParams MakeReplyParams() const; // The original call parameters passed to the resource message call. const ppapi::proxy::ResourceMessageCallParams& params; diff --git a/ppapi/host/ppapi_host.cc b/ppapi/host/ppapi_host.cc index 247c781..0ec37b6 100644 --- a/ppapi/host/ppapi_host.cc +++ b/ppapi/host/ppapi_host.cc @@ -26,10 +26,8 @@ const size_t kMaxResourcesPerPlugin = 1 << 14; } // namespace PpapiHost::PpapiHost(IPC::Sender* sender, - HostFactory* host_factory, const PpapiPermissions& perms) : sender_(sender), - host_factory_(host_factory), permissions_(perms) { } @@ -73,6 +71,9 @@ void PpapiHost::SendReply(const proxy::ResourceMessageReplyParams& params, Send(new PpapiPluginMsg_ResourceReply(params, msg)); } +void PpapiHost::AddHostFactoryFilter(scoped_ptr<HostFactory> filter) { + host_factory_filters_.push_back(filter.release()); +} void PpapiHost::AddInstanceMessageFilter( scoped_ptr<InstanceMessageFilter> filter) { @@ -121,8 +122,15 @@ void PpapiHost::OnHostMsgResourceCreated( if (resources_.size() >= kMaxResourcesPerPlugin) return; - scoped_ptr<ResourceHost> resource_host( - host_factory_->CreateResourceHost(this, params, instance, nested_msg)); + // Run through all filters until one grabs this message. + scoped_ptr<ResourceHost> resource_host; + DCHECK(!host_factory_filters_.empty()); // Caller forgot to add a factory. + for (size_t i = 0; i < host_factory_filters_.size(); i++) { + resource_host = host_factory_filters_[i]->CreateResourceHost( + this, params, instance, nested_msg).Pass(); + if (resource_host.get()) + break; + } if (!resource_host.get()) { NOTREACHED(); return; diff --git a/ppapi/host/ppapi_host.h b/ppapi/host/ppapi_host.h index 3f3605c5..748d47a 100644 --- a/ppapi/host/ppapi_host.h +++ b/ppapi/host/ppapi_host.h @@ -37,12 +37,11 @@ class ResourceHost; // corresponding replies. class PPAPI_HOST_EXPORT PpapiHost : public IPC::Sender, public IPC::Listener { public: - // The sender is the channel to the plugin for outgoing messages. The factory - // will be used to receive resource creation messages from the plugin. Both - // pointers are owned by the caller and must outlive this class. - PpapiHost(IPC::Sender* sender, - HostFactory* host_factory, - const PpapiPermissions& perms); + // The sender is the channel to the plugin for outgoing messages. + // Normally the creator will add filters for resource creation messages + // (AddHostFactoryFilter) and instance messages (AddInstanceMessageFilter) + // after construction. + PpapiHost(IPC::Sender* sender, const PpapiPermissions& perms); virtual ~PpapiHost(); const PpapiPermissions& permissions() const { return permissions_; } @@ -57,6 +56,10 @@ class PPAPI_HOST_EXPORT PpapiHost : public IPC::Sender, public IPC::Listener { void SendReply(const proxy::ResourceMessageReplyParams& params, const IPC::Message& msg); + // Adds the given host factory filter to the host. The PpapiHost will take + // ownership of the pointer. + void AddHostFactoryFilter(scoped_ptr<HostFactory> filter); + // Adds the given message filter to the host. The PpapiHost will take // ownership of the pointer. void AddInstanceMessageFilter(scoped_ptr<InstanceMessageFilter> filter); @@ -78,11 +81,14 @@ class PPAPI_HOST_EXPORT PpapiHost : public IPC::Sender, public IPC::Listener { // Non-owning pointer. IPC::Sender* sender_; - // Non-owning pointer. - HostFactory* host_factory_; - PpapiPermissions permissions_; + // Filters for resource creation messages. Note that since we don't support + // deleting these dynamically we don't need to worry about modifications + // during iteration. If we add that capability, this should be replaced with + // an ObserverList. + ScopedVector<HostFactory> host_factory_filters_; + // Filters for instance messages. Note that since we don't support deleting // these dynamically we don't need to worry about modifications during // iteration. If we add that capability, this should be replaced with an diff --git a/ppapi/ppapi_proxy.gypi b/ppapi/ppapi_proxy.gypi index e737aa5..a802f87 100644 --- a/ppapi/ppapi_proxy.gypi +++ b/ppapi/ppapi_proxy.gypi @@ -27,6 +27,8 @@ 'proxy/enter_proxy.h', 'proxy/file_chooser_resource.cc', 'proxy/file_chooser_resource.h', + 'proxy/flash_device_id_resource.cc', + 'proxy/flash_device_id_resource.h', 'proxy/gamepad_resource.cc', 'proxy/gamepad_resource.h', 'proxy/host_dispatcher.cc', @@ -72,8 +74,6 @@ 'proxy/ppb_file_ref_proxy.h', 'proxy/ppb_file_system_proxy.cc', 'proxy/ppb_file_system_proxy.h', - 'proxy/ppb_flash_device_id_proxy.cc', - 'proxy/ppb_flash_device_id_proxy.h', 'proxy/ppb_flash_proxy.cc', 'proxy/ppb_flash_proxy.h', 'proxy/ppb_flash_menu_proxy.cc', @@ -165,11 +165,11 @@ ['>(nacl_untrusted_build)==1', { 'sources!': [ 'proxy/broker_dispatcher.cc', + 'proxy/flash_device_id_resource.cc', 'proxy/ppb_audio_input_proxy.cc', 'proxy/ppb_broker_proxy.cc', 'proxy/ppb_buffer_proxy.cc', 'proxy/ppb_file_chooser_proxy.cc', - 'proxy/ppb_flash_device_id_proxy.cc', 'proxy/ppb_flash_proxy.cc', 'proxy/ppb_flash_menu_proxy.cc', 'proxy/ppb_flash_message_loop_proxy.cc', diff --git a/ppapi/proxy/flash_device_id_resource.cc b/ppapi/proxy/flash_device_id_resource.cc new file mode 100644 index 0000000..39ff63b --- /dev/null +++ b/ppapi/proxy/flash_device_id_resource.cc @@ -0,0 +1,67 @@ +// 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 "ppapi/proxy/flash_device_id_resource.h" + +#include "ppapi/c/pp_errors.h" +#include "ppapi/proxy/dispatch_reply_message.h" +#include "ppapi/proxy/ppapi_messages.h" +#include "ppapi/shared_impl/var.h" + +namespace ppapi { +namespace proxy { + +FlashDeviceIDResource::FlashDeviceIDResource(Connection connection, + PP_Instance instance) + : PluginResource(connection, instance), + dest_(NULL) { + SendCreateToBrowser(PpapiHostMsg_FlashDeviceID_Create()); +} + +FlashDeviceIDResource::~FlashDeviceIDResource() { +} + +thunk::PPB_Flash_DeviceID_API* +FlashDeviceIDResource::AsPPB_Flash_DeviceID_API() { + return this; +} + +int32_t FlashDeviceIDResource::GetDeviceID( + PP_Var* id, + scoped_refptr<TrackedCallback> callback) { + if (TrackedCallback::IsPending(callback_)) + return PP_ERROR_INPROGRESS; + if (!id) + return PP_ERROR_BADARGUMENT; + + dest_ = id; + callback_ = callback; + + CallBrowser(PpapiHostMsg_FlashDeviceID_GetDeviceID()); + return PP_OK_COMPLETIONPENDING; +} + +void FlashDeviceIDResource::OnReplyReceived( + const ResourceMessageReplyParams& params, + const IPC::Message& msg) { + IPC_BEGIN_MESSAGE_MAP(FlashDeviceIDResource, msg) + PPAPI_DISPATCH_RESOURCE_REPLY( + PpapiPluginMsg_FlashDeviceID_GetDeviceIDReply, + OnPluginMsgGetDeviceIDReply) + IPC_END_MESSAGE_MAP() +} + +void FlashDeviceIDResource::OnPluginMsgGetDeviceIDReply( + const ResourceMessageReplyParams& params, + const std::string& id) { + if (params.result() == PP_OK) + *dest_ = StringVar::StringToPPVar(id); + else + *dest_ = PP_MakeUndefined(); + dest_ = NULL; + TrackedCallback::ClearAndRun(&callback_, params.result()); +} + +} // namespace proxy +} // namespace ppapi diff --git a/ppapi/proxy/flash_device_id_resource.h b/ppapi/proxy/flash_device_id_resource.h new file mode 100644 index 0000000..b563c80 --- /dev/null +++ b/ppapi/proxy/flash_device_id_resource.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 PPAPI_PROXY_FLASH_DEVICE_ID_RESOURCE_H_ +#define PPAPI_PROXY_FLASH_DEVICE_ID_RESOURCE_H_ + +#include "ppapi/proxy/plugin_resource.h" +#include "ppapi/proxy/ppapi_proxy_export.h" +#include "ppapi/shared_impl/tracked_callback.h" +#include "ppapi/thunk/ppb_flash_device_id_api.h" + +namespace ppapi { +namespace proxy { + +class FlashDeviceIDResource + : public PluginResource, + public thunk::PPB_Flash_DeviceID_API { + public: + FlashDeviceIDResource(Connection connection, + PP_Instance instance); + virtual ~FlashDeviceIDResource(); + + // Resource override. + virtual thunk::PPB_Flash_DeviceID_API* AsPPB_Flash_DeviceID_API() OVERRIDE; + + // PPB_Flash_DeviceID_API implementation. + virtual int32_t GetDeviceID(PP_Var* id, + scoped_refptr<TrackedCallback> callback) OVERRIDE; + + private: + // PluginResource override; + virtual void OnReplyReceived(const ResourceMessageReplyParams& params, + const IPC::Message& msg); + + // IPC message handler. + void OnPluginMsgGetDeviceIDReply(const ResourceMessageReplyParams& params, + const std::string& id); + + // Non-null when a callback is pending. + PP_Var* dest_; + + scoped_refptr<TrackedCallback> callback_; + + DISALLOW_COPY_AND_ASSIGN(FlashDeviceIDResource); +}; + +} // namespace proxy +} // namespace ppapi + +#endif // PPAPI_PROXY_FLASH_DEVICE_ID_RESOURCE_H_ diff --git a/ppapi/proxy/interface_list.cc b/ppapi/proxy/interface_list.cc index 129901c..d77c1cb 100644 --- a/ppapi/proxy/interface_list.cc +++ b/ppapi/proxy/interface_list.cc @@ -84,7 +84,6 @@ #include "ppapi/proxy/ppb_file_io_proxy.h" #include "ppapi/proxy/ppb_file_ref_proxy.h" #include "ppapi/proxy/ppb_file_system_proxy.h" -#include "ppapi/proxy/ppb_flash_device_id_proxy.h" #include "ppapi/proxy/ppb_flash_menu_proxy.h" #include "ppapi/proxy/ppb_flash_message_loop_proxy.h" #include "ppapi/proxy/ppb_flash_proxy.h" diff --git a/ppapi/proxy/ppapi_messages.h b/ppapi/proxy/ppapi_messages.h index cfdc984..2478b0f 100644 --- a/ppapi/proxy/ppapi_messages.h +++ b/ppapi/proxy/ppapi_messages.h @@ -1549,6 +1549,12 @@ IPC_MESSAGE_CONTROL4(PpapiHostMsg_FileChooser_Show, IPC_MESSAGE_CONTROL1(PpapiPluginMsg_FileChooser_ShowReply, std::vector<ppapi::PPB_FileRef_CreateInfo> /* files */) +// Flash device ID. +IPC_MESSAGE_CONTROL0(PpapiHostMsg_FlashDeviceID_Create) +IPC_MESSAGE_CONTROL0(PpapiHostMsg_FlashDeviceID_GetDeviceID) +IPC_MESSAGE_CONTROL1(PpapiPluginMsg_FlashDeviceID_GetDeviceIDReply, + std::string /* id */) + // Gamepad. IPC_MESSAGE_CONTROL0(PpapiHostMsg_Gamepad_Create) diff --git a/ppapi/proxy/ppb_flash_device_id_proxy.cc b/ppapi/proxy/ppb_flash_device_id_proxy.cc deleted file mode 100644 index bb66b33..0000000 --- a/ppapi/proxy/ppb_flash_device_id_proxy.cc +++ /dev/null @@ -1,126 +0,0 @@ -// 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 "ppapi/proxy/ppb_flash_device_id_proxy.h" - -#include "base/compiler_specific.h" -#include "ppapi/c/pp_errors.h" -#include "ppapi/proxy/plugin_dispatcher.h" -#include "ppapi/proxy/plugin_globals.h" -#include "ppapi/proxy/plugin_proxy_delegate.h" -#include "ppapi/proxy/ppapi_messages.h" -#include "ppapi/shared_impl/resource.h" -#include "ppapi/shared_impl/tracked_callback.h" -#include "ppapi/shared_impl/var.h" -#include "ppapi/thunk/enter.h" -#include "ppapi/thunk/ppb_flash_device_id_api.h" - -using ppapi::thunk::PPB_Flash_DeviceID_API; - -namespace ppapi { -namespace proxy { - -namespace { - -class DeviceID : public Resource, public PPB_Flash_DeviceID_API { - public: - DeviceID(PP_Instance instance); - virtual ~DeviceID(); - - // Resource overrides. - virtual PPB_Flash_DeviceID_API* AsPPB_Flash_DeviceID_API() OVERRIDE; - - // PPB_Flash_DeviceID_API implementation. - virtual int32_t GetDeviceID(PP_Var* id, - const PP_CompletionCallback& callback) OVERRIDE; - - void OnReply(int32_t result, const std::string& id); - - private: - // Non-null when a callback is pending. - PP_Var* dest_; - - scoped_refptr<TrackedCallback> callback_; - - DISALLOW_COPY_AND_ASSIGN(DeviceID); -}; - -DeviceID::DeviceID(PP_Instance instance) - : Resource(OBJECT_IS_PROXY, instance), - dest_(NULL) { -} - -DeviceID::~DeviceID() { -} - -PPB_Flash_DeviceID_API* DeviceID::AsPPB_Flash_DeviceID_API() { - return this; -} - -int32_t DeviceID::GetDeviceID(PP_Var* id, - const PP_CompletionCallback& callback) { - if (TrackedCallback::IsPending(callback_)) - return PP_ERROR_INPROGRESS; - if (!id) - return PP_ERROR_BADARGUMENT; - - callback_ = new TrackedCallback(this, callback); - dest_ = id; - - PluginDispatcher* dispatcher = - PluginDispatcher::GetForInstance(pp_instance()); - - PluginGlobals::Get()->plugin_proxy_delegate()->SendToBrowser( - new PpapiHostMsg_PPBFlashDeviceID_Get( - API_ID_PPB_FLASH_DEVICE_ID, dispatcher->plugin_dispatcher_id(), - pp_resource())); - return PP_OK_COMPLETIONPENDING; -} - -void DeviceID::OnReply(int32_t result, const std::string& id) { - if (result == PP_OK) - *dest_ = StringVar::StringToPPVar(id); - else - *dest_ = PP_MakeUndefined(); - dest_ = NULL; - TrackedCallback::ClearAndRun(&callback_, result); -} - -} // namespace - -PPB_Flash_DeviceID_Proxy::PPB_Flash_DeviceID_Proxy(Dispatcher* dispatcher) - : InterfaceProxy(dispatcher) { -} - -PPB_Flash_DeviceID_Proxy::~PPB_Flash_DeviceID_Proxy() { -} - -// static -PP_Resource PPB_Flash_DeviceID_Proxy::CreateProxyResource( - PP_Instance instance) { - return (new DeviceID(instance))->GetReference(); -} - -bool PPB_Flash_DeviceID_Proxy::OnMessageReceived(const IPC::Message& msg) { - bool handled = true; - IPC_BEGIN_MESSAGE_MAP(PPB_Flash_DeviceID_Proxy, msg) - IPC_MESSAGE_HANDLER(PpapiMsg_PPBFlashDeviceID_GetReply, - OnPluginMsgGetReply) - IPC_MESSAGE_UNHANDLED(handled = false) - IPC_END_MESSAGE_MAP() - return handled; -} - -void PPB_Flash_DeviceID_Proxy::OnPluginMsgGetReply(int32 routing_id, - PP_Resource resource, - int32 result, - const std::string& id) { - thunk::EnterResourceNoLock<PPB_Flash_DeviceID_API> enter(resource, false); - if (enter.failed()) - return; // Resource destroyed. - static_cast<DeviceID*>(enter.object())->OnReply(result, id); -} - -} // namespace proxy -} // namespace ppapi diff --git a/ppapi/proxy/ppb_flash_device_id_proxy.h b/ppapi/proxy/ppb_flash_device_id_proxy.h deleted file mode 100644 index f379873..0000000 --- a/ppapi/proxy/ppb_flash_device_id_proxy.h +++ /dev/null @@ -1,41 +0,0 @@ -// 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 PPAPI_PROXY_PPB_FLASH_DEVICE_ID_PROXY_H_ -#define PPAPI_PROXY_PPB_FLASH_DEVICE_ID_PROXY_H_ - -#include <string> - -#include "ppapi/c/pp_instance.h" -#include "ppapi/proxy/interface_proxy.h" - -namespace ppapi { -namespace proxy { - -class PPB_Flash_DeviceID_Proxy : public InterfaceProxy { - public: - PPB_Flash_DeviceID_Proxy(Dispatcher* dispatcher); - virtual ~PPB_Flash_DeviceID_Proxy(); - - static PP_Resource CreateProxyResource(PP_Instance instance); - - // InterfaceProxy implementation. - virtual bool OnMessageReceived(const IPC::Message& msg); - - static const ApiID kApiID = API_ID_PPB_FLASH_DEVICE_ID; - - private: - void OnPluginMsgGetReply(int32 routing_id, - PP_Resource resource, - int32 result, - const std::string& id); - - DISALLOW_COPY_AND_ASSIGN(PPB_Flash_DeviceID_Proxy); -}; - -} // namespace proxy -} // namespace ppapi - -#endif // PPAPI_PROXY_PPB_FLASH_DEVICE_ID_PROXY_H_ - diff --git a/ppapi/proxy/resource_creation_proxy.cc b/ppapi/proxy/resource_creation_proxy.cc index f24f86a..0981b82 100644 --- a/ppapi/proxy/resource_creation_proxy.cc +++ b/ppapi/proxy/resource_creation_proxy.cc @@ -9,6 +9,7 @@ #include "ppapi/c/trusted/ppb_image_data_trusted.h" #include "ppapi/proxy/connection.h" #include "ppapi/proxy/file_chooser_resource.h" +#include "ppapi/proxy/flash_device_id_resource.h" #include "ppapi/proxy/plugin_dispatcher.h" #include "ppapi/proxy/plugin_globals.h" #include "ppapi/proxy/plugin_proxy_delegate.h" @@ -21,7 +22,6 @@ #include "ppapi/proxy/ppb_file_io_proxy.h" #include "ppapi/proxy/ppb_file_ref_proxy.h" #include "ppapi/proxy/ppb_file_system_proxy.h" -#include "ppapi/proxy/ppb_flash_device_id_proxy.h" #include "ppapi/proxy/ppb_flash_menu_proxy.h" #include "ppapi/proxy/ppb_flash_message_loop_proxy.h" #include "ppapi/proxy/ppb_graphics_2d_proxy.h" @@ -303,7 +303,7 @@ PP_Resource ResourceCreationProxy::CreateFileChooser( } PP_Resource ResourceCreationProxy::CreateFlashDeviceID(PP_Instance instance) { - return PPB_Flash_DeviceID_Proxy::CreateProxyResource(instance); + return (new FlashDeviceIDResource(GetConnection(), instance))->GetReference(); } PP_Resource ResourceCreationProxy::CreateFlashMenu( diff --git a/ppapi/shared_impl/ppapi_permissions.h b/ppapi/shared_impl/ppapi_permissions.h index 4b1c6a6..8456fb7 100644 --- a/ppapi/shared_impl/ppapi_permissions.h +++ b/ppapi/shared_impl/ppapi_permissions.h @@ -19,7 +19,7 @@ enum Permission { // Allows ability to bypass user-gesture checks for showing things like // file select dialogs. - PERMISSION_BYPASS_USER_GESTURE = 1 << 3 + PERMISSION_BYPASS_USER_GESTURE = 1 << 3, // NOTE: If you add stuff be sure to update AllPermissions(). }; diff --git a/ppapi/thunk/interfaces_ppb_private_flash.h b/ppapi/thunk/interfaces_ppb_private_flash.h index 7226020..8ec049a 100644 --- a/ppapi/thunk/interfaces_ppb_private_flash.h +++ b/ppapi/thunk/interfaces_ppb_private_flash.h @@ -46,8 +46,7 @@ PROXIED_IFACE(PPB_Flash, PPB_FLASH_FILE_FILEREF_INTERFACE, PPB_Flash_File_FileRef) -PROXIED_API(PPB_Flash_DeviceID) -PROXIED_IFACE(PPB_Flash_DeviceID, +PROXIED_IFACE(NoAPIName, PPB_FLASH_DEVICEID_INTERFACE_1_0, PPB_Flash_DeviceID_1_0) diff --git a/ppapi/thunk/ppb_flash_device_id_api.h b/ppapi/thunk/ppb_flash_device_id_api.h index ae31abd..cbd1bf5 100644 --- a/ppapi/thunk/ppb_flash_device_id_api.h +++ b/ppapi/thunk/ppb_flash_device_id_api.h @@ -2,7 +2,13 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. +#include "base/memory/ref_counted.h" +#include "ppapi/thunk/ppapi_thunk_export.h" + namespace ppapi { + +class TrackedCallback; + namespace thunk { class PPAPI_THUNK_EXPORT PPB_Flash_DeviceID_API { @@ -10,7 +16,7 @@ class PPAPI_THUNK_EXPORT PPB_Flash_DeviceID_API { virtual ~PPB_Flash_DeviceID_API() {} virtual int32_t GetDeviceID(PP_Var* id, - const PP_CompletionCallback& callback) = 0; + scoped_refptr<TrackedCallback> callback) = 0; }; } // namespace thunk diff --git a/ppapi/thunk/ppb_flash_device_id_thunk.cc b/ppapi/thunk/ppb_flash_device_id_thunk.cc index 9275648..498df75 100644 --- a/ppapi/thunk/ppb_flash_device_id_thunk.cc +++ b/ppapi/thunk/ppb_flash_device_id_thunk.cc @@ -26,7 +26,7 @@ int32_t GetDeviceID(PP_Resource resource, EnterResource<PPB_Flash_DeviceID_API> enter(resource, callback, true); if (enter.failed()) return enter.retval(); - return enter.SetResult(enter.object()->GetDeviceID(id, callback)); + return enter.SetResult(enter.object()->GetDeviceID(id, enter.callback())); } const PPB_Flash_DeviceID g_ppb_flash_deviceid_thunk = { |